openclacky 1.3.5 → 1.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a7474760c07220891bc62795e95ab0f5b9f83387b4881e1cc9eec4133545222
-  data.tar.gz: '099b846d3a8b44af563403c05f5bc8c855b0925122aabeb3f01b77f8f0c8d18f'
+  metadata.gz: 45a64960de249e34ee18e67f0ce38888b510a886988d545c58aca558d942bbdb
+  data.tar.gz: '008d7b7bec8fd7edf43cb9848949637d23783d2ad3a8a2b6199010f9b8ed660d'
 SHA512:
-  metadata.gz: e494c9032f35cf631a91dbbff72c89004c1aa8991a6f630dc21c65a9d97b45bceb2afa9c69b2f25b0d4c0e909d317b64eff5ed7b972fd475edc2f19e81a2f779
-  data.tar.gz: 7fb32e090e6cfd780cd0b4218bbfb00a0f939ce77089cc124e35d03a8870abdbb27f09de976304526b8e905d14107fc861914ba08f80d447a72e4d24a6711c8f
+  metadata.gz: 2f0e9c3fb21691cf9bbfdd6820faaaed86086bebb820278b6104356f92fec4c0e53584a8c3ca40bfd42fb7f82e1f3a484ed404c2b693a47467e9c43d517ed9e8
+  data.tar.gz: 83cb1fa9ac5a3ae4834bf5c02c344da9db09a5863a4970857f2d233656c66d9b20fde131f0af4b04d23e204a09a978968ae7d2310ae1c3c3ceb8bcb6d721e3c2

data/CHANGELOG.md

@@ -5,6 +5,18 @@ 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/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.3.6] - 2026-06-30
+
+### Added
+- Cron task session isolation with independent pagination and stable task count
+- Backup/restore UI in settings with WebSocket reconnect refresh and WSL open-folder support
+
+### Fixed
+- Rewrite human-readable cron parser to handle comma-separated lists, hour ranges, and `*/1` normalization
+- Setup submit button hover color follows accent theme variable
+- Settings button no longer navigates away when already on settings page
+- Use Unix epoch for old thread timestamps to avoid date parsing issues
+
 ## [1.3.5] - 2026-06-29
 
 ### Added

data/lib/clacky/agent/message_compressor.rb

@@ -39,10 +39,14 @@ module Clacky
 
       REQUIRED RESPONSE FORMAT:
       First output a <topics> line listing 3-6 key topic phrases (comma-separated, concise).
+      Then output a <continues_previous> line: "true" if this conversation is a direct
+      continuation of the SAME task/topic as the PREVIOUS chunk shown below, "false" if it
+      has moved on to a different task or topic. If there is no previous chunk, output "false".
       Then output the full summary wrapped in <summary> tags.
 
       Example format:
       <topics>Rails setup, database config, deploy pipeline, Tailwind CSS</topics>
+      <continues_previous>false</continues_previous>
       <summary>
       ...full summary text...
       </summary>
@@ -54,7 +58,8 @@ module Clacky
       - Errors encountered and fixes applied
       - Current work status and pending tasks
 
-      Begin your response NOW. Remember: PURE TEXT only, starting with <topics> then <summary>.
+      Begin your response NOW. Remember: PURE TEXT only, starting with <topics> then
+      <continues_previous> then <summary>.
     PROMPT
 
     def initialize(client, model: nil)
@@ -72,18 +77,25 @@ module Clacky
     #
     # @param messages [Array<Hash>] Original conversation messages
     # @param recent_messages [Array<Hash>] Recent messages to keep uncompressed (optional)
+    # @param previous_topics [String, nil] Topics of the most recent chunk on disk,
+    #   shown to the LLM so it can decide whether the current conversation is a
+    #   continuation (drives the <continues_previous> output for chunk merging).
     # @return [Hash] Compression instruction message to insert, or nil if nothing to compress
-    def build_compression_message(messages, recent_messages: [])
+    def build_compression_message(messages, recent_messages: [], previous_topics: nil)
       # Get messages to compress (exclude system message and recent messages)
       messages_to_compress = messages.reject { |m| m[:role] == "system" || recent_messages.include?(m) }
 
       # If nothing to compress, return nil
       return nil if messages_to_compress.empty?
 
