openclacky 1.0.0.beta.6 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: afc12c94c2b8b7580ca948625cc6c106004bbf385f341c783e36e1be9d93fd82
-  data.tar.gz: 95508d829f02270b3fce4849b21e29b6766a46d9c663d47e37df817aed456da5
+  metadata.gz: 9d6ba5a62f7a352730705db11aff8ab76af059764903eb4413bd5a0aa835fecf
+  data.tar.gz: 58ba8fdcf23b5dabcc4a8ed709be0f34a9d27a5be83601fee685a638eb3ff445
 SHA512:
-  metadata.gz: 8f44be2b9d9bf26f97490f5ddf2525a6cad937c5152b8486bb2840a263ab104cacfa5838600236b3a38a6806e69cd717fbce982838f2c2a65664158b0b4ed238
-  data.tar.gz: aecb14f4b6f345d190e52de0c0816f380b4e6c3213453c9e69a04b78944f757115e8a1ac042b0a78398e79d27de65190f4c0cb61d1efe3c224416b6a2f55f6c6
+  metadata.gz: 00e3f00119cad74d7da43519a1a12332e509c0050946d713dea17db539bbadf0099e96ea5369cc19046fd0bc1c224849cbbaf43addfe0708858780a370067b3b
+  data.tar.gz: 4e7888c952dd49c664c67212c0986b62bd7745887dae7d85bce14b3f36c544fc5bd9ca27f1851f04e14477cfd9316938605b6ae0f89b19652cadd1442c6dc564

data/CHANGELOG.md

@@ -5,7 +5,40 @@ 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).
 
-## [Unreleased]
+## [1.0.1] - 2026-05-06
+
+### Added
+- **OpenRouter Anthropic API support.** You can now route Claude model requests through OpenRouter, giving access to Anthropic models via a single OpenRouter API key — useful when Anthropic direct access is limited in your region.
+- **GPT provider support.** Direct GPT provider configuration is now available alongside other providers, making it easier to switch between different OpenAI-compatible endpoints.
+- **OCR-powered PDF reading.** PDF files that contain scanned images (non-text PDFs) are now readable via OCR, allowing the agent to extract content from scanned documents, invoices, and image-heavy PDFs.
+- **Terminal output size control.** The agent now limits terminal output to a configurable size, preventing token overflows when running commands that produce very long output.
+- **Memories & Trash manager in Web UI.** A new management panel lets you browse, review, and delete agent memories and trashed files directly from the Web UI.
+- **Watchdog for interrupt messages.** A background watchdog ensures interrupt signals reliably stop the agent even when it's deep in a tool execution loop.
+- **Skill import with category directory scanning.** When importing skills from openclaw packages, nested category directories are now scanned automatically, so all skills in a category bundle are imported at once.
+
+### Improved
+- **Deploy skill simplified.** The deploy skill now uses Railway CLI directly without custom helper tools, making deployments more reliable and the codebase significantly lighter.
+- **Fix double-render of progress indicators.** Progress spinners and status lines no longer render twice in quick succession, keeping the Web UI output clean.
+- **Session idle status tracking and file descriptor cleanup.** Sessions now correctly report idle state when the agent finishes, and open file descriptors are properly closed to avoid resource leaks.
+- **GPT-4.1 and GPT-5 pricing added.** Model cost tracking now includes the latest GPT-4.1 and GPT-5 pricing tiers.
+
+### Fixed
+- **UTF-8 encoding error in file preview.** Opening files with non-UTF-8 characters no longer crashes the preview — they are now handled gracefully.
+- **Expand `~` in openfile path.** The "open file in editor" API endpoint now correctly expands `~` to the user's home directory.
+
+## [1.0.0] - 2026-04-30
+
+### Added
+- **Speed test tool in Web UI.** Test API response latency for different models and providers directly from the settings panel, making it easy to find the fastest endpoint for your region.
+- **History chunk loading.** Previously compressed conversation chunks can now be loaded back into the session when needed, so long-running conversations don't lose context.
+- **Default model changed to 4.5.** New default model provides better balance of speed, quality, and cost for most tasks.
+
+### Improved
+- **Thinking indicator now visible for more steps.** The "thinking..." indicator stays visible longer during complex operations, giving better feedback about what the agent is doing.
+- **Message timestamps display correctly in Web UI.** User message times now show properly without layout issues, and the scroll behavior is smoother.
+
+### Fixed
+- **Scroll position no longer jumps unexpectedly** in the Web UI when loading session history.
 
 ## [1.0.0.beta.6] - 2026-04-30
 

