openclacky 1.5.13 → 1.5.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca259b2f17df9695e21c4d4c4f18ee83affec0fc41d67db829d903e1c3bb008d
-  data.tar.gz: b0bfd31378c6b452a7aef246d3d316242a91fa6366f543c45edcff8c3f44ac6c
+  metadata.gz: 87ba4a4c52b1e52b0af0aad921bac4b8addd3d95955f44442894753ffd73ad14
+  data.tar.gz: 0a861cf43fcecc64275cb243029f7cc621ac32dfab949e0768aadfaf7e0f9490
 SHA512:
-  metadata.gz: cfcb5b28264aeb2acb6b121b89c395e4e9241b3a3135c2e9fb7d565365ed263c701f939448a2c01cb229359cca11402b36b081d4edff6231ce8e46e72d253498
-  data.tar.gz: 95cca310ebd8e0a23b1f1e5aed241b6e5fbc19aa206fdb16301dfd3b90f07e33424a44686c10b2d6cf4d3344c75eab2c033d7b3e4e7ef6c9a40b7879dd07a88b
+  metadata.gz: 1b476b0c9ef80a39ac6830c35cac601abb5086d639d2806fc473af3a9074af25449f6f8befeea54bc07e38571e484f4012150d3a53adef674534f8b89ca8771e
+  data.tar.gz: 5ee52bb903109343a3a7adb9dc3681be836e22dd43f1b12021def3b32383c205b3750283b3af357f0e01b580ad1f5a8e2507c9f6133789b4813378e5a56120b3

data/CHANGELOG.md