-      # Simple compression instruction - LLM can see the history already
-      { 
-        role: "user", 
-        content: COMPRESSION_PROMPT,
+      content = COMPRESSION_PROMPT
+      if previous_topics && !previous_topics.strip.empty?
+        content = "#{COMPRESSION_PROMPT}\n\nPREVIOUS CHUNK TOPICS (for <continues_previous> judgement): #{previous_topics}"
+      end
+
+      {
+        role: "user",
+        content: content,
         system_injected: true
       }
     end
@@ -142,6 +154,15 @@ module Clacky
       m ? m[1].strip : nil
     end
 
+    # Parse the <continues_previous> tag. Returns true only when the LLM
+    # explicitly says "true"; missing tag or any other value → false.
+    # This conservative default ensures we never merge unless the model is sure.
+    def parse_continues_previous(content)
+      return false if content.nil? || content.to_s.empty?
+      m = content.to_s.match(/<continues_previous>(.*?)<\/continues_previous>/m)
+      m ? m[1].strip.downcase == "true" : false
+    end
+
     def parse_compressed_result(result, chunk_path: nil, topics: nil, previous_chunks: [])
       # Return the compressed result as a single user message (role: "user").
       #
@@ -171,8 +192,11 @@ module Clacky
       if content.empty?
         []
       else
-        # Strip out the <topics> block — it's metadata for the chunk file, not for AI context
-        content_without_topics = content.gsub(/<topics>.*?<\/topics>\n*/m, "").strip
+        # Strip out the <topics> and <continues_previous> blocks — they're
+        # metadata for chunk handling, not for AI context.
+        content_without_topics = content.gsub(/<topics>.*?<\/topics>\n*/m, "")
+                                        .gsub(/<continues_previous>.*?<\/continues_previous>\n*/m, "")
+                                        .strip
 
         # Build previous chunks index section — links to older chunk files so the AI
         # can find earlier conversations without keeping all prior compressed_summary

data/lib/clacky/agent/message_compressor_helper.rb

@@ -193,8 +193,18 @@ module Clacky
         recent_messages = get_recent_messages_with_tool_pairs(all_messages, target_recent_count)
         recent_messages = [] if recent_messages.nil?
 
+        # Surface the most recent chunk's topics so the compression LLM can judge
+        # whether this conversation continues the same task (drives chunk merging).
+        previous_topics = nil
+        if @session_id && @created_at
+          latest = session_manager.chunks_for_current(@session_id, @created_at).last
+          previous_topics = latest && latest[:topics]
+        end
+
         # Build compression instruction message (to be inserted into conversation)
-        compression_message = @message_compressor.build_compression_message(all_messages, recent_messages: recent_messages)
+        compression_message = @message_compressor.build_compression_message(
+          all_messages, recent_messages: recent_messages, previous_topics: previous_topics
+        )
 
         return nil if compression_message.nil?
 
@@ -242,25 +252,52 @@ module Clacky
         # all chunk file I/O (naming, writing, discovery) — we just ask it.
         sm = session_manager
         existing_chunks = sm.chunks_for_current(@session_id, @created_at)
-        chunk_index = sm.next_chunk_index(@session_id, @created_at)
 
         # Extract topics from the LLM response to store in both the chunk MD front
         # matter and the compressed_summary message hash (for future chunk indexing).
         topics = @message_compressor.parse_topics(compressed_content)
 
-        chunk_path = save_compressed_chunk(
-          original_messages,
-          compression_context[:recent_messages],
-          chunk_index: chunk_index,
-          compression_level: compression_context[:compression_level],
-          topics: topics
-        )
+        # Decide whether to MERGE into the previous chunk or create a NEW one.
+        # The LLM judges (via <continues_previous>) whether this conversation is a
+        # direct continuation of the previous chunk's task. Merging avoids tiny
+        # fragmented chunks (e.g. a long task compressed mid-flight into 2-message
+        # chunks) that pollute the topics index and degrade recall.
+        latest_chunk = existing_chunks.last
+        continues = latest_chunk && @message_compressor.parse_continues_previous(compressed_content)
+
+        if continues
+          chunk_path = merge_into_previous_chunk(
+            latest_chunk,
+            original_messages,
+            compression_context[:recent_messages],
+            compression_level: compression_context[:compression_level],
+            topics: topics
+          )
+          # Fallback to new chunk if the merge could not be performed.
+          chunk_path ||= save_compressed_chunk(
+            original_messages, compression_context[:recent_messages],
+            chunk_index: sm.next_chunk_index(@session_id, @created_at),
+            compression_level: compression_context[:compression_level], topics: topics
+          )
+          # The merged chunk is the current chunk — exclude it from previous_chunks.
+          index_chunks = existing_chunks.reject { |c| c[:index] == latest_chunk[:index] }
+        else
+          chunk_index = sm.next_chunk_index(@session_id, @created_at)
+          chunk_path = save_compressed_chunk(
+            original_messages,
+            compression_context[:recent_messages],
+            chunk_index: chunk_index,
+            compression_level: compression_context[:compression_level],
+            topics: topics
+          )
+          index_chunks = existing_chunks
+        end
 
         # Build previous_chunks index from the disk-discovered chunks (already
         # sorted by index ascending). This gives the new summary a complete
         # chronological index of all older archives so the AI can recall any
         # past chunk via file_reader, not just the most recent one.
-        previous_chunks = existing_chunks.map do |c|
+        previous_chunks = index_chunks.map do |c|
           { basename: c[:basename], path: c[:path], topics: c[:topics] }
         end
 
@@ -483,6 +520,62 @@ module Clacky
         nil
       end
 
+      # Merge the current batch of compressed messages INTO an existing chunk
+      # (overwrite-in-place, same chunk index). Used when the LLM judged this
+      # conversation as a continuation of the previous chunk's task. Keeps the
+      # archive on a single, growing, well-formed chunk instead of fragmenting
+      # into tiny standalone files that pollute the topics index.
+      #
+      # Every write hits disk immediately, so a crash never loses archived
+      # messages — there is no in-memory buffering.
+      #
+      # @param prev_chunk [Hash] disk-discovered chunk hash ({ index:, path:, topics: })
+      # @return [String, nil] the chunk path on success, nil if merge not possible
+      def merge_into_previous_chunk(prev_chunk, original_messages, recent_messages, compression_level:, topics: nil)
+        return nil unless @session_id && @created_at
+
+        recent_set = recent_messages.to_a
+        messages_to_archive = original_messages.reject do |m|
+          m[:role] == "system" || m[:system_injected] || m[:compressed_summary] || recent_set.include?(m)
+        end
+        return nil if messages_to_archive.empty?
+
+        sm = session_manager
+        raw = sm.read_chunk(prev_chunk[:path])
+        return nil unless raw
+
+        fm, body = sm.split_chunk_md(raw)
+        return nil unless fm
+
+        new_sections = render_message_sections(messages_to_archive)
+
+        fm["compression_level"] = compression_level.to_s
+        fm["archived_at"]       = Time.now.iso8601
+        fm["message_count"]     = (fm["message_count"].to_i + messages_to_archive.size).to_s
+        fm["merged_count"]      = (fm.fetch("merged_count", "1").to_i + 1).to_s
+        fm["topics"]            = merge_topics(fm["topics"], topics)
+
+        lines = ["---"]
+        fm.each { |k, v| lines << "#{k}: #{v}" }
+        lines << "---"
+        lines << body.rstrip
+        lines << ""
+        lines.concat(new_sections)
+
+        sm.write_chunk(@session_id, @created_at, prev_chunk[:index], lines.join("\n"))
+      rescue => e
+        @ui&.log("Failed to merge chunk MD: #{e.message}", level: :warn)
+        nil
+      end
+
+      # Union two comma-separated topic strings, preserving order, dropping dups.
+      private def merge_topics(existing, incoming)
+        a = (existing || "").split(/\s*,\s*/).map(&:strip).reject(&:empty?)
+        b = (incoming || "").split(/\s*,\s*/).map(&:strip).reject(&:empty?)
+        merged = (a + b).uniq
+        merged.empty? ? nil : merged.join(", ")
+      end
+
       # Build markdown content from a list of messages
       # @param messages [Array<Hash>] Messages to render
       # @param chunk_index [Integer] Chunk number for metadata
@@ -508,6 +601,15 @@ module Clacky
         lines << "> Use `file_reader` to recall specific details from this conversation."
         lines << ""
 
+        lines.concat(render_message_sections(messages))
+
+        lines.join("\n")
+      end
+
+      # Render messages into chunk MD body sections (no front matter / header).
+      # Shared by build_chunk_md and the chunk-merge path.
+      def render_message_sections(messages)
+        lines = []
         messages.each do |msg|
           role = msg[:role]
           content = msg[:content]
@@ -560,8 +662,7 @@ module Clacky
             lines << ""
           end
         end
-
-        lines.join("\n")
+        lines
       end
 
       # Format message content (handles string or array of content blocks)

data/lib/clacky/agent.rb

@@ -683,9 +683,6 @@ module Clacky
         raise
       ensure
         # Safety net: ensure any lingering progress spinner is stopped.
-        # Normal paths close their own spinners; this guards against exceptions
-        # raised between a progress slot's active/done pair.
-        Clacky::Logger.warn("[ph_debug] agent_run_ensure")
         @ui&.show_progress(phase: "done")
 
         # Fire-and-forget telemetry after every agent run.

data/lib/clacky/cli.rb

@@ -654,7 +654,6 @@ module Clacky
 
       # Handle agent error/interrupt with cleanup
       def handle_agent_exception(ui_controller, agent, session_manager, exception)
-        Clacky::Logger.warn("[ph_debug] handle_agent_exception", klass: exception.class.name, msg: exception.message.to_s[0, 200])
         ui_controller.show_progress(phase: "done")
         ui_controller.set_idle_status