data/README.md

@@ -6,77 +6,79 @@
 [![Downloads](https://img.shields.io/gem/dt/openclacky?label=downloads&style=flat-square&color=brightgreen)](https://rubygems.org/gems/openclacky)
 [![License](https://img.shields.io/badge/license-MIT-lightgrey?style=flat-square)](LICENSE.txt)
 
-**From expertise to business — turn your professional knowledge into a monetizable OpenClaw Skill.**
+**The most Token-efficient open-source AI Agent.**
 
-OpenClacky is the creator-side platform for the OpenClaw ecosystem. Package your methods and workflows into encrypted, white-labeled Skills that your clients install and use — under your name, your brand, your price.
+OpenClacky matches Claude Code on capability at comparable cost, and saves significantly against other open-source agents (~50% vs OpenClaw, ~3× cheaper than Hermes). 100% open source (MIT), BYOK with any OpenAI-compatible model, built on two years of Agentic R&D and harness engineering.
 
-## Why OpenClacky?
+> Website: https://www.openclacky.com/ · Backed by **MiraclePlus · ZhenFund · Sequoia China · Hillhouse Capital**
 
-The OpenClaw ecosystem has 5,700+ Skills and growing. But almost all of them are open-sourced, free, and easily copied. The real scarcity isn't more Skills — it's **expertise-backed, production-grade Skills worth paying for**.
+## Why OpenClacky?
 
-OpenClacky is built for the people who have that expertise.
+Same task, how much do you pay? Under comparable agent workloads, OpenClacky saves a large amount of Token spend compared to mainstream alternatives.
 
-|  | **Openclaw** | **OpenClacky** |
+| Agent | Relative cost | Notes |
 |---|---|---|
-| **Core model** | Open sharing | Encrypted & protected |
-| **Primary users** | Users who install Skills | Creators who sell Skills |
-| **Revenue** | None | Creator-defined pricing |
-| **Brand** | Platform brand | Your own brand |
-| **Driven by** | Technical contributors | Domain expertise |
+| **OpenClacky** | **~0.8–1.2×** | 16 tools · ~100% cache hit · subagent routing |
+| Claude Code | 1.0× (baseline) | World-class harness, closed-source subscription |
+| OpenClaw | ~1.5× | Comparable harness agent |
+| Hermes | ~3× | 52 built-in tools — schema bloat ~3–4× |
 
-## How It Works
+*Numbers are averages measured on internal common agent tasks, using Claude Code as the baseline. Full benchmark reports will be published on GitHub.*
 
-**Four steps from capability to business:**
+## Feature comparison
 
-1. **Craft your Skill** — Turn your domain methodology into a repeatable AI workflow
-2. **Encrypt & protect** — Your logic stays yours; clients can't inspect or copy it
-3. **Package your brand** — Ship under your name, your logo, your onboarding experience
-4. **Launch & acquire** — One-click sales page, built-in SEO, start converting traffic
+Core agent capability is roughly on par across the field — the real differentiators are **cost, openness, Skill evolution, and integrations**.
 
-## Who It's For
+| Feature | Claude Code | OpenClaw | Hermes | **OpenClacky** |
+|---|:---:|:---:|:---:|:---:|
+| Token cost | 1.0× | ~1.5× | ~3× | **~0.8–1.2×** |
+| Open source | ❌ Closed | ✅ Open | ✅ Open | ✅ MIT |
+| BYOK / model freedom | ❌ Anthropic only | ✅ | ✅ | ✅ |
+| Skill self-evolution | ❌ | ❌ | ✅ | ✅ |
+| IM integration (Feishu / WeCom / WeChat) | ❌ | ✅ | ✅ | ✅ |
 
-OpenClacky is built for domain experts whose knowledge can be expressed as *information processing + executable actions*:
+## How we get the cost down
 
-- **SEO specialists** — keyword research, content scoring, rank monitoring
-- **Lawyers** — contract review, case retrieval, risk flagging
-- **Traders** — signal detection, strategy backtesting, automated execution
-- **Data analysts** — cleaning, modeling, report generation
-- **Content strategists** — topic selection, outlines, drafts at scale
+Not by cutting features — by compounding the right choice at every layer.
 
-## Features
+### 1. Ultra-high cache hit rate
+Sessions never restart, double cache markers, **Insert-then-Compress** — the system prompt is never mutated, so compression still reuses the cache. **Measured cache hit rate: near 100%.**
 
-- [x] **Skill builder** — Create AI workflows via conversation or UI, iterate and ship fast
-- [x] **Encryption** — Protect your knowledge assets; end users cannot read your Skill source
-- [x] **White-label packaging** — Your brand, your product line, your client experience
-- [x] **Auto-update delivery** — Push updates to all users seamlessly, with version control
-- [x] **Cross-platform distribution** — Windows, macOS, Linux — one Skill, every platform
-- [x] **Sales page generator** — Launch your storefront fast, with built-in SEO foundations
-- [x] **Cost monitoring** — Real-time token tracking, automatic compression (up to 90% savings)
-- [x] **Multi-provider support** — OpenAI, Anthropic, DeepSeek, and any OpenAI-compatible API
-- [ ] **Skill marketplace** — Discover and distribute premium Skills *(coming soon)*
+### 2. Minimal tool set
+Only **16 core tools**. Capabilities are offloaded to the Skill ecosystem via a single `invoke_skill` meta-tool. Tool count is not the metric — task completion rate is.
 
-## Coding Support
+| OpenClacky | Claude Code | OpenClaw | Hermes |
+|:--:|:--:|:--:|:--:|
+| **16** | 40+ | 23 | 52 |
 
-OpenClacky also works as a general AI coding assistant — scaffold full-stack Rails apps, add features, or explore an unfamiliar codebase:
+### 3. Idle-time auto-compression
+Go to a meeting, grab coffee — the agent compresses long context in the background and pre-warms the cache. Your first message back hits the cache directly. **Cold-start first-token cost reduced by 50%+.**
 
-```bash
-$ openclacky
-> /new my-app        # scaffold a full-stack Rails app
-> Add user auth with email and password
-> How does the payment module work?
-```
+### 4. BYOK — you pick the model, you set the cost
+Any OpenAI-compatible API, plug and play. Official direct, aggregate routing, compatible relays — the choice is 100% yours. Use Claude for code, auto-route subtasks to DeepSeek, save another chunk of tokens.
+
+Built on **2 years · 3 generations of agentic architecture · 6 core harness engineering decisions**.
+
+## Skills — the soul of the agent
 
-Built on a production-ready Rails architecture with one-click deployment, dev/prod isolation, and automatic backups.
+- **Invoke with `/`** — instant browse, fuzzy search, direct call. Hundreds of Skills at your fingertips.
+- **Create Skills in natural language** — just describe what you want; the agent drafts `SKILL.md`, breaks down steps, and runs validation. No code required.
+- **Self-evolving** — after each run, the agent updates the Skill based on execution context and results. The next call is more stable and more accurate.
+- **Open & compatible** — supports Claude Skills / Markdown Pack / custom formats.
+- **Monetizable** — polished Skills can be packaged for sale, with encrypted distribution, License management, and creator-defined pricing.
 
 ## Installation
 
-### Method 1: One-line Install (Recommended)
+### Desktop installer (recommended)
 
-```bash
-/bin/bash -c "$(curl -sSL https://raw.githubusercontent.com/clacky-ai/openclacky/main/scripts/install.sh)"
-```
+Double-click to install — environment, dependencies, and Skills all set up automatically.
+
+- **macOS** — [Download `.dmg`](https://oss.1024code.com/openclacky-installer/official/openclacky-installer.dmg) (Apple Silicon / Intel)
+- **Windows** — [Download `.exe`](https://oss.1024code.com/openclacky-installer/official/openclacky-installer.exe) (Windows 10 2004+ / Windows 11)
 
-### Method 2: RubyGems
+More options: https://www.openclacky.com/
+
+### Command line
 
 **Requirements:** Ruby >= 3.1.0
 
@@ -84,6 +86,12 @@ Built on a production-ready Rails architecture with one-click deployment, dev/pr
 gem install openclacky
 ```
 
+Or one-line install:
+
+```bash
+/bin/bash -c "$(curl -sSL https://raw.githubusercontent.com/clacky-ai/openclacky/main/scripts/install.sh)"
+```
+
 ## Quick Start
 
 ### Terminal (CLI)
@@ -95,16 +103,16 @@ openclacky            # start interactive agent in current directory
 ### Web UI
 
 ```bash
-openclacky server     # start the web server (default: http://localhost:7070)
+openclacky server     # default: http://localhost:7070
 ```
 
-Then open **http://localhost:7070** in your browser. You'll get a full-featured chat interface with multi-session support — run separate sessions for coding, copywriting, research, and more, all in parallel.
+Open **http://localhost:7070** for a full chat interface with multi-session support — run coding, copywriting, research sessions in parallel.
 
 Options:
 
 ```bash
-openclacky server --port 8080          # custom port
-openclacky server --host 0.0.0.0      # listen on all interfaces (e.g. remote access)
+openclacky server --port 8080        # custom port
+openclacky server --host 0.0.0.0     # listen on all interfaces (remote access)
 ```
 
 ## Configuration
@@ -114,7 +122,26 @@ $ openclacky
 > /config
 ```
 
-You'll be prompted to set your **API Key**, **Model**, and **Base URL** (any OpenAI-compatible provider).
+Set your **API Key**, **Model**, and **Base URL** (any OpenAI-compatible provider).
+
+Supported out of the box: **Claude (Anthropic) · GPT (OpenAI) · DeepSeek · Kimi (Moonshot) · MiniMax · OpenRouter** — or any custom endpoint.
+
+## Coding use case
+
+OpenClacky works as a general AI coding assistant — scaffold full-stack apps, add features, or explore unfamiliar codebases:
+
+```bash
+$ openclacky
+> /new my-app        # scaffold a new project
+> Add user auth with email and password
+> How does the payment module work?
+```
+
+## Advanced — Creator Program
+
+Already power users are turning their workflows into vertical AI experts on OpenClacky — encrypted distribution, License management, self-set pricing. Legal, healthcare, financial planning, and more.
+
+Learn more: https://www.openclacky.com/ → Creators
 
 ## Install from Source
 
@@ -125,6 +152,13 @@ bundle install
 bin/clacky
 ```
 
+## Trust & Credibility
+
+- **100% open source** — MIT License, all code public, all decisions traceable
+- **2 years of Agentic R&D** — 3 generations of architecture
+- **16 core tools** — minimal by design
+- **Backed by** MiraclePlus · ZhenFund · Sequoia China · Hillhouse Capital
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/clacky-ai/openclacky. Contributors are expected to adhere to the [code of conduct](https://github.com/clacky-ai/openclacky/blob/main/CODE_OF_CONDUCT.md).

data/lib/clacky/agent/cost_tracker.rb

@@ -105,8 +105,25 @@ module Clacky
         cache_write = usage[:cache_creation_input_tokens] || 0
         cache_read = usage[:cache_read_input_tokens] || 0
 
-        # Calculate token delta from previous iteration
-        delta_tokens = total_tokens - @previous_total_tokens
+        # Calculate token delta from previous iteration.
+        #
+        # Two conventions exist for total_tokens across providers:
+        #   - OpenAI (default):    cumulative per-request input+output (grows
+        #                          with history every turn). Delta = total - prev.
+        #   - Anthropic direct:    already the per-turn new compute
+        #                          (raw_input + cache_creation + output).
+        #                          The MessageFormat sets :total_is_per_turn so
+        #                          we use total_tokens directly as the delta.
+        #
+        # Without this branch, Anthropic's per-turn total would be treated as
+        # cumulative and produce negative / nonsensical deltas whenever cached
+        # prefixes make the per-turn new-compute smaller than the previous turn.
+        delta_tokens =
+          if usage[:total_is_per_turn]
+            total_tokens
+          else
+            total_tokens - @previous_total_tokens
+          end
         @previous_total_tokens = total_tokens  # Update for next iteration
 
         {

data/lib/clacky/agent/llm_caller.rb

@@ -54,6 +54,20 @@ module Clacky
         max_retries = 10
         retry_delay = 5
         retries = 0
+
+        # Track whether any of the retry/fallback branches below opened a
+        # "retrying" progress slot via show_progress(progress_type:
+        # "retrying", phase: "active"). If so, we MUST close it before
+        # leaving call_llm — otherwise the UI's legacy shim in
+        # UI2::UIController keeps the :quiet ProgressHandle alive, its
+        # ticker thread keeps running, and the user sees a frozen
+        # "Network failed: ... (681s)" line long after the task finished.
+        #
+        # The close is done in the outer ensure below so it runs on:
+        #   - normal success (response returned)
+        #   - unrecoverable failure (raise propagates out)
+        #   - BadRequestError reasoning-content retry success
+        retrying_progress_opened = false
         # One-shot flag set by the BadRequestError rescue below when the server
         # complained about missing reasoning_content. The subsequent retry will
         # pad every assistant message's reasoning_content, which satisfies
@@ -67,6 +81,7 @@ module Clacky
         thinking_retry_attempted = false
 
         begin
+          begin
           # Use active_messages (Time Machine) when undone, otherwise send full history.
           # to_api strips internal fields and handles orphaned tool_calls.
           messages_to_send = if respond_to?(:active_messages)
@@ -86,7 +101,46 @@ module Clacky
           # Successful response — if we were probing, confirm primary is healthy.
           handle_probe_success if @config.probing?
 
-        rescue Faraday::ConnectionFailed, Faraday::TimeoutError, Faraday::SSLError, Errno::ECONNREFUSED, Errno::ETIMEDOUT => e
+        rescue Faraday::TimeoutError => e
+          # ── Read-timeout path (distinct from connection-level failures) ──
+          # Faraday::TimeoutError on our non-streaming POST almost always means
+          # the *response* took longer than the 300s read-timeout to come back —
+          # i.e. the model is trying to produce a huge output in one shot
+          # (e.g. "write me a 2000-line snake game"). Blindly retrying the same
+          # request with the same prompt reproduces the same timeout.
+          #
+          # Strategy:
+          #   1. On the FIRST timeout in a task, inject a `[SYSTEM]` user message
+          #      telling the model to break the work into smaller steps, then
+          #      retry. The history edit changes the prompt, so the retry is
+          #      materially different from the failed attempt.
+          #   2. On subsequent timeouts in the same task, fall back to the
+          #      generic "just retry" behaviour (the model may have ignored
+          #      the hint; don't pile on duplicate hints).
+          #   3. Probing-mode timeouts still go through handle_probe_failure.
+          retries += 1
+
+          if @config.probing?
+            handle_probe_failure
+            retry
+          end
+
+          if retries <= max_retries
+            inject_large_output_hint_if_first_timeout(e)
+            @ui&.show_progress(
+              "Response too slow (likely generating too much at once): #{e.message}",
+              progress_type: "retrying",
+              phase: "active",
+              metadata: { attempt: retries, total: max_retries }
+            )
+            retrying_progress_opened = true
+            sleep retry_delay
+            retry
+          else
+            raise AgentError, "[LLM] Request timed out after #{max_retries} retries: #{e.message}"
+          end
+
+        rescue Faraday::ConnectionFailed, Faraday::SSLError, Errno::ECONNREFUSED, Errno::ETIMEDOUT => e
           retries += 1
 
           # Probing failure: primary still down — renew cooling-off and retry with fallback.
@@ -95,9 +149,10 @@ module Clacky
             retry
           end
 
-          # Network-level errors (timeouts, connection failures) are likely transient
-          # infrastructure blips — do NOT trigger fallback.  Just retry on the current
-          # model (primary or already-active fallback) up to max_retries.
+          # Connection-level errors (DNS, TCP refused, open-timeout, TLS) are
+          # transient infrastructure blips — do NOT trigger fallback, and do
+          # NOT inject the "break into steps" hint (the model did nothing wrong).
+          # Just retry on the current model up to max_retries.
           if retries <= max_retries
             @ui&.show_progress(
               "Network failed: #{e.message}",
@@ -105,6 +160,7 @@ module Clacky
               phase: "active",
               metadata: { attempt: retries, total: max_retries }
             )
+            retrying_progress_opened = true
             sleep retry_delay
             retry
           else
@@ -141,6 +197,7 @@ module Clacky
               phase: "active",
             metadata: { attempt: retries, total: current_max }
           )
+          retrying_progress_opened = true
           sleep retry_delay
           retry
         else
@@ -174,6 +231,21 @@ module Clacky
         response[:token_usage] = token_data
 
         response
+        ensure
+          # Close any "retrying" progress slot that was opened during the
+          # retry/fallback loop above. The legacy UI shim allocates a
+          # separate :quiet ProgressHandle under the "retrying" key; if it
+          # is never finished its ticker thread keeps running and the user
+          # sees a stale "Network failed: ... (NNN s)" line long after the
+          # task has completed. This ensure runs on:
+          #   - successful retry → close the slot, message is "Recovered"
+          #     so the final frame is informative rather than blank
+          #   - unrecoverable failure that raises out → close the slot so
+          #     the spinner doesn't linger while the error bubbles up
+          if retrying_progress_opened
+            @ui&.show_progress(progress_type: "retrying", phase: "done")
+          end
+        end
       end
 
       # Attempt to activate the provider fallback model for the given primary model.
@@ -229,6 +301,50 @@ module Clacky
           (msg.include?("thinking") || msg.include?("must be passed back") ||
            msg.include?("must be provided"))
       end
+
+      # On the FIRST Faraday::TimeoutError within a task, append a [SYSTEM]
+      # user message to the history instructing the model to break its work
+      # into smaller steps. Subsequent timeouts in the same task are ignored
+      # here (caller just retries) so we don't pollute history with duplicate
+      # hints.
+      #
+      # The injected message carries `system_injected: true` so it is:
+      #   - Hidden from UI replay (session_serializer / replay_history filters)
+      #   - Skipped by prompt-caching marker placement (client.rb)
+      #   - Skipped by message compression's "recent user turn" protection
+      #     (message_compressor_helper.rb)
+      #
+      # Reset per-task via Agent#run (see @task_timeout_hint_injected = false).
+      private def inject_large_output_hint_if_first_timeout(err)
+        return if @task_timeout_hint_injected
+
+        @task_timeout_hint_injected = true
+
+        hint = "[SYSTEM] The previous LLM response timed out (read timeout after ~300s). " \
+               "This usually means the model was trying to produce too much output in a single response. " \
+               "Please change your approach:\n" \
+               "- Break the task into multiple smaller steps, each producing a short response.\n" \
+               "- For long files: first create a skeleton with `write` (structure + placeholder comments only), " \
+               "then fill in each section with separate `edit` calls.\n" \
+               "- Keep each single tool-call argument (especially file content) well under ~500 lines.\n" \
+               "- Do NOT attempt to output the entire deliverable in one response."
+
+        @history.append({
+          role: "user",
+          content: hint,
+          system_injected: true,
+          task_id: @current_task_id
+        })
+
+        Clacky::Logger.info(
+          "[llm_caller] Read-timeout detected — injected 'break into smaller steps' hint " \
+          "(error=#{err.class}: #{err.message})"
+        )
+
+        @ui&.show_warning(
+          "LLM response timed out — asking model to break the task into smaller steps and retrying..."
+        )
+      end
     end
   end
 end

data/lib/clacky/agent/message_compressor_helper.rb

@@ -47,11 +47,41 @@ module Clacky
             handle_compression_response(response, compression_context, progress: handle)
             true
           rescue Clacky::AgentInterrupted => e
-            @ui&.log("Idle compression canceled: #{e.message}", level: :info)
+            # User cancelled the idle compression — finish the quiet progress
+            # slot in place so the user sees exactly what happened (rather
+            # than the "Idle detected..." line being silently removed).
+            final = "Idle compression cancelled: #{e.message}"
+            if handle
+              handle.finish(final_message: final)
+            else
+              @ui&.log(final, level: :info)
+            end
             @history.rollback_before(compression_message)
+            Clacky::Logger.info("[idle-compress] cancelled: #{e.message}")
             false
           rescue => e
-            @ui&.log("Idle compression failed: #{e.message}", level: :error)
+            # Compression failed (most commonly: network errors after all
+            # LlmCaller retries exhausted). Previously this only wrote an
+            # @ui.log(:error) that was easy to miss — especially when no
+            # other output followed. Now we:
+            #   1. Replace the active quiet progress line with the error so
+            #      the user always sees *something* where the spinner was.
+            #   2. Emit a show_warning for a more prominent entry.
+            #   3. Persist to Clacky::Logger so post-mortem is possible even
+            #      if the terminal scrollback has rolled past.
+            final = "Idle compression failed: #{e.message}"
+            if handle
+              handle.finish(final_message: final)
+            else
+              @ui&.log(final, level: :error)
+            end
+            @ui&.show_warning(final)
+            Clacky::Logger.warn(
+              "[idle-compress] failed",
+              error_class: e.class.name,
+              error_message: e.message,
+              backtrace: e.backtrace&.first(5)
+            )
             @history.rollback_before(compression_message)
             false
           end

data/lib/clacky/agent/session_serializer.rb

@@ -36,6 +36,15 @@ module Clacky
         # Restore previous_total_tokens for accurate delta calculation across sessions
         @previous_total_tokens = session_data.dig(:stats, :previous_total_tokens) || 0
 
+        # Recover the latest latency metric from the most recent assistant message
+        # that carries a :latency field. This is the source of truth for the status-bar
+        # signal — no separate session-level field is needed. Older sessions (pre-feature)
+        # simply start with nil; the signal stays hidden until the next LLM call populates it.
+        last_assistant_with_latency = @history.to_a.reverse.find do |m|
+          m[:role].to_s == "assistant" && m[:latency]
+        end
+        @latest_latency = last_assistant_with_latency&.dig(:latency)
+
         # Restore Time Machine state
         @task_parents = session_data.dig(:time_machine, :task_parents) || {}
         @current_task_id = session_data.dig(:time_machine, :current_task_id) || 0
@@ -178,8 +187,18 @@ module Clacky
           elsif current_round
             current_round[:events] << msg
           elsif msg[:compressed_summary] && msg[:chunk_path]
-            # Compressed summary sitting before any user rounds — expand it from chunk md
-            chunk_rounds = parse_chunk_md_to_rounds(msg[:chunk_path])
+            # 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_rounds = sibling_chunks_of(msg[:chunk_path]).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
@@ -243,6 +262,32 @@ module Clacky
         { has_more: has_more }
       end
 
+      # Return all chunk MD file paths that belong to the same session as
+      # +chunk_path+, sorted by chunk index ascending (chunk-1, chunk-2, …).
+      # Uses the filename convention "<base>-chunk-<N>.md".
+      #
+      # Handles path resolution the same way parse_chunk_md_to_rounds does:
+      # if the stored path doesn't exist, fall back to SESSIONS_DIR + basename
+      # (cross-machine / cross-user session bundles).
+      private def sibling_chunks_of(chunk_path)
+        return [] unless chunk_path
+
+        resolved = chunk_path.to_s
+        unless File.exist?(resolved)
+          resolved = File.join(Clacky::SessionManager::SESSIONS_DIR, File.basename(resolved))
+        end
+        return [] unless File.exist?(resolved)
+
+        dir  = File.dirname(resolved)
+        base = File.basename(resolved).sub(/-chunk-\d+\.md\z/, "")
+        return [resolved] if base == File.basename(resolved)  # unconventional name — just use as-is
+
+        Dir.glob(File.join(dir, "#{base}-chunk-*.md")).sort_by do |p|
+          m = File.basename(p).match(/-chunk-(\d+)\.md\z/)
+          m ? m[1].to_i : Float::INFINITY
+        end
+      end
+
       # Parse a chunk MD file into an array of rounds compatible with replay_history.
       # Each round is { user_msg: Hash, events: Array<Hash> }.
       # Timestamps are synthesised from the chunk's archived_at, spread backwards.