openclacky 1.5.23 → 1.5.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b5f420c625379fad464ab7f88912b46d3c8bfd17dbb14c58274ed0841d0039e
-  data.tar.gz: 6f8df699a2a7097348bba112445687429b17aa2617f1265ad83107a1aa7778fd
+  metadata.gz: 0de5997e8f1b998b5e57c588e232c0bbb6f96664f9dcd2c36ff2577d566b445b
+  data.tar.gz: 25108838302b0137589a14b320ee7374202a1601c897333fc1cb632226366462
 SHA512:
-  metadata.gz: 462d32d168319ebc8d1366636ffe7cbcd5df1d748334180e12e688928f9abd72a8c7e8887ee8d3fb71c269a835fdd014a7bf8387fc6aeff5b2b98ca40833d217
-  data.tar.gz: e74fdb9dfdc042b922544f6eb80f0a7b6c029d25f6e5e15a841ee8277aa32830c5dcd733a049cc9225851689d18d66665e9301480ffb3c0875dc6e644b582484
+  metadata.gz: ecaa16a7b3a69d5932b0f878abc9fa0d0a6fe0c10898eb509a3ad92959a90f5bfb78e2610b55608bd5687128de48b587f11e0b2aff29b4c00629093704020afe
+  data.tar.gz: 54c69db9fcbe7aa5e34eca12a5c1171f893fff2d8833a0c99814eb7a50dcdc91388f04758f81cfb1041facf2bb7698d85ce7e5245a33911d26c6117aeb03b2af

data/CHANGELOG.md

@@ -4,6 +4,52 @@ 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.24] - 2026-11-13
+
+### Added
+- Stream assistant replies as they are written
+- Point first-time users at Settings with a hint
+- Add a first-run hint on the model picker in the session info bar
+- Recall relevant memories automatically before each message (opt-in)
+- Collapse the Config and My Data sidebar sections
+- Preview files an AI turn leaves in the system temp directory
+- Dismiss the OpenClacky AI Keys promo and keep it dismissed
+- Show progress while packing and downloading a backup
+- Add model hints for audio, speech-to-text and video understanding
+- Add Claude Fable 5.2 to the hosted model picker
+- Give the secretary extension an icon and a detail page
+- Let extensions follow WebSocket events and run before the first think
+
+### Improved
+- Unify the settings section headings and their icons
+- Tighten the long-term memory write rules so stored facts stay worth keeping
+- Keep the memories listing compact and flag the files it leaves out
+- Move Web Search above Network in the general tab
+- Keep memories timestamped by file mtime
+- Use the shared tooltip on memory and recycle-bin row actions
+- Stream backup restore uploads instead of buffering them
+- Reveal overlong project names on hover
+- Rename auto recall to plainer wording
+
+### Fixed
+- Switch sessions with one click in Safari
+- Keep backend text in the client's language
+- Rewrite hosted-platform file references to local links
+- Render non-media image references as plain links instead of broken thumbnails
+- Show media with a single inline reference
+- Keep dropdown lists inside the viewport
+- Keep the flipped new-session popover glued to its chip
+- Localise the channel platform names
+- Open channel setup in the session that started it
+- Keep the git panel diffs rendered when switching layout
+- Pin the git panel file header while scrolling a long diff
+- Order the git panel diff stream like the file tree
+- Show actionable browser toggle state and errors in settings
+- Stop the scheduled tasks view from opening with no active menu item
+
+### More
+- Move GLM 5.3 and Kimi K3 to the end of the model picker
+
 ## [1.5.23] - 2026-11-06
 
 ### Added

data/lib/clacky/agent/cost_tracker.rb

@@ -34,42 +34,7 @@ module Clacky
       # @param raw_api_usage [Hash, nil] Raw API usage data for debugging
       # @param model [String, nil] Model name to use for billing (defaults to current_model)
       def track_cost(usage, raw_api_usage: nil, model: nil)
