openclacky 1.0.0.beta.5 → 1.0.0.beta.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39e25cd04a3d01fdacbb0382c2c367a1e72e8d2be88408e7fb29f804b3af1ba6
-  data.tar.gz: 492ca66bcfb55a6cfc3f2cf38f171ce983f142a7a4b0f8655e5aafa317b79a69
+  metadata.gz: afc12c94c2b8b7580ca948625cc6c106004bbf385f341c783e36e1be9d93fd82
+  data.tar.gz: 95508d829f02270b3fce4849b21e29b6766a46d9c663d47e37df817aed456da5
 SHA512:
-  metadata.gz: 014eeb8227bcc4cd94104a1da3bb2877083a1c70c4baaaf408233eec57ef684cbc2bcbac632ca52a771e2f1a8f436f2a09d89b697a165f1147891cabfe3708a0
-  data.tar.gz: cc54f77d960bfd2db73906b713a84d0da6465fc18c65d9ec3ceb75d250bf426adaf4d9ba42c71900beab889bb6acf6a6472fa3843420fec8bbd3460a13f00088
+  metadata.gz: 8f44be2b9d9bf26f97490f5ddf2525a6cad937c5152b8486bb2840a263ab104cacfa5838600236b3a38a6806e69cd717fbce982838f2c2a65664158b0b4ed238
+  data.tar.gz: aecb14f4b6f345d190e52de0c0816f380b4e6c3213453c9e69a04b78944f757115e8a1ac042b0a78398e79d27de65190f4c0cb61d1efe3c224416b6a2f55f6c6

data/CHANGELOG.md

@@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.0.0.beta.6] - 2026-04-30
+
+### Fixed
+- **Compression chunk indexing now uses disk-based discovery.** Chunk files are no longer incorrectly overwritten after the second compression. Previously, chunk index was counted from compressed_summary messages in history — which caps at 1 after rebuild — causing chunk-2.md to be overwritten on every subsequent compression. Now uses durable disk-based chunk discovery via SessionManager, ensuring all compressed chunks are preserved.
+- **Skill evolution no longer creates duplicate skills.** The reflect and auto-create scenarios in skill evolution are now mutually exclusive: when a skill was just used, only reflection runs; when no skill was used, only auto-creation is considered. This prevents near-duplicate "auto-*" skills from being extracted from tasks already served by an existing skill.
+
+### Improved
+- **Slash commands no longer misinterpret filesystem paths.** Pasted paths like `/Users/alice/foo` or `/tmp/bar` are no longer mistaken for slash commands, avoiding confusing "skill not found" notices.
+
 ## [1.0.0.beta.5] - 2026-04-29
 
 ### Added

data/lib/clacky/agent/message_compressor_helper.rb

@@ -154,12 +154,22 @@ module Clacky
         # Note: we need to remove the compression instruction message we just added
         original_messages = @history.to_a[0..-2]  # All except the last (compression instruction)
 
-        # Archive compressed messages to a chunk MD file before discarding them
-        # Count existing compressed_summary messages in history to determine the next chunk index.
-        # Using @compressed_summaries.size would reset to 0 on process restart and overwrite existing
-        # chunk files, creating circular chunk references. Counting from history is always accurate.
-        existing_chunk_count = original_messages.count { |m| m[:compressed_summary] }
-        chunk_index = existing_chunk_count + 1
+        # Archive compressed messages to a chunk MD file before discarding them.
+        #
+        # IMPORTANT: chunk_index and previous_chunks MUST come from disk, not from
+        # message history. Each compression's rebuild_with_compression keeps only
+        # ONE compressed_summary message (the new one), dropping older summaries
+        # and embedding their references into the new summary's content. So
+        # counting compressed_summary messages in history caps at 1 from the
+        # second compression onward — causing chunk-2.md to be overwritten on
+        # every subsequent compression, and losing references to chunk-1.md.
+        #
+        # Disk is the only durable source of truth: chunk files survive process
+        # restarts, session reloads, and message rebuilds. SessionManager owns
+        # 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).
@@ -173,14 +183,13 @@ module Clacky
           topics: topics
         )
 