@@ -4,6 +4,57 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
+## [1.5.14] - 2026-09-10
+
+### Added
+- Add a click-driven live preview panel for workspace files and localhost dev servers
+- Open local files in the preview panel via file:// URLs and bare absolute paths
+- Add GPT-5.6 Sol/Terra/Luna and GPT-6 Astra models with Global CRIS pricing
+- Add the deepseek-flash model
+- Add an editable Chinese metadata form and field-level frontmatter update API for skills
+- Add a /think reasoning-effort switcher to the TUI
+- Render CSV/TSV files as read-only tables in the workspace
+- Add Parallel Free as the primary built-in web-search provider
+- Select text in a message and quote it into the composer (#526 - @kylezhang)
+- Syntax-highlight code in the file viewer
+- Send large STT audio as base64 JSON (#525 - @tomash)
+- Add a Files panel open-with menu, tree toggle, split preview, and in-menu download
+- Detect Windows apps for open-with in WSL
+- Skip registering the browser tool when it is disabled
+- Auto-snapshot the page after browser actions
+- Truncate long working directories in the session info bar
+- Highlight width-drag handles on hover
+
+### Improved
+- Switch the default model to Gemini 3.8 Flash
+- Use single-pane navigation on mobile (C-5779) (#539)
+- Polish the chat navigator layout and hover interactions (#527)
+- Improve message navigation in long conversations (#523)
+- Refine the billing tooltip UX (C-5778) (#537)
+- Let the git panel fill the aside height and free up diff width (#531)
+
+### Fixed
+- Restore the aside width after closing file previews (#545)
+- Replace undefined danger tokens with the error color variable (#542 - @sundevilyang)
+- Add hover and disabled feedback to danger and secondary buttons (#541, #540 - @sundevilyang)
+- Correct DeepSeek v4-pro and flash pricing
+- Collapse extension actions into a menu on narrow screens (C-5781) (#538)
+- Don't submit argumented commands on Enter
+- Scroll overflow menus and pin config action buttons
+- Sniff binary content before text preview (C-5690) (#535)
+- Require a slash prefix for channel help commands (C-5641) (#533)
+- Normalize the homepage URL scheme on read (C-5666) (#534)
+- Decode non-ASCII paths in git panel output (C-5777) (#530)
+- Refresh the file tree on working-dir switch and task completion
+- Harden extension developer guidance and manifest validation (#524)
+- Fix zip file encoding errors
+- Resolve file://~/ tilde paths from chat links
+- Align the open-button icon
+
+### More
+- Move the preview tab to the end of the left-nav order
+- Extract provider id constants to replace magic strings
+
 ## [1.5.13] - 2026-09-03
 
 ### Added

data/lib/clacky/agent/chunk_index.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Clacky
+  class Agent
+    # Byte ranges only: no message bodies, tool outputs or persistent sidecars.
+    module ChunkIndex
+      private def chunk_section_header(line, directory)
+        if (match = line.match(/\A## Assistant \[Compressed Summary — original conversation at: (.+)\]/))
+          { role: "assistant", nested_chunk: File.join(directory, match[1]) }
+        elsif (match = line.match(/\A## (User|Assistant)(?: \[Task ([1-9]\d*)\])?\z/))
+          { role: match[1].downcase, task_id: match[2]&.to_i }
+        elsif line.start_with?("### Tool Result:")
+          { role: "tool" }
+        end
+      end
+
+      private def chunk_file_version(path)
+        stat = File.stat(path)
+        [stat.size, stat.mtime.to_f, stat.ctime.to_f].join(":")
+      rescue Errno::ENOENT
+        "missing"
+      end
+
+      private def chunk_navigation_index(path)
+        version = chunk_file_version(path)
+        @chunk_index_mutex ||= Mutex.new
+        @chunk_index_mutex.synchronize do
+          @chunk_indexes ||= {}
+          cached = @chunk_indexes[path]
+          return cached if cached && cached[:version] == version
+
+          index = version == "missing" ? { rounds: [], nested: [], section_count: 0 } : scan_chunk_index(path)
+          raise ArgumentError, "History changed while indexing" unless chunk_file_version(path) == version
+
+          @chunk_indexes[path] = index.merge(version: version)
+        end
+      end
+
+      private def scan_chunk_index(path)
+        rounds = []
+        nested = []
+        section_count = 0
+        user_start = nil
+        archived_at = nil
+        front_matter = false
+        directory = File.dirname(path)
+        position = 0
+        File.open(path, "rb") do |file|
+          while (line = file.gets)
+            start = position
+            position += line.bytesize
+            text = line.force_encoding(Encoding::UTF_8).scrub.chomp
+            if start.zero? && text == "---"
+              front_matter = true
+            elsif front_matter
+              front_matter = false if text == "---"
+              archived_at = (Time.parse(text.split(":", 2).last.strip) rescue nil) if text.start_with?("archived_at:")
+            end
+            header = chunk_section_header(text, directory)
+            if header
+              section_count += 1
+              nested << header[:nested_chunk] if header[:nested_chunk]
+              user_start = header[:role] == "user" ? start : nil
+            elsif user_start && !text.strip.empty?
+              # Match replay's empty/metadata-only user handling without
+              # retaining the rest of the user message or any assistant text.
+              visible, events = extract_ext_events_from_text(text)
+              visible, files = extract_display_files_from_text(visible)
+              next if visible.empty? && events.empty? && files.empty?
+
+              rounds.last[:length] = user_start - rounds.last[:start] if rounds.any?
+              rounds << { start: user_start }
+              user_start = nil
+            end
+          end
+          rounds.last[:length] = position - rounds.last[:start] if rounds.any?
+        end
+        { rounds: rounds, nested: nested, section_count: section_count,
+          base_time: (archived_at || File.mtime(path)).to_f }
+      end
+    end
+  end
+end

data/lib/clacky/agent/history_navigation.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+module Clacky
+  class Agent
+    # Read-only navigation: locations at startup, bounded previews on demand.
+    module HistoryNavigation
+      NAVIGATION_PREVIEW_LENGTH = 400
+      NAVIGATION_PREVIEW_BATCH_LIMIT = 30
+
+      def history_navigation
+        sources = navigation_sources
+        manifest = sources.map do |source|
+          entry = { key: source[:key], version: source[:version], count: navigation_source_count(source),
+                    volatile: !!source[:rounds] || source[:continuation].to_a.any? }
+          entry[:identities] = source[:rounds].map { |round| round[:user_msg].values_at(:created_at, :task_id) } if source[:rounds]
+          entry
+        end
+        { sources: manifest, total: manifest.sum { |source| source[:count] } }
+      end
+
+      def history_navigation_preview(id:)
+        history_navigation_previews(ids: [id]).fetch(0)
+      end
+
+      def history_navigation_previews(ids:)
+        ids = Array(ids)
+        if ids.length > NAVIGATION_PREVIEW_BATCH_LIMIT
+          raise ArgumentError, "Too many history locations"
+        end
+
+        sources = navigation_sources
+        ids.map do |id|
+          source_index, offset = navigation_position(sources, id)
+          unless offset && offset < navigation_source_count(sources[source_index])
+            raise ArgumentError, "History location is no longer available"
+          end
+          navigation_entry(navigation_source_rounds(sources, source_index, offset: offset, limit: 1).fetch(0))
+        end
+      end
+
+      def replay_history_window(ui, limit: 30, around: nil, before_id: nil, after_id: nil)
+        sources = navigation_sources
+        anchor = around || before_id || after_id
+        source_index, offset = anchor ? navigation_position(sources, anchor) : [sources.length - 1, nil]
+        count = navigation_source_count(sources[source_index])
+        offset ||= count
+        raise ArgumentError, "History location is no longer available" if anchor && offset >= count
+
+        # Around starts at the requested round; before/after are exclusive.
+        forward = !!(around || after_id)
+        offset += 1 if after_id
+        page = []
+        index = source_index
+        while index.between?(0, sources.length - 1) && page.length < limit
+          count = navigation_source_count(sources[index])
+          if forward
+            first = index == source_index ? offset : 0
+            page.concat(navigation_source_rounds(sources, index, offset: first, limit: limit - page.length))
+            index += 1
+          else
+            last = index == source_index ? offset : count
+            first = [last - (limit - page.length), 0].max
+            page = navigation_source_rounds(sources, index, offset: first, limit: last - first) + page
+            index -= 1
+          end
+        end
+
+        if page.empty? && !anchor
+          @history.to_a.each do |message|
+            next if message[:role].to_s == "system" || message[:system_injected]
+            _replay_single_message(message, ui)
+          end
+        else
+          replay_rounds(ui, page)
+        end
+        first = page.first&.dig(:navigation_id)
+        last = page.last&.dig(:navigation_id)
+        first_pos = first && navigation_position(sources, first)
+        last_pos = last && navigation_position(sources, last)
+        has_before = first_pos && (first_pos[1].positive? || first_pos[0].positive?)
+        has_after = last_pos && (last_pos[1] < navigation_source_count(sources[last_pos[0]]) - 1 ||
+          ((last_pos[0] + 1)...sources.length).any? { |i| navigation_source_count(sources[i]).positive? })
+        {
+          has_more: !!has_before, has_after: !!has_after,
+          before_cursor: first, after_cursor: last,
+          round_ids: page.map { |round| round[:navigation_id] }
+        }
+      end
+
+      private def real_history_user?(msg)
+        return false unless msg[:role].to_s == "user" && !msg[:system_injected]
+
+        content = msg[:content]
+        if content.is_a?(String)
+          !content.start_with?("[SYSTEM]")
+        elsif content.is_a?(Array)
+          content.any? { |block| block.is_a?(Hash) && %w[text image image_url].include?((block[:type] || block["type"]).to_s) }
+        else
+          false
+        end
+      end
+
+      private def navigation_sources
+        messages = @history.to_a
+        rounds = []
+        leading = []
+        chunks = []
+        messages.each do |msg|
+          if real_history_user?(msg)
+            rounds << { user_msg: msg, events: [], editable: true }
+          elsif msg[:compressed_summary]
+            paths = if msg[:chunk_path].to_s.empty?
+              session_manager.chunks_for_current(@session_id, @created_at).map { |chunk| chunk[:path] }
+            else
+              sibling_chunks_of(msg[:chunk_path])
+            end
+            chunks.concat(paths)
+          elsif rounds.empty?
+            leading << msg unless msg[:role].to_s == "system" || msg[:system_injected]
+          else
+            rounds.last[:events] << msg
+          end
+        end
+        sources = []
+        visited = Set.new
+        top_level = chunks.map { |path| File.basename(path) }.to_set
+        append_source = lambda do |path|
+          path = File.join(Clacky::SessionManager::SESSIONS_DIR, File.basename(path)) unless File.exist?(path)
+          path = File.expand_path(path)
+          next unless visited.add?(path)
+
+          index = chunk_navigation_index(path)
+          # Legacy nested references precede this source's own rounds. Sibling
+          # chunks already enumerated above must not be counted twice.
+          index[:nested].reverse_each do |nested|
+            append_source.call(nested) unless top_level.include?(File.basename(nested))
+          end
+          sources << { key: File.basename(path), path: path, version: index[:version], index: index }
+        end
+        chunks.uniq.each { |path| append_source.call(path) }
+        @chunk_index_mutex&.synchronize { @chunk_indexes&.delete_if { |path, _| !visited.include?(path) } }
+        last_archive = sources.reverse_each.find { |source| navigation_source_count(source).positive? }
+        last_archive[:continuation] = leading if last_archive
+        version = rounds.map { |round| round[:user_msg].values_at(:created_at, :task_id) }.hash.to_s
+        sources << { key: "live", rounds: rounds, version: version }
+        sources
+      end
+
+      private def navigation_source_count(source)
+        source[:rounds] ? source[:rounds].length : source[:index][:rounds].length
+      end
+
+      private def navigation_id(source, offset)
+        identity = source[:rounds] && offset && source[:rounds][offset]&.dig(:user_msg)&.values_at(:created_at, :task_id)
+        JSON.generate([source[:key], offset, source[:version], identity])
+      end
+
+      private def navigation_position(sources, id)
+        key, offset, version, identity = JSON.parse(id)
+        index = sources.index { |source| source[:key] == key }
+        if index && key == "live" && version != sources[index][:version] && identity.is_a?(Array) && identity.any?
+          matches = sources[index][:rounds].each_index.select do |i|
+            sources[index][:rounds][i][:user_msg].values_at(:created_at, :task_id) == identity
+          end
+          if matches.one?
+            offset = matches.first
+            version = sources[index][:version]
+          end
+        end
+        unless index && sources[index][:version] == version && (offset.nil? || (offset.is_a?(Integer) && offset >= 0))
+          raise ArgumentError, "History location is no longer available"
+        end
+        [index, offset]
+      rescue JSON::ParserError, TypeError
+        raise ArgumentError, "Invalid history location"
+      end
+
+      private def navigation_source_rounds(sources, index, offset: 0, limit: nil)
+        source = sources.fetch(index)
+        count = navigation_source_count(source)
+        length = [limit || count, count - offset].min
+        return [] unless length.positive?
+
+        siblings = sources.filter_map { |entry| entry[:key] if entry[:path] && entry != source }.to_set
+        rounds = if source[:rounds]
+          source[:rounds].slice(offset, length)
+        else
+          ranges = source[:index][:rounds]
+          first = ranges[offset]
+          last = ranges[offset + length - 1]
+          range = { start: first[:start], length: last[:start] + last[:length] - first[:start] }
+          result = parse_chunk_md_to_rounds(source[:path], excluded_paths: siblings, byte_range: range,
+            index: source[:index], round_offset: offset)
+          unless chunk_file_version(source[:path]) == source[:version] && result.length == length
+            raise ArgumentError, "History changed while reading"
+          end
+          result
+        end
+        if rounds.any? && offset + length == count && source[:continuation]
+          rounds.last[:events].concat(source[:continuation])
+        end
+        rounds.each { |round| round[:events].reject! { |event| event[:compressed_summary] } }
+        rounds.each_with_index do |round, position|
+          round[:navigation_id] = navigation_id(source, offset + position)
+        end
+        rounds
+      end
+
+      private def navigation_entry(round)
+        msg = round[:user_msg]
+        user = navigation_preview(msg[:display_text] || extract_text_from_content(msg[:content]))
+        if user.empty?
+          names = Array(msg[:display_files]).map { |file| file[:name] || file["name"] }
+          Array(msg[:content]).each do |block|
+            next unless block.is_a?(Hash) && %w[image image_url].include?((block[:type] || block["type"]).to_s)
+            names << (block[:image_name] || block["image_name"] || "image")
+          end
+          user = navigation_preview(names.compact.join(", "))
+        end
+        # A final reply is the last main-agent response, with no pending tool
+        # work. Earlier narration, reasoning and nested subagent transcripts
+        # must never be substituted for a missing final response.
+        last = round[:events].reverse.find do |event|
+          !event[:system_injected] && !event[:compressed_summary] &&
+            %w[assistant tool].include?(event[:role].to_s)
+        end
+        final = last && last[:role].to_s == "assistant" && !last[:interim] && Array(last[:tool_calls]).empty?
+        answer = final ? navigation_preview(extract_text_from_content(last[:content])) : ""
+        { id: round[:navigation_id], created_at: msg[:created_at], archived: round[:editable] == false,
+          user: user, assistant: answer }
+      end
+
+      private def navigation_preview(text)
+        text.to_s.gsub(/<think>.*?(?:<\/think>|\z)/m, "")
+          .strip[0, NAVIGATION_PREVIEW_LENGTH]
+      end
+    end
+  end
+end

data/lib/clacky/agent/session_serializer.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
 require "strscan"
+require_relative "history_navigation"
+require_relative "chunk_index"
 
 module Clacky
   class Agent
     # Session serialization for saving and restoring agent state
     # Handles session data serialization and deserialization
     module SessionSerializer
+      include HistoryNavigation
+      include ChunkIndex
       # Restore from a saved session
       # @param session_data [Hash] Saved session data
       def restore_session(session_data)
@@ -289,77 +293,8 @@ module Clacky
       #   created_at < before. Pass nil to get the most recent rounds.
       # @return [Hash] { has_more: Boolean } — whether older rounds exist beyond this page
       def replay_history(ui, limit: 20, before: nil)
-        # Split @history into rounds, each starting at a real user message
-        rounds = []
-        current_round = nil
-
-        @history.to_a.each do |msg|
-          role = msg[:role].to_s
-
-          # A real user message can have either a String content or an Array content
-          # (Array = multipart: text + image blocks). Exclude system-injected messages
-          # and synthetic [SYSTEM] text messages.
-          is_real_user_msg = role == "user" && !msg[:system_injected] &&
-            if msg[:content].is_a?(String)
-              !msg[:content].start_with?("[SYSTEM]")
-            elsif msg[:content].is_a?(Array)
-              # Must contain at least one text or image block (not a tool_result array).
-              # "image_url" covers image-only messages (user sent a picture with no
-              # accompanying text); without it such messages start no round and get
-              # dropped on replay, making the image vanish on session reopen.
-              msg[:content].any? { |b| b.is_a?(Hash) && %w[text image image_url].include?(b[:type].to_s) }
-            else
-              false
-            end
-
-          if is_real_user_msg
-            # Start a new round at each real user message.
-            # editable: true — this message still lives in the active in-memory
-            # @history, so truncate_from_created_at can locate and truncate it.
-            current_round = { user_msg: msg, events: [], editable: true }
-            rounds << current_round
-          elsif current_round
-            current_round[:events] << msg
-          elsif msg[:compressed_summary]
-            # Compressed summary sitting before any user rounds — expand ALL chunk
-            # MD files that belong to the same session (siblings of chunk_path),
-            # in chunk-index ascending order.
-            #
-            # Under the current "single summary + previous_chunks index" scheme,
-            # session.json only keeps the newest compressed_summary message (which
-            # points at the newest chunk). Older chunks (chunk-1..chunk-N-1) are
-            # referenced only as basenames inside the summary text. Expanding just
-            # msg[:chunk_path] would therefore lose all prior chunks on replay.
-            #
-            # chunk_path may be blank when a hot restart's SIGKILL killed the
-            # worker after the chunk file was written but before its path was
-            # persisted into session.json. Fall back to discovering the chunks
-            # on disk from session_id + created_at so the history is not lost.
-            chunk_paths = if msg[:chunk_path].to_s.empty?
-              session_manager.chunks_for_current(@session_id, @created_at).map { |c| c[:path] }
-            else
-              sibling_chunks_of(msg[:chunk_path])
-            end
-            chunk_rounds = chunk_paths.flat_map { |p| parse_chunk_md_to_rounds(p) }
-            rounds.concat(chunk_rounds)
-            # After expanding, treat the last chunk round as the current round so that
-            # any orphaned assistant/tool messages that follow in session.json (belonging
-            # to the same task whose user message was compressed into the chunk) get
-            # appended here instead of being silently discarded.
-            current_round = rounds.last unless chunk_rounds.empty?
-          elsif rounds.last
-            # Orphaned non-user message with no current_round yet (e.g. recent_messages
-            # after compression started mid-task with no leading user message).
-            # Attach to the last known round rather than drop silently.
-            rounds.last[:events] << msg
-          end
-        end
-
-        # Expand any compressed_summary assistant messages sitting inside a round's events.
-        # These occur when compression happened mid-round (rare) — expand them in-place.
-        rounds.each do |round|
-          round[:events].select! { |ev| !ev[:compressed_summary] }
-        end
+        sources = navigation_sources
+        rounds = sources.each_index.flat_map { |index| navigation_source_rounds(sources, index) }
 
         # Apply before-cursor filter: only rounds whose user message created_at < before
         if before
@@ -379,6 +314,11 @@ module Clacky
         # Take the most recent `limit` rounds
         page = rounds.last(limit)
 
+        replay_rounds(ui, page)
+        { has_more: has_more }
+      end
+
+      private def replay_rounds(ui, page)
         page.each do |round|
           msg = round[:user_msg]
           raw_text    = msg[:display_text] || extract_text_from_content(msg[:content])
@@ -410,7 +350,6 @@ module Clacky
           end
         end
 
-        { has_more: has_more }
       end
 
       # Return all chunk MD file paths that belong to the same session as
@@ -446,7 +385,8 @@ module Clacky
       #
       # @param chunk_path [String] Path to the chunk md file
       # @return [Array<Hash>] rounds array (may be empty if file missing/unreadable)
-      private def parse_chunk_md_to_rounds(chunk_path, visited: Set.new)
+      private def parse_chunk_md_to_rounds(chunk_path, visited: Set.new, excluded_paths: Set.new,
+                                          byte_range: nil, index: nil, round_offset: 0)
         return [] unless chunk_path
 
         # 1. Try the stored absolute path first (same machine, normal case).
@@ -468,7 +408,14 @@ module Clacky
 
         # Scrub invalid UTF-8 bytes defensively — chunk files written before
         # the 0.9.37 fix may contain poisoned bytes from file_reader results.
-        raw = File.read(resolved).then do |s|
+        raw = (if byte_range
+          File.open(resolved, "rb") do |file|
+            file.seek(byte_range[:start])
+            file.read(byte_range[:length]).to_s.force_encoding(Encoding::UTF_8)
+          end
+        else
+          File.read(resolved)
+        end).then do |s|
           s.encoding == Encoding::UTF_8 && s.valid_encoding? ? s :
             s.encode("UTF-8", invalid: :replace, undef: :replace, replace: "\u{FFFD}")
         end
@@ -486,7 +433,7 @@ module Clacky
             end
           end
         end
-        base_time = (archived_at || Time.now).to_f
+        base_time = index ? index[:base_time] : (archived_at || File.mtime(resolved)).to_f
         chunk_dir = File.dirname(chunk_path.to_s)
 
         # Split into sections by ## headings
@@ -498,25 +445,12 @@ module Clacky
 
         raw.each_line do |line|
           stripped = line.chomp
-          if (m = stripped.match(/\A## Assistant \[Compressed Summary — original conversation at: (.+)\]/))
-            # Nested chunk reference — record it, treat as assistant section
+          if (header = chunk_section_header(stripped, chunk_dir))
             sections << { role: current_role, lines: current_lines.dup, nested_chunk: current_nested_chunk, task_id: current_task_id } if current_role
-            current_role         = "assistant"
+            current_role         = header[:role]
             current_lines        = []
-            current_nested_chunk = File.join(chunk_dir, m[1])
-            current_task_id      = nil
-          elsif (m = stripped.match(/\A## (User|Assistant)(?: \[Task ([1-9]\d*)\])?\z/))
-            sections << { role: current_role, lines: current_lines.dup, nested_chunk: current_nested_chunk, task_id: current_task_id } if current_role
-            current_role         = m[1].downcase
-            current_lines        = []
-            current_nested_chunk = nil
-            current_task_id      = m[2]&.to_i
-          elsif stripped.match?(/\A### Tool Result:/)
-            sections << { role: current_role, lines: current_lines.dup, nested_chunk: current_nested_chunk, task_id: current_task_id } if current_role
-            current_role         = "tool"
-            current_lines        = []
-            current_nested_chunk = nil
-            current_task_id      = nil
+            current_nested_chunk = header[:nested_chunk]
+            current_task_id      = header[:task_id]
           else
             current_lines << line
           end
@@ -538,11 +472,15 @@ module Clacky
 
           # Nested chunk: expand it recursively, prepend before current rounds
           if sec[:nested_chunk]
-            nested = parse_chunk_md_to_rounds(sec[:nested_chunk], visited: visited)
+            nested = if excluded_paths.include?(File.basename(sec[:nested_chunk]))
+              []
+            else
+              parse_chunk_md_to_rounds(sec[:nested_chunk], visited: visited, excluded_paths: excluded_paths)
+            end
             rounds = nested + rounds unless nested.empty?
             # Also render its summary text as an assistant event in current round if any
             if current_round && !text.empty?
-              current_round[:events] << { role: "assistant", content: text }
+              current_round[:events] << { role: "assistant", content: text, compressed_summary: true }
             end
             next
           end
@@ -552,7 +490,7 @@ module Clacky
           if sec[:role] == "user"
             round_index += 1
             # Synthetic timestamp: spread rounds backwards from archived_at
-            synthetic_ts = base_time - (sections.size - round_index) * 1.0
+            synthetic_ts = base_time - ((index ? index[:section_count] : sections.size) - round_offset - round_index) * 1.0
             user_msg = {
               role: "user",
               content: text,
@@ -594,7 +532,9 @@ module Clacky
 
               # Flush any plain text
               plain_text = remaining_lines.join.strip
-              current_round[:events] << { role: "assistant", content: plain_text } unless plain_text.empty?
+              unless plain_text.empty?
+                current_round[:events] << { role: "assistant", content: plain_text, interim: !pending_tool_entries.empty? }
+              end
 
               # Emit one synthetic tool_calls message per detected tool
               pending_tool_entries.each do |entry|
@@ -774,7 +714,8 @@ module Clacky
             else
               raw_text
             end
-            ui.show_assistant_message(text, files: [], created_at: msg[:created_at])
+            ui.show_assistant_message(text, files: [], created_at: msg[:created_at],
+                                      interim: !!msg[:interim] || Array(msg[:tool_calls]).any?)
           end
 
           # Tool calls embedded in assistant message