-        # Priority 1: Use API-provided cost if available (OpenRouter, LiteLLM, etc.)
-        iteration_cost = nil
-        if usage[:api_cost]
-          add_cost(usage[:api_cost])
-          @cost_source = :api
-          @task_cost_source = :api
-          iteration_cost = usage[:api_cost]
-          @ui&.log("Using API-provided cost: $#{usage[:api_cost]}", level: :debug) if @config.verbose
-        else
-          # Priority 2: Calculate from tokens using ModelPricing
-          # Use provided model name (from API call time) to ensure accurate billing
-          # even if the user switches models during the API call
-          billing_model = model || current_model
-          result = ModelPricing.calculate_cost(model: billing_model, usage: usage)
-          cost = result[:cost]
-          pricing_source = result[:source]
-
-          # Only accumulate cost when the model has known pricing.
-          # Unknown models return nil — display N/A, don't add to total.
-          if cost
-            add_cost(cost)
-            iteration_cost = cost
-            @cost_source = pricing_source
-            @task_cost_source = pricing_source
-          end
-
-          if @config.verbose
-            if cost
-              source_label = pricing_source == :price ? "model pricing" : "default pricing"
-              @ui&.log("Calculated cost for #{@config.model_name} using #{source_label}: $#{cost.round(6)}", level: :debug)
-            else
-              @ui&.log("No pricing data available for #{@config.model_name} — cost is unknown", level: :debug)
-            end
-            @ui&.log("Usage breakdown: prompt=#{usage[:prompt_tokens]}, completion=#{usage[:completion_tokens]}, cache_write=#{usage[:cache_creation_input_tokens] || 0}, cache_read=#{usage[:cache_read_input_tokens] || 0}", level: :debug)
-          end
-        end
+        iteration_cost = accumulate_cost(usage, model)
 
         # Collect token usage data for this iteration (returned to caller for deferred display)
         token_data = collect_iteration_tokens(usage, iteration_cost)
@@ -127,6 +92,60 @@ module Clacky
         token_data
       end
 
+      # Bill a side LLM call (e.g. the memory picker) into the session total.
+      # Unlike track_cost it leaves @previous_total_tokens and the cache stats
+      # alone: those describe the main conversation and drive compression.
+      # @return [Float, nil] cost of the call, nil when pricing is unknown
+      def track_auxiliary_cost(usage, model:)
+        cost = accumulate_cost(usage, model)
+        unless @is_subagent
+          @ui&.update_sessionbar(cost: @total_cost, cost_source: @cost_source)
+          persist_billing_record(usage, cost, model: model)
+        end
+        cost
+      end
+
+      # Add one call's cost to the running total.
+      # @return [Float, nil] the call's cost, nil when pricing is unknown
+      private def accumulate_cost(usage, model)
+        # Priority 1: Use API-provided cost if available (OpenRouter, LiteLLM, etc.)
+        if usage[:api_cost]
+          add_cost(usage[:api_cost])
+          @cost_source = :api
+          @task_cost_source = :api
+          @ui&.log("Using API-provided cost: $#{usage[:api_cost]}", level: :debug) if @config.verbose
+          return usage[:api_cost]
+        end
+
+        # Priority 2: Calculate from tokens using ModelPricing
+        # Use provided model name (from API call time) to ensure accurate billing
+        # even if the user switches models during the API call
+        billing_model = model || current_model
+        result = ModelPricing.calculate_cost(model: billing_model, usage: usage)
+        cost = result[:cost]
+        pricing_source = result[:source]
+
+        # Only accumulate cost when the model has known pricing.
+        # Unknown models return nil — display N/A, don't add to total.
+        if cost
+          add_cost(cost)
+          @cost_source = pricing_source
+          @task_cost_source = pricing_source
+        end
+
+        if @config.verbose
+          if cost
+            source_label = pricing_source == :price ? "model pricing" : "default pricing"
+            @ui&.log("Calculated cost for #{billing_model} using #{source_label}: $#{cost.round(6)}", level: :debug)
+          else
+            @ui&.log("No pricing data available for #{billing_model} — cost is unknown", level: :debug)
+          end
+          @ui&.log("Usage breakdown: prompt=#{usage[:prompt_tokens]}, completion=#{usage[:completion_tokens]}, cache_write=#{usage[:cache_creation_input_tokens] || 0}, cache_read=#{usage[:cache_read_input_tokens] || 0}", level: :debug)
+        end
+
+        cost
+      end
+
       # Persist a billing record to the billing store
       # @param usage [Hash] Usage data from API
       # @param cost [Float, nil] Calculated cost for this iteration

data/lib/clacky/agent/hook_manager.rb

@@ -10,6 +10,7 @@ module Clacky
       :on_start,
       :on_complete,
       :on_iteration,