-        # Collect previous chunk references so the new summary carries a complete
-        # index of all older archives. Without this, each new compression would
-        # lose all prior chunk references — leaving only the newest chunk reachable
-        # via replay_history. The AI can still access older chunks via file_reader
-        # using the embedded basenames and topics.
-        previous_chunks = original_messages
-          .select { |m| m[:compressed_summary] && m[:chunk_path] }
-          .map { |m| { basename: File.basename(m[:chunk_path]), path: m[:chunk_path], topics: m[:topics] } }
+        # 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|
+          { basename: c[:basename], path: c[:path], topics: c[:topics] }
+        end
 
         @history.replace_all(@message_compressor.rebuild_with_compression(
           compressed_content,
@@ -348,8 +357,22 @@ module Clacky
         end
       end
 
-      # Save the messages being compressed to a chunk MD file for future recall
-      # File path: ~/.clacky/sessions/{datetime}-{short_id}-chunk-{n}.md
+      # Lazy accessor for a SessionManager instance used by compression chunk I/O.
+      # We keep this local to the helper rather than threading a manager instance
+      # through the Agent constructor — Agent itself doesn't persist sessions
+      # (CLI / HTTP server do that), but the compression archive lives in the
+      # same directory under SessionManager's ownership.
+      #
+      # NOTE: Uses Clacky::SessionManager::SESSIONS_DIR by default. Tests can
+      # stub that constant to point at a tmpdir.
+      private def session_manager
+        @session_manager ||= Clacky::SessionManager.new
+      end
+
+      # Save the messages being compressed to a chunk MD file for future recall.
+      # The filesystem concerns (path, write, chmod) are delegated to SessionManager;
+      # this method is responsible only for the business rules of WHAT gets archived.
+      #
       # @param original_messages [Array<Hash>] All messages before compression (excluding compression instruction)
       # @param recent_messages [Array<Hash>] Recent messages being kept (to exclude from chunk)
       # @param chunk_index [Integer] Sequential chunk number
@@ -373,19 +396,14 @@ module Clacky
 
         return nil if messages_to_archive.empty?
 
-        sessions_dir = Clacky::SessionManager::SESSIONS_DIR
-        datetime = Time.parse(@created_at).strftime("%Y-%m-%d-%H-%M-%S")
-        short_id = @session_id[0..7]
-        base_name = "#{datetime}-#{short_id}"
-        chunk_filename = "#{base_name}-chunk-#{chunk_index}.md"
-        chunk_path = File.join(sessions_dir, chunk_filename)
-
-        md_content = build_chunk_md(messages_to_archive, chunk_index: chunk_index, compression_level: compression_level, topics: topics)
-
-        File.write(chunk_path, md_content)
-        FileUtils.chmod(0o600, chunk_path)
+        md_content = build_chunk_md(messages_to_archive,
+                                    chunk_index: chunk_index,
+                                    compression_level: compression_level,
+                                    topics: topics)
 
-        chunk_path
+        # Delegate filesystem concerns (path assembly, write, chmod) to SessionManager —
+        # it owns the on-disk layout for sessions and their chunk archives.
+        session_manager.write_chunk(@session_id, @created_at, chunk_index, md_content)
       rescue => e
         @ui&.log("Failed to save chunk MD: #{e.message}", level: :warn)
         nil

data/lib/clacky/agent/skill_evolution.rb

@@ -10,16 +10,31 @@ module Clacky
     # Triggered at the end of Agent#run (post-run hooks), only for main agents.
     module SkillEvolution
       # Main entry point - runs all skill evolution checks
-      # Called from Agent#run after the main loop completes
+      # Called from Agent#run after the main loop completes.
+      #
+      # The two scenarios are mutually exclusive by design:
+      #
+      #   * If a skill just ran (@skill_execution_context is set), the user's
+      #     need was already served by an existing skill. Run Scenario 2
+      #     (reflect + possibly improve that skill) and skip Scenario 1 —
+      #     otherwise we would auto-extract a near-duplicate "auto-*" skill
+      #     from the same task, polluting the skills directory.
+      #
+      #   * If no skill ran, the task was solved with raw tools. That is the
+      #     signal for Scenario 1: if the pattern is complex/repeatable enough,
+      #     consider extracting it into a new skill.
       def run_skill_evolution_hooks
         return unless skill_evolution_enabled?
         return if @is_subagent
 
-        # Scenario 2: Reflect on executed skill (if one just ran)
-        maybe_reflect_on_skill if @skill_execution_context
-
-        # Scenario 1: Auto-create new skill from complex task
-        maybe_create_skill_from_task
+        if @skill_execution_context
+          # Scenario 2: Reflect on executed skill (may invoke skill-creator
+          # to UPDATE the existing skill, but will not create a new one).
+          maybe_reflect_on_skill
+        else
+          # Scenario 1: Auto-create new skill from complex task.
+          maybe_create_skill_from_task
+        end
       end
 
       # Check if skill evolution is enabled in config

data/lib/clacky/agent/skill_manager.rb

@@ -33,12 +33,46 @@ module Clacky
       def parse_skill_command(input)
         return { matched: false } unless input.start_with?("/")
 
-        match = input.match(%r{^/(\S+)(?:\s+(.*))?$})
+        # Split off the first whitespace-delimited token after the leading "/".
+        # Shape of a slash command:
+        #   /<command>
+        #   /<command> <arguments...>
+        #
+        # The key distinction we need to make is "slash command" vs. "filesystem
+        # path starting with /". Paths look like "/xxx/yyy", "/Users/alice/foo",
+        # "/tmp/bar" — what they all share is a *second* "/" inside the first
+        # token. Slash commands, on the other hand, may legitimately contain
+        # non-slug characters like ':' or '.' (e.g. "/guizang-ppt-skill:create"),
+        # so we deliberately DO NOT require the command to be a clean slug here —
+        # find_by_command handles the lookup, and a pilot-error like "/foo.bar"
+        # should still surface a friendly "skill not found" notice.
+        #
+        # Rejected as slash commands (treated as plain user messages):
+        #   - "/", "//", "/*.rb"        — token is empty or begins with a separator/glob
+        #   - "/ leading space"         — whitespace immediately after /
+        #   - "/Users/alice/foo"        — second "/" inside the first token ⇒ a path
+        #   - "/xxxx/zzzz/"             — same
+        #
+        # Accepted (routed to find_by_command, may yield :not_found notice):
+        #   - "/commit"
+        #   - "/skill-add https://…"     — "/" appears only in arguments, fine
+        #   - "/guizang-ppt-skill:create", "/foo.bar"  — non-slug but no path shape
+        match = input.match(%r{^/(\S+?)(?:\s+(.*))?$})
         return { matched: false } unless match
 
         skill_name = match[1]
         arguments  = match[2] || ""
 
+        # Reject path-like first tokens: anything containing a "/" after the
+        # leading one belongs to the filesystem, not the command namespace.
+        # This also naturally rejects "" (from "/" alone) and "*…" / ".…" style
+        # tokens because they won't be registered as a command — but those edge
+        # cases fall through to :not_found which is acceptable. The main goal is
+        # to stop pasted paths like "/Users/foo/bar" from producing a bogus
+        # "skill /Users/foo/bar not found" reply.
+        return { matched: false } if skill_name.include?("/")
+        return { matched: false } if skill_name.empty?
+
         skill = @skill_loader.find_by_command("/#{skill_name}")
         return { matched: true, found: false, skill_name: skill_name, reason: :not_found } unless skill
 

data/lib/clacky/session_manager.rb

@@ -84,6 +84,67 @@ module Clacky
       { session: session, json_path: json_path, chunks: chunks }
     end
 
+    # ── Chunk file I/O (for conversation compression archives) ────────────────
+    #
+    # The SessionManager is the single owner of sessions/{base}-chunk-N.md
+    # file naming, writing, discovery, and deletion. Everything else in the
+    # codebase (MessageCompressorHelper, SessionSerializer) should go through
+    # these methods rather than building paths or scanning the directory
+    # directly — this keeps the on-disk layout under one roof and makes it
+    # easy to evolve (e.g. add encryption, switch to a DB).
+
+    # Discover all chunk MD files on disk for a given session.
+    # Returns them sorted by chunk index ascending (oldest first).
+    #
+    # @param session_id [String] full session id (or at least first 8 chars)
+    # @param created_at [String] ISO-8601 timestamp used in the base filename
+    # @return [Array<Hash>] each with :index, :path, :basename, :topics
+    def chunks_for_current(session_id, created_at)
+      return [] unless session_id && created_at
+
+      base = chunk_base_name(session_id, created_at)
+      pattern = File.join(@sessions_dir, "#{base}-chunk-*.md")
+
+      Dir.glob(pattern).filter_map do |path|
+        basename = File.basename(path)
+        # Extract integer index from "<base>-chunk-<N>.md"
+        m = basename.match(/-chunk-(\d+)\.md\z/)
+        next nil unless m
+
+        {
+          index: m[1].to_i,
+          path: path,
+          basename: basename,
+          topics: read_chunk_topics(path)
+        }
+      end.sort_by { |c| c[:index] }
+    end
+
+    # Next unused chunk index for a session, derived from disk.
+    # This is the ONLY correct way to compute the next chunk index —
+    # counting compressed_summary messages in history caps at 1 after the
+    # second compression (rebuild keeps only the latest summary) and
+    # in-memory counters reset on process restart.
+    def next_chunk_index(session_id, created_at)
+      existing = chunks_for_current(session_id, created_at)
+      (existing.map { |c| c[:index] }.max || 0) + 1
+    end
+
+    # Write a chunk MD file to disk. Returns the absolute path.
+    # Caller is responsible for generating the MD content — this method
+    # only handles filesystem concerns (path assembly, write, chmod).
+    def write_chunk(session_id, created_at, chunk_index, md_content)
+      return nil unless session_id && created_at
+
+      base = chunk_base_name(session_id, created_at)
+      chunk_path = File.join(@sessions_dir, "#{base}-chunk-#{chunk_index}.md")
+
+      File.write(chunk_path, md_content)
+      FileUtils.chmod(0o600, chunk_path)
+
+      chunk_path
+    end
+
     # All sessions from disk, newest-first (sorted by created_at).
     # Optional filters:
     #   current_dir: (String) if given, sessions matching working_dir come first
@@ -141,9 +202,52 @@ module Clacky
     end
 
     def generate_filename(session_id, created_at)
+      "#{chunk_base_name(session_id, created_at)}.json"
+    end
+
+    # Base name (without extension) shared by a session's .json file and its
+    # chunk-N.md archive files. Kept as a single source of truth so chunk
+    # I/O stays consistent with the session filename.
+    private def chunk_base_name(session_id, created_at)
       datetime = Time.parse(created_at).strftime("%Y-%m-%d-%H-%M-%S")
       short_id = session_id[0..7]
-      "#{datetime}-#{short_id}.json"
+      "#{datetime}-#{short_id}"
+    end
+
+    # Read the `topics:` field from a chunk MD file's YAML-like front matter.
+    # Only scans the first ~20 lines — front matter is tiny and we don't
+    # want to read megabytes of archived conversation just to grab one line.
+    # Returns nil if the file is missing, unreadable, or has no topics.
+    private def read_chunk_topics(path)
+      return nil unless File.exist?(path)
+
+      lines = []
+      File.open(path, "r") do |f|
+        20.times do
+          line = f.gets
+          break if line.nil?
+          lines << line
+        end
+      end
+
+      in_front_matter = false
+      lines.each do |line|
+        stripped = line.strip
+        if stripped == "---"
+          break if in_front_matter
+          in_front_matter = true
+          next
+        end
+        next unless in_front_matter
+
+        if (m = stripped.match(/\Atopics:\s*(.+)\z/))
+          topics = m[1].strip
+          return topics.empty? ? nil : topics
+        end
+      end
+      nil
+    rescue
+      nil
     end
 
     # Delete a session JSON file and all its associated chunk MD files.

data/lib/clacky/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Clacky
-  VERSION = "1.0.0.beta.5"
+  VERSION = "1.0.0.beta.6"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openclacky
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta.5
+  version: 1.0.0.beta.6
 platform: ruby
 authors:
 - windy