+      :before_think,
       :session_rollback
     ].freeze
 
@@ -39,6 +40,8 @@ module Clacky
     # display/countdown. It may extend questions, display context and model-only
     # answer_context in place; answer_context is never sent to UI subscribers.
     # return values are ignored. Keep work bounded; no separate UI events.
+    # before_think receives (agent) after steering, before model reasoning.
+    # Its return value is ignored, like other observation/preparation hooks.
     def trigger(event, *args)
       validate_event!(event)
       # Keep payload hashes positional: Ruby 2.6 otherwise promotes their keys
@@ -51,7 +54,7 @@ module Clacky
           callback_args = [*args, @agent]
           callback_args << context.dup if context
           hook_result = hook.call(*callback_args)
-          next if [:on_complete, :prepare_feedback].include?(event)
+          next if [:on_complete, :prepare_feedback, :before_think].include?(event)
           next unless hook_result.is_a?(Hash)
           # First deny wins and stops the chain: a weaker later verdict must
           # never clobber a stronger earlier one, and the first deny's reason

data/lib/clacky/agent/llm_caller.rb

@@ -45,7 +45,8 @@ module Clacky
       #   Inside call_llm we only *update in place* during retries, so the
       #   already-live progress slot shows meaningful transient status
       #   ("Network failed… attempt 2/10", etc.).
-      private def call_llm(agent_upstream_fails: nil, agent_upgrade_fails: nil)
+      # Only user-facing replies opt in; compression calls stay silent.
+      private def call_llm(agent_upstream_fails: nil, agent_upgrade_fails: nil, stream_reply: false)
         # Transition :fallback_active → :probing if cooling-off has expired.
         @config.maybe_start_probing
         refresh_client_if_card_changed!
@@ -118,17 +119,20 @@ module Clacky
             @history.to_api(force_reasoning_content_pad: force_reasoning_content_pad)
           end
 
-          response = @client.send_messages_with_tools(
-            messages_to_send,
-            model: api_call_model,
-            tools: tools_to_send,
-            max_tokens: @config.max_tokens,
-            enable_caching: @config.enable_prompt_caching,
-            reasoning_effort: @reasoning_effort,
-            on_chunk: build_progress_on_chunk,
-            agent_upstream_fails: (agent_upstream_fails || 0) + floor_fails,
-            agent_upgrade_fails: (agent_upgrade_fails || 0) + upgrade_fails
-          )
+          response = with_assistant_text_stream(enabled: stream_reply) do |on_text_delta|
+            @client.send_messages_with_tools(
+              messages_to_send,
+              model: api_call_model,
+              tools: tools_to_send,
+              max_tokens: @config.max_tokens,
+              enable_caching: @config.enable_prompt_caching,
+              reasoning_effort: @reasoning_effort,
+              on_chunk: build_progress_on_chunk,
+              **(on_text_delta ? { on_text_delta: on_text_delta } : {}),
+              agent_upstream_fails: (agent_upstream_fails || 0) + floor_fails,
+              agent_upgrade_fails: (agent_upgrade_fails || 0) + upgrade_fails
+            )
+          end
 
           # Successful response — if we were probing, confirm primary is healthy.
           handle_probe_success if @config.probing?
@@ -841,6 +845,36 @@ module Clacky
         )
       end
 
+      # Each attempt owns a preview. Always close it, including cancellation and retry.
+      private def with_assistant_text_stream(enabled: true)
+        return yield(nil) unless enabled
+        return yield(nil) unless @ui && @ui.respond_to?(:stream_assistant_text?) && @ui.stream_assistant_text?
+
+        message_id = SecureRandom.uuid
+        seq = 0
+        pending = +""
+        last_emit = 0.0
+        flush = lambda do
+          unless pending.empty?
+            seq += 1
+            @ui.show_assistant_delta(message_id: message_id, seq: seq, delta: pending.dup)
+            pending.clear
+            last_emit = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          end
+        end
+        callback = lambda do |text|
+          pending << text
+          flush.call if Process.clock_gettime(Process::CLOCK_MONOTONIC) - last_emit >= 0.05
+        end
+        begin
+          result = yield(callback)
+          flush.call
+          result
+        ensure
+          @ui.end_assistant_stream(message_id: message_id)
+        end
+      end
+
       # Build a streaming progress callback for Client#send_messages_with_tools.
       # Returns nil when no UI is attached, so the client skips the streaming
       # plumbing entirely. Callback throttles UI updates to avoid flooding the

data/lib/clacky/agent/memory_injector.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Clacky
+  class Agent
+    # Automatic long-term memory injection (opt-in: memory_inject_enabled).
+    #
+    # Before each user message a picker model (the provider's lite model, else
+    # the primary) selects relevant files from a wide memories listing
+    # (+load_memories_meta+); their bodies are appended as a system_injected
+    # user message. Append-only keeps the prompt-cache prefix intact. Files
+    # already injected on the active task chain are skipped; compression drops
+    # those messages, which naturally allows re-injection later.
+    #
+    # Best-effort: any failure is logged and the turn proceeds without memories.
+    module MemoryInjector
+      MEMORY_INJECT_MAX_FILES = 3
+      MEMORY_INJECT_FILE_BYTES = 4096
+      MEMORY_INJECT_STALE_DAYS = 30
+      MEMORY_PICKER_PREV_REPLY_CHARS = 600
+      MEMORY_PICKER_USER_CHARS = 2000
+      # Thinking models spend part of this budget on reasoning; 200 truncated the JSON.
+      MEMORY_PICKER_MAX_TOKENS = 1024
+      MEMORY_PICKER_READ_TIMEOUT = 20
+      # The picker can't grep, so it needs a far wider view than the
+      # 20-file LRU shortlist the recall/persist skills get.
+      MEMORY_PICKER_LISTING_LIMIT = 200
+
+      MEMORY_PICKER_SYSTEM_PROMPT = <<~PROMPT
+        You select long-term memory files relevant to the user's latest message.
+        A memory is relevant only if it would change how the assistant handles this message
+        (preferences, conventions, project facts, prior decisions). Skip loosely related ones.
+        Reply with JSON only: {"files": ["<filename>.md"]} using at most #{MEMORY_INJECT_MAX_FILES} filenames from the list.
+        Reply {"files": []} when nothing is relevant (greetings, acknowledgements, small talk).
+      PROMPT
+
+      private def inject_relevant_memories(user_input, task_id:)
+        return unless @config.memory_inject_enabled
+        return if @is_subagent
+
+        message = user_input.to_s.strip
+        return if message.empty?
+        return if Dir.glob(File.join(memories_base_dir, "*.md")).empty?
+
+        visible = memory_visible_messages
+        picked = pick_relevant_memories(message, visible) - injected_memory_files(visible)
+        return if picked.empty?
+
+        @history.append({
+          role: "user",
+          content: build_memory_reminder(picked),
+          system_injected: true,
+          memory_recall: true,
+          memory_files: picked,
+          task_id: task_id
+        })
+      rescue StandardError => e
+        Clacky::Logger.warn("memory_inject.failed", error: e)
+      end
+
+      # Messages on the active task chain, so undone branches neither count as
+      # injected nor feed the picker.
+      private def memory_visible_messages
+        chain = active_task_chain
+        @history.to_a.select { |m| !m[:task_id] || chain.include?(m[:task_id]) }
+      end
+
+      private def injected_memory_files(messages)
+        messages.select { |m| m[:memory_recall] }.flat_map { |m| Array(m[:memory_files]) }.uniq
+      end
+
+      private def pick_relevant_memories(message, visible)
+        model = memory_picker_model
+        # send_messages_with_tools rather than send_messages: only it returns usage.
+        response = memory_picker_client(model).send_messages_with_tools(
+          [
+            { role: "system", content: MEMORY_PICKER_SYSTEM_PROMPT },
+            { role: "user", content: memory_picker_prompt(message, visible) }
+          ],
+          model: model,
+          tools: [],
+          max_tokens: MEMORY_PICKER_MAX_TOKENS
+        )
+        track_auxiliary_cost(response[:usage], model: response[:routed_model] || model) if response[:usage]
+        if response[:finish_reason] == "length"
+          Clacky::Logger.warn("memory_inject.picker_truncated", model: model, max_tokens: MEMORY_PICKER_MAX_TOKENS)
+        end
+        parse_memory_picker_reply(response[:content].to_s)
+          .select { |name| memory_file_name?(name) }
+          .uniq
+          .first(MEMORY_INJECT_MAX_FILES)
+      end
+
+      private def memory_picker_model
+        lite = @config.lite_model_config_for_current
+        (lite && lite["model"]) || current_model
+      end
+
+      # A dedicated client so a slow picker gives up quickly instead of holding
+      # the turn for the main client's 300s read timeout.
+      private def memory_picker_client(model)
+        lite = @config.lite_model_config_for_current
+        if lite
+          Clacky::Client.new(
+            lite["api_key"],
+            base_url: lite["base_url"],
+            model: model,
+            anthropic_format: lite["anthropic_format"] == true,
+            read_timeout: MEMORY_PICKER_READ_TIMEOUT
+          )
+        else
+          Clacky::Client.new(
+            @config.api_key,
+            base_url: @config.base_url,
+            model: model,
+            anthropic_format: @config.anthropic_format?,
+            api_format: @config.api_format,
+            read_timeout: MEMORY_PICKER_READ_TIMEOUT
+          )
+        end
+      end
+
+      private def memory_picker_prompt(message, visible)
+        <<~PROMPT
+          #{load_memories_meta(limit: MEMORY_PICKER_LISTING_LIMIT)}
+
+          Previous assistant reply (excerpt):
+          #{previous_reply_excerpt(last_assistant_reply_text(visible))}
+
+          User message:
+          #{message[0, MEMORY_PICKER_USER_CHARS]}
+        PROMPT
+      end
+
+      # Long replies open with the conclusion but close with the question the
+      # user is answering, so keep both ends.
+      private def previous_reply_excerpt(text)
+        return "(none)" if text.empty?
+
+        limit = MEMORY_PICKER_PREV_REPLY_CHARS
+        return text if text.length <= limit
+
+        half = limit / 2
+        "#{text[0, half]}\n...\n#{text[-half, half]}"
+      end
+
+      private def parse_memory_picker_reply(text)
+        json = begin
+          JSON.parse(text)
+        rescue JSON::ParserError
+          match = text.match(/\{.*\}/m)
+          match ? (JSON.parse(match[0]) rescue nil) : nil
+        end
+        files = json.is_a?(Hash) ? json["files"] : nil
+        files.is_a?(Array) ? files.map(&:to_s) : []
+      end
+
+      # Bare filename that exists in the memories dir; rejects hallucinated
+      # names and any path components.
+      private def memory_file_name?(name)
+        name.end_with?(".md") && File.basename(name) == name &&
+          File.file?(File.join(memories_base_dir, name))
+      end
+
+      private def last_assistant_reply_text(visible)
+        msg = visible.reverse.find { |m| m[:role] == "assistant" && !m[:content].to_s.strip.empty? }
+        return "" unless msg
+
+        content = msg[:content]
+        text = if content.is_a?(Array)
+          content.map { |b| b.is_a?(Hash) ? (b[:text] || b["text"]).to_s : "" }.join("\n")
+        else
+          content.to_s
+        end
+        text.strip
+      end
+
+      private def build_memory_reminder(names)
+        parts = [
+          "<system-reminder>",
+          "Relevant long-term memories (auto-selected from ~/.clacky/memories/). " \
+          "Apply them where they fit; the user's current instructions take precedence.",
+          ""
+        ]
+        names.each do |name|
+          path = File.join(memories_base_dir, name)
+          mtime = File.mtime(path)
+          parts << "## #{name} (last updated #{mtime.strftime("%Y-%m-%d")})"
+          parts << memory_inject_body(path)
+          age_days = ((Time.now - mtime) / 86_400).floor
+          if age_days > MEMORY_INJECT_STALE_DAYS
+            parts << "(This memory is #{age_days} days old; verify it against the current state before relying on it.)"
+          end
+          parts << ""
+        end
+        parts << "</system-reminder>"
+        parts.join("\n")
+      end
+
+      private def memory_inject_body(path)
+        body = File.read(path, encoding: "UTF-8").sub(/\A---\n.*?\n---\n*/m, "").strip
+        return body if body.bytesize <= MEMORY_INJECT_FILE_BYTES
+
+        "#{body.byteslice(0, MEMORY_INJECT_FILE_BYTES).scrub("")}\n...(truncated; read #{path} for the rest)"
+      end
+    end
+  end
+end

data/lib/clacky/agent/memory_updater.rb

@@ -188,6 +188,22 @@ module Clacky
           - Any task that produced no lasting decisions or preferences
           - Repeating or slightly rephrasing what is already in memory
 
+          ## Never persist what can be re-derived
+
+          Code and git are the source of truth; a memory that copies them goes stale
+          silently and later misleads. Do NOT persist:
+
+          - Code structure, architecture, file paths, class/method names, line numbers
+          - Implementation details of a feature that was just built or changed
+          - Git history, change logs, PR contents, or "what was modified"
+          - Debugging steps, root-cause narratives, or how a bug was fixed
+          - Content already in project rules or docs (.clackyrules, README, AGENTS.md, etc.)
+          - Temporary task state, progress, or TODOs of the current conversation
+
+          If a session's only takeaways fall into this list, write nothing. When a
+          whitelisted item involves code, persist only the decision and its reason,
+          not the implementation.
+
           ═══════════════════════════════════════════════════════════════
           EXECUTOR MANUAL (from persist-memory skill)
           ═══════════════════════════════════════════════════════════════

data/lib/clacky/agent/skill_manager.rb

@@ -98,6 +98,14 @@ module Clacky
       # so excessive mcp.json entries don't quietly bloat the system prompt.
       MAX_CONTEXT_MCP_SERVERS = 10
 
+      # Bounds on the memories listing injected into recall/persist-memory skills.
+      # The file cap is an LRU shortlist, not a hard limit: older files stay
+      # reachable via grep. Per-field caps stop one oversized frontmatter from
+      # bloating the whole list.
+      MAX_MEMORIES_META_FILES = 20
+      MAX_MEMORY_TOPIC_CHARS = 100
+      MAX_MEMORY_DESCRIPTION_CHARS = 150
+
       # Process-wide deduper for the "skill context limit" warning so that
       # every newly constructed Agent (sub-agents, retries, web turns…) doesn't
       # re-emit the same line.
@@ -489,16 +497,18 @@ module Clacky
 
       # Scan ~/.clacky/memories/ and return a formatted summary of all memory files.
       # Parses YAML frontmatter (same pattern as Skill#parse_frontmatter) for each file.
+      # @param limit [Integer] max files listed, newest first
       # @return [String] Formatted list of memory topics and descriptions
-      def load_memories_meta
+      def load_memories_meta(limit: MAX_MEMORIES_META_FILES)
         memories_dir = memories_base_dir
         return "(No long-term memories found.)" unless Dir.exist?(memories_dir)
 
-        files = Dir.glob(File.join(memories_dir, "*.md"))
-                    .sort_by { |f| File.mtime(f) }
-                    .reverse
-                    .first(20)
-        return "(No long-term memories found.)" if files.empty?
+        all_files = Dir.glob(File.join(memories_dir, "*.md"))
+                       .sort_by { |f| File.mtime(f) }
+                       .reverse
+        return "(No long-term memories found.)" if all_files.empty?
+
+        files = all_files.first(limit)
 
         lines = ["Available memory files in ~/.clacky/memories/:"]
         lines << ""
@@ -506,8 +516,8 @@ module Clacky
         files.each do |path|
           filename = File.basename(path)
           fm = parse_memory_frontmatter(path)
-          topic       = fm["topic"]       || filename.sub(/\.md$/, "")
-          description = fm["description"] || "(no description)"
+          topic       = truncate_memory_field(fm["topic"] || filename.sub(/\.md$/, ""), MAX_MEMORY_TOPIC_CHARS)
+          description = truncate_memory_field(fm["description"] || "(no description)", MAX_MEMORY_DESCRIPTION_CHARS)
           # Use file mtime as the "last seen" signal (covers both writes and
           # touch-on-recall LRU bumps). Authoritative — no longer relies on
           # an LLM-maintained `updated_at` frontmatter field.
@@ -518,9 +528,21 @@ module Clacky
           lines << entry
         end
 
+        omitted = all_files.size - files.size
+        if omitted > 0
+          lines << ""
+          lines << "(#{omitted} older memories not listed — search ~/.clacky/memories/ with grep if needed)"
+        end
+
         lines.join("\n")
       end
 
+      # Collapse to a single line so each memory occupies exactly one entry in the listing.
+      private def truncate_memory_field(value, max_chars)
+        text = value.to_s.gsub(/\s+/, " ").strip
+        text.length > max_chars ? "#{text[0, max_chars]}…" : text
+      end
+
       # Base directory for long-term memories. Override in tests for isolation.
       # @return [String]
       def memories_base_dir