openclacky 1.2.18 → 1.3.0

data/lib/clacky/server/http_server.rb

@@ -3,6 +3,7 @@
 require "webrick"
 require "websocket"
 require "socket"
+require "digest"
 require "json"
 require "net/http"
 require "faraday"
@@ -366,6 +367,17 @@ module Clacky
         @scheduler.start
         puts "   Scheduler: #{@scheduler.schedules.size} task(s) loaded"
 
+        # Reclaim orphaned Time Machine snapshots (sessions deleted earlier
+        # without snapshot cleanup). Runs off-thread so startup stays fast.
+        Thread.new do
+          begin
+            n = Clacky::SessionManager.cleanup_orphan_snapshots
+            puts "   Snapshots: reclaimed #{n} orphan dir(s)" if n.positive?
+          rescue StandardError => e
+            Clacky::Logger.error("snapshot_cleanup_error", error: e)
+          end
+        end
+
         # Start IM channel adapters (non-blocking — each platform runs in its own thread)
         @channel_manager.start
 
@@ -411,6 +423,16 @@ module Clacky
           # with modalities:["image"]); end-to-end latency is commonly
           # 20-60s and can exceed 2 minutes for or-gpt-image-2 under load.
           300
+        elsif path == "/api/media/video"
+          # Video generation (Veo via the gateway) runs an async submit+poll
+          # cycle that routinely takes 1-3 minutes and can approach the
+          # gateway's 8-minute ceiling. Give the local handler headroom.
+          600
+        elsif path == "/api/media/audio/speech"
+          120
+        elsif path.start_with?("/api/backup/download") || path == "/api/backup/run"
+          # Building a tar.gz of ~/.clacky (with session history) can take a while.
+          120
         else
           10
         end
@@ -435,7 +457,7 @@ module Clacky
         when ["GET",    "/api/cron-tasks"]    then api_list_cron_tasks(res)
         when ["POST",   "/api/cron-tasks"]    then api_create_cron_task(req, res)
         when ["GET",    "/api/skills"]         then api_list_skills(res)
-        when ["GET",    "/api/config"]        then api_get_config(res)
+        when ["GET",    "/api/config"]        then api_get_config(req, res)
         when ["GET",    "/api/config/settings"]  then api_get_settings(res)
         when ["GET",    "/api/exchange-rate"]    then api_exchange_rate(req, res)
         when ["PATCH",  "/api/config/settings"]  then api_update_settings(req, res)
@@ -449,10 +471,16 @@ module Clacky
         when ["POST",   "/api/internal/ocr-image"] then api_internal_ocr_image(req, res)
         when ["GET",    "/api/providers"]     then api_list_providers(res)
         when ["GET",    "/api/onboard/status"]    then api_onboard_status(res)
+        when ["POST",   "/api/onboard/device/start"] then api_onboard_device_start(req, res)
+        when ["POST",   "/api/onboard/device/poll"]  then api_onboard_device_poll(req, res)
         when ["GET",    "/api/browser/status"]    then api_browser_status(res)
         when ["POST",   "/api/browser/configure"]  then api_browser_configure(req, res)
         when ["POST",   "/api/browser/reload"]    then api_browser_reload(res)
         when ["POST",   "/api/browser/toggle"]    then api_browser_toggle(res)
+        when ["GET",    "/api/backup/status"]     then api_backup_status(res)
+        when ["POST",   "/api/backup/run"]        then api_backup_run(res)
+        when ["GET",    "/api/backup/download"]   then api_backup_download(res)
+        when ["PATCH",  "/api/backup/config"]     then api_backup_config(req, res)
         when ["POST",   "/api/telemetry"]        then api_telemetry(req, res)
         when ["POST",   "/api/onboard/complete"]  then api_onboard_complete(req, res)
         when ["POST",   "/api/onboard/skip-soul"] then api_onboard_skip_soul(req, res)
@@ -480,6 +508,8 @@ module Clacky
         when ["POST",   "/api/file-action"]       then api_file_action(req, res)
         when ["GET",    "/api/local-image"]       then api_serve_local_image(req, res)
         when ["POST",   "/api/media/image"]       then api_media_image(req, res)
+        when ["POST",   "/api/media/video"]       then api_media_video(req, res)
+        when ["POST",   "/api/media/audio/speech"] then api_media_audio_speech(req, res)
         when ["GET",    "/api/media/types"]       then api_media_types(res)
         when ["GET",    "/api/version"]           then api_get_version(res)
         when ["POST",   "/api/version/upgrade"]   then api_upgrade_version(req, res)
@@ -535,6 +565,8 @@ module Clacky
           elsif method == "GET" && path.match?(%r{^/api/sessions/[^/]+/skills$})
             session_id = path.sub("/api/sessions/", "").sub("/skills", "")
             api_session_skills(session_id, res)
+          elsif method == "GET" && path == "/api/dirs"
+            api_browse_dirs(req, res)
           elsif method == "GET" && path.match?(%r{^/api/sessions/[^/]+/files$})
             session_id = path.sub("/api/sessions/", "").sub("/files", "")
             api_session_files(session_id, req, res)
@@ -822,6 +854,96 @@ module Clacky
         end
       end
 
+      # POST /api/onboard/device/start
+      # Kicks off a device-authorization flow against the platform. Returns the
+      # device_code (held by the client for polling) plus the user-facing
+      # verification URL the browser should open.
+      def api_onboard_device_start(req, res)
+        client = Clacky::PlatformHttpClient.new
+        result = client.post("/api/v1/device/authorize", {
+          device_id:   onboard_device_id,
+          device_info: { os: RUBY_PLATFORM, hostname: Socket.gethostname, app_version: Clacky::VERSION }
+        })
+
+        if result[:success]
+          data = result[:data]
+          json_response(res, 200, {
+            ok:                        true,
+            device_code:               data["device_code"],
+            user_code:                 data["user_code"],
+            verification_uri:          data["verification_uri"],
+            verification_uri_complete: data["verification_uri_complete"],
+            interval:                  data["interval"] || 5
+          })
+        else
+          json_response(res, 502, { ok: false, error: result[:error] })
+        end
+      end
+
+      # POST /api/onboard/device/poll  { device_code }
+      # Polls the platform once. While pending, returns { status: "pending" }.
+      # On approval, persists the issued key into agent_config and returns
+      # { status: "approved" } so the frontend can proceed to the onboard session.
+      def api_onboard_device_poll(req, res)
+        body        = parse_json_body(req) || {}
+        device_code = body["device_code"].to_s
+        if device_code.empty?
+          return json_response(res, 422, { ok: false, error: "device_code is required" })
+        end
+
+        client = Clacky::PlatformHttpClient.new
+        result = client.post("/api/v1/device/token", { device_code: device_code })
+        data   = result[:data] || {}
+        status = data["status"]
+
+        if result[:success] && status == "approved"
+          persist_onboard_model(
+            api_key:  data["api_key"],
+            base_url: data["base_url"],
+            model:    data["default_model"]
+          )
+          json_response(res, 200, {
+            ok:            true,
+            status:        "approved",
+            default_model: data["default_model"]
+          })
+        elsif status == "pending"
+          json_response(res, 200, { ok: true, status: "pending" })
+        else
+          # denied / expired / consumed / network error — surface to the client.
+          json_response(res, 200, {
+            ok:     false,
+            status: status || "error",
+            error:  result[:error]
+          })
+        end
+      end
+
+      # Stable per-machine id for the onboarding device flow. Independent of the
+      # brand/license device_id — onboarding can happen before any license.
+      private def onboard_device_id
+        components = [Socket.gethostname, ENV["USER"] || ENV["USERNAME"] || "", RUBY_PLATFORM]
+        Digest::SHA256.hexdigest(components.join(":"))
+      end
+
+      # Persist a device-flow-issued model as the default and re-anchor current_*.
+      private def persist_onboard_model(api_key:, base_url:, model:)
+        @agent_config.models.each { |m| m.delete("type") if m["type"] == "default" }
+        entry = {
+          "id"               => SecureRandom.uuid,
+          "model"            => model,
+          "base_url"         => base_url,
+          "api_key"          => api_key,
+          "anthropic_format" => false,
+          "type"             => "default"
+        }
+        @agent_config.models << entry
+        @agent_config.current_model_id    = entry["id"]
+        @agent_config.current_model_index = @agent_config.models.length - 1
+        @agent_config.save
+      end
+
+
       # GET /api/browser/status
       # Returns real daemon liveness from BrowserManager (not just yml read).
       def api_browser_status(res)
@@ -860,6 +982,52 @@ module Clacky
         json_response(res, 500, { ok: false, error: e.message })
       end
 
+      # GET /api/backup/status
+      def api_backup_status(res)
+        json_response(res, 200, BackupManager.status)
+      rescue StandardError => e
+        json_response(res, 500, { ok: false, error: e.message })
+      end
+
+      # POST /api/backup/run — run a backup immediately.
+      def api_backup_run(res)
+        result = BackupManager.run!
+        json_response(res, 200, { ok: true, archive: File.basename(result[:archive]),
+                                  size: result[:size], dest_dir: result[:dest_dir],
+                                  status: BackupManager.status })
+      rescue StandardError => e
+        json_response(res, 500, { ok: false, error: e.message })
+      end
+
+      # GET /api/backup/download — build a one-off archive and stream it
+      # directly to the browser. Not written to dest_dir nor recorded.
+      def api_backup_download(res)
+        result = BackupManager.build_download!
+        res.status                = 200
+        res["Content-Type"]       = "application/gzip"
+        res["Content-Disposition"] = %(attachment; filename="#{result[:filename]}")
+        res["Cache-Control"]      = "no-store"
+        res.body                  = File.binread(result[:path])
+      rescue StandardError => e
+        json_response(res, 500, { ok: false, error: e.message })
+      ensure
+        FileUtils.rm_f(result[:path]) if result && result[:path]
+      end
+      # Body: { enabled?, cron?, dest_dir?, keep?, include_sessions? }
+      def api_backup_config(req, res)
+        body = parse_json_body(req) || {}
+        cfg = BackupManager.update_config(
+          enabled:          body.key?("enabled") ? body["enabled"] : nil,
+          cron:             body["cron"],
+          dest_dir:         body.key?("dest_dir") ? body["dest_dir"] : nil,
+          keep:             body["keep"],
+          include_sessions: body.key?("include_sessions") ? body["include_sessions"] : nil
+        )
+        json_response(res, 200, { ok: true, config: cfg, status: BackupManager.status })
+      rescue StandardError => e
+        json_response(res, 500, { ok: false, error: e.message })
+      end
+
       # POST /api/telemetry
       # Body: { "event": "share_open" | "share_download", ... }
       # Fire-and-forget telemetry from the WebUI frontend.
@@ -903,6 +1071,65 @@ module Clacky
         json_response(res, 500, { error: e.message })
       end
 
+      def api_media_video(req, res)
+        body = parse_json_body(req)
+        return json_response(res, 400, { error: "Invalid JSON" }) unless body
+
+        prompt = body["prompt"].to_s
+        if prompt.strip.empty?
+          return json_response(res, 422, { error: "prompt is required" })
+        end
+
+        aspect_ratio = body["aspect_ratio"].to_s
+        aspect_ratio = "landscape" if aspect_ratio.empty?
+        duration     = body["duration_seconds"]
+        image        = body["image"]
+        output_dir   = body["output_dir"].to_s
+        output_dir   = @agent_config.default_working_dir || Dir.pwd if output_dir.empty?
+
+        result = Clacky::Media::Generator.new(@agent_config).generate_video(
+          prompt: prompt,
+          aspect_ratio: aspect_ratio,
+          duration_seconds: duration,
+          output_dir: output_dir,
+          image: image
+        )
+        if result["success"]
+          log_media_usage(result, prompt: prompt)
+        end
+        status = result["success"] ? 200 : 422
+        json_response(res, status, result)
+      rescue StandardError => e
+        json_response(res, 500, { error: e.message })
+      end
+
+      def api_media_audio_speech(req, res)
+        body = parse_json_body(req)
+        return json_response(res, 400, { error: "Invalid JSON" }) unless body
+
+        input = body["input"].to_s
+        if input.strip.empty?
+          return json_response(res, 422, { error: "input is required" })
+        end
+
+        voice      = body["voice"]
+        output_dir = body["output_dir"].to_s
+        output_dir = @agent_config.default_working_dir || Dir.pwd if output_dir.empty?
+
+        result = Clacky::Media::Generator.new(@agent_config).generate_speech(
+          input: input,
+          voice: voice,
+          output_dir: output_dir
+        )
+        if result["success"]
+          log_media_usage(result, prompt: input)
+        end
+        status = result["success"] ? 200 : 422
+        json_response(res, status, result)
+      rescue StandardError => e
+        json_response(res, 500, { error: e.message })
+      end
+
       private def log_media_usage(result, prompt:)
         usage = result["usage"]
         cost  = result["cost_usd"]
@@ -919,7 +1146,11 @@ module Clacky
         end
         parts << format("cost_usd=%.6f", cost.to_f) if cost
         parts << "prompt=#{prompt[0, 60].inspect}"
-        Clacky::Logger.info("[Media] image generated #{parts.join(" ")}")
+        kind = if result.key?("video") then "video"
+               elsif result.key?("audio") then "audio"
+               else "image"
+               end
+        Clacky::Logger.info("[Media] #{kind} generated #{parts.join(" ")}")
       end
 
       # GET /api/media/types
@@ -2703,19 +2934,38 @@ module Clacky
         # Convert it to the Linux-side path so File.exist? works.
         path = Utils::EnvironmentDetector.win_to_linux_path(path)
 
-        # Security: only serve image files
+        # Security: only serve media files (images + videos)
         ext = File.extname(path).downcase
-        unless Utils::FileProcessor::LOCAL_IMAGE_EXTENSIONS.include?(ext)
-          return json_response(res, 403, { error: "not an image file" })
+        unless Utils::FileProcessor::LOCAL_MEDIA_EXTENSIONS.include?(ext)
+          return json_response(res, 403, { error: "not a supported media file" })
         end
 
         return json_response(res, 404, { error: "file not found" }) unless File.exist?(path)
 
+        file_size = File.size(path)
         mime = Utils::FileProcessor::MIME_TYPES[ext] || "application/octet-stream"
-        res.status         = 200
-        res["Content-Type"] = mime
-        res["Cache-Control"] = "private, max-age=3600"
-        res.body = File.binread(path)
+
+        # Support HTTP Range requests for video seeking
+        range_header = req["Range"]
+        if range_header && range_header =~ /\Abytes=(\d*)-(\d*)\z/
+          start_byte = ($1.empty? ? 0 : $1.to_i)
+          end_byte   = ($2.empty? ? file_size - 1 : $2.to_i)
+          end_byte   = [end_byte, file_size - 1].min
+
+          res.status = 206
+          res["Content-Type"]  = mime
+          res["Content-Range"] = "bytes #{start_byte}-#{end_byte}/#{file_size}"
+          res["Accept-Ranges"] = "bytes"
+          res["Cache-Control"] = "private, max-age=3600"
+          res["Content-Length"] = (end_byte - start_byte + 1).to_s
+          IO.binread(path, end_byte - start_byte + 1, start_byte).then { |data| res.body = data }
+        else
+          res.status         = 200
+          res["Content-Type"] = mime
+          res["Accept-Ranges"] = "bytes"
+          res["Cache-Control"] = "private, max-age=3600"
+          res.body = File.binread(path)
+        end
       rescue => e
         json_response(res, 500, { error: e.message })
       end
@@ -3112,6 +3362,7 @@ module Clacky
         query = URI.decode_www_form(req.query_string.to_s).to_h
         rel = query["path"].to_s
         absolute_mode = query["absolute"] == "true"
+        show_hidden = query["show_hidden"] == "true"
 
         # Absolute mode: allow browsing outside working directory (e.g., root "/")
         if absolute_mode
@@ -3131,7 +3382,9 @@ module Clacky
         end
 
         return json_response(res, 404, { error: "Directory not found" }) unless Dir.exist?(target)
-        entries = Dir.children(target).reject { |name| IGNORED_FILE_ENTRIES.include?(name) }
+        entries = Dir.children(target).reject do |name|
+          IGNORED_FILE_ENTRIES.include?(name) || (!show_hidden && name.start_with?("."))
+        end
 
         items = entries.filter_map do |name|
           full = File.join(target, name)
@@ -3155,6 +3408,45 @@ module Clacky
       rescue StandardError => e
         json_response(res, 500, { error: e.message })
       end
+
+      # GET /api/dirs?path=<absolute-or-~-path>
+      # Session-independent directory browser used by the New Session modal,
+      # where no session (and thus no working_dir) exists yet. Always operates
+      # in absolute mode and lists directories only.
+      def api_browse_dirs(req, res)
+        query = URI.decode_www_form(req.query_string.to_s).to_h
+        rel   = query["path"].to_s.strip
+        show_hidden = query["show_hidden"] == "true"
+        rel   = Dir.home if rel.empty?
+        target = File.expand_path(rel.start_with?("~") ? rel.sub(/\A~/, Dir.home) : rel)
+
+        # The requested directory may not exist yet (e.g. the default
+        # ~/clacky_workspace before any session created it). Instead of 404,
+        # walk up to the nearest existing ancestor so the picker stays usable.
+        until Dir.exist?(target)
+          parent = File.dirname(target)
+          break if parent == target
+          target = parent
+        end
+        return json_response(res, 404, { error: "Directory not found" }) unless Dir.exist?(target)
+
+        entries = Dir.children(target).reject do |name|
+          IGNORED_FILE_ENTRIES.include?(name) || (!show_hidden && name.start_with?("."))
+        end
+        items = entries.filter_map do |name|
+          full = File.join(target, name)
+          next unless File.directory?(full) && File.exist?(full)
+          { name: name, path: full, type: "dir" }
+        rescue StandardError
+          nil
+        end
+        items.sort_by! { |it| it[:name].downcase }
+
+        json_response(res, 200, { root: target, path: target, parent: File.dirname(target), home: Dir.home, entries: items })
+      rescue StandardError => e
+        json_response(res, 500, { error: e.message })
+      end
+
       # Body: { enabled: true/false }
       def api_toggle_skill(name, req, res)
         body    = parse_json_body(req)
@@ -3908,7 +4200,7 @@ module Clacky
       # ── Config API ────────────────────────────────────────────────────────────
 
       # GET /api/config — return current model configurations
-      def api_get_config(res)
+      def api_get_config(req, res)
         models = @agent_config.models.map.with_index do |m, i|
           {
             id:               m["id"],   # Stable runtime id — use this for switching
@@ -3921,19 +4213,58 @@ module Clacky
           }
         end
         # Filter out auto-injected models (lite, derived media) AND media
-        # entries (image/video/audio) — those are managed via the dedicated
+        # entries (image/video/audio/ocr) — those are managed via the dedicated
         # media-config UI, not the chat-model card list.
         models.reject! do |m|
           raw = @agent_config.models[m[:index]]
-          raw["auto_injected"] || Clacky::Providers::MEDIA_KINDS.include?(raw["type"].to_s)
+          raw["auto_injected"] ||
+            Clacky::Providers::MEDIA_KINDS.include?(raw["type"].to_s) ||
+            raw["type"].to_s == "ocr"
         end
+        # Capabilities follow the model the *session* is actually running on
+        # (it may differ from the global default after a per-session switch).
+        query   = URI.decode_www_form(req.query_string.to_s).to_h
+        cfg     = config_for_session(query["session_id"]) || @agent_config
         json_response(res, 200, {
           models: models,
           current_index: @agent_config.current_model_index,
-          current_id: @agent_config.current_model&.dig("id")
+          current_id: @agent_config.current_model&.dig("id"),
+          media_capabilities: media_capabilities_payload(cfg)
         })
       end
 
+      # Resolve the AgentConfig for a given session, falling back to nil when
+      # the session isn't live so callers can use the global config instead.
+      def config_for_session(session_id)
+        return nil if session_id.to_s.strip.empty?
+        return nil unless @registry.ensure(session_id)
+
+        agent = nil
+        @registry.with_session(session_id) { |s| agent = s[:agent] }
+        agent&.config
+      end
+
+      # Capability summary for the model dropdown's footer.
+      #   vision — true when the current default model handles images itself
+      #            OR a vision sidecar is configured (ocr_state covers both).
+      #   image/video/audio — true only when a dedicated sidecar is configured;
+      #            the chat model can never generate these on its own.
+      def media_capabilities_payload(cfg = @agent_config)
+        ocr = cfg.ocr_state
+        out = {
+          vision: {
+            configured: !!ocr["configured"],
+            primary:    !!ocr["primary"],
+            model:      ocr["model"]
+          }
+        }
+        Clacky::Providers::MEDIA_KINDS.each do |t|
+          state = cfg.media_state(t)
+          out[t] = { configured: !!state["configured"], model: state["model"] }
+        end
+        out
+      end
+
       # GET /api/config/settings — return advanced settings
       def api_get_settings(res)
         json_response(res, 200, {

data/lib/clacky/server/scheduler.rb

@@ -210,6 +210,8 @@ module Clacky
 
       # Check all enabled schedules against the given time and fire matching ones.
       private def tick(now)
+        maybe_run_backup(now)
+
         load_schedules.each do |schedule|
           next unless schedule["enabled"] != false
           next unless cron_matches?(schedule["cron"].to_s, now)
@@ -248,6 +250,23 @@ module Clacky
         Clacky::Logger.error("scheduler_fire_error", task: schedule["task"], error: e)
       end
 
+      # Built-in automatic backup hook. Runs as a plain system operation —
+      # no AI session — when the backup cron matches and auto-backup is enabled.
+      private def maybe_run_backup(now)
+        cfg = BackupManager.config
+        return unless cfg["enabled"]
+        return unless cron_matches?(cfg["cron"].to_s, now)
+
+        minute_key = now.strftime("%Y%m%d%H%M")
+        return if @last_backup_minute == minute_key
+
+        @last_backup_minute = minute_key
+        result = BackupManager.run!
+        Clacky::Logger.info("scheduler_backup_done", archive: File.basename(result[:archive]), size: result[:size])
+      rescue => e
+        Clacky::Logger.error("scheduler_backup_error", error: e)
+      end
+
       # ── Cron parsing ─────────────────────────────────────────────────────────
 
       # Returns true if the 5-field cron expression matches the given Time.

data/lib/clacky/server/session_registry.rb

@@ -44,7 +44,7 @@ module Clacky
           error:                nil,
           error_code:           nil,
           top_up_url:           nil,
-          updated_at:           Time.now,
+          updated_at:           nil,
           agent:                nil,
           ui:                   nil,
           thread:               nil,
@@ -170,6 +170,7 @@ module Clacky
             live_name  = nil if live_name&.empty?
           live_cost_source = s[:agent]&.cost_source
           { status: s[:status], error: s[:error], error_code: s[:error_code], top_up_url: s[:top_up_url],
+            updated_at: s[:updated_at]&.iso8601,
             model: model_info&.dig(:model), model_id: model_info&.dig(:id), name: live_name,
             total_tasks: s[:agent]&.total_tasks, total_cost: s[:agent]&.total_cost,
             cost_source: live_cost_source,
@@ -227,7 +228,9 @@ module Clacky
         pinned, non_pinned = all.partition { |s| s[:pinned] }
 
         # `before` cursor ONLY applies to non-pinned (paginated) sessions.
-        non_pinned = non_pinned.select { |s| (s[:created_at] || "") < before } if before
+        # Cursor field must match the sort key in all_sessions (updated_at,
+        # falling back to created_at for legacy rows).
+        non_pinned = non_pinned.select { |s| (s[:updated_at] || s[:created_at] || "") < before } if before
         non_pinned = non_pinned.first(limit) if limit
 
         # Pinned section: only included on the first page (before == nil) so
@@ -267,6 +270,7 @@ module Clacky
           live_name  = s[:agent]&.name
           live_name  = nil if live_name&.empty?
           { status: s[:status], error: s[:error], error_code: s[:error_code], top_up_url: s[:top_up_url],
+            updated_at: s[:updated_at]&.iso8601,
             model: model_info&.dig(:model), model_id: model_info&.dig(:id),
             name: live_name, total_tasks: s[:agent]&.total_tasks,
             total_cost: s[:agent]&.total_cost, cost_source: s[:agent]&.cost_source,
@@ -301,7 +305,7 @@ module Clacky
           agent_profile: (s[:agent_profile] || "general").to_s,
           working_dir:   s[:working_dir],
           created_at:    s[:created_at],
-          updated_at:    s[:updated_at],
+          updated_at:    ls&.dig(:updated_at) || s[:updated_at],
           total_tasks:   ls&.dig(:total_tasks) || s.dig(:stats, :total_tasks) || 0,
           total_cost:    ls&.dig(:total_cost)  || s.dig(:stats, :total_cost_usd) || 0.0,
           cost_source:   (ls&.dig(:cost_source) || s.dig(:stats, :cost_source) || "estimated").to_s,
@@ -466,7 +470,7 @@ module Clacky
           working_dir:     agent.working_dir,
           status:          session[:status],
           created_at:      agent.created_at,
-          updated_at:      session[:updated_at].iso8601,
+          updated_at:      session[:updated_at]&.iso8601 || agent.created_at,
           total_tasks:     agent.total_tasks || 0,
           total_cost:      agent.total_cost  || 0.0,
           cost_source:     agent.cost_source.to_s,

data/lib/clacky/session_manager.rb

@@ -4,6 +4,7 @@ require "json"
 require "fileutils"
 require "securerandom"
 require "open3"
+require "set"
 
 module Clacky
   class SessionManager
@@ -162,14 +163,15 @@ module Clacky
       chunk_path
     end
 
-    # All sessions from disk, newest-first (sorted by created_at).
+    # All sessions from disk, newest-first (sorted by last activity / updated_at,
+    # falling back to created_at for legacy sessions without updated_at).
     # Optional filters:
     #   current_dir: (String) if given, sessions matching working_dir come first
     #   limit:       (Integer) max number of sessions to return
     def all_sessions(current_dir: nil, limit: nil)
       sessions = Dir.glob(File.join(@sessions_dir, "*.json")).filter_map do |filepath|
         load_session_file(filepath)
-      end.sort_by { |s| s[:created_at] || "" }.reverse
+      end.sort_by { |s| s[:updated_at] || s[:created_at] || "" }.reverse
 
       if current_dir
         current_sessions = sessions.select { |s| s[:working_dir] == current_dir }
@@ -412,5 +414,41 @@ module Clacky
     rescue JSON::ParserError, Errno::ENOENT
       nil
     end
+
+    # Remove Time Machine snapshots that no longer belong to any known session.
+    # Snapshots are keyed by full session_id; session files are named by the
+    # 8-char id prefix, so a snapshot dir is an orphan when its prefix matches
+    # no active or trashed session file. Returns the count of removed dirs.
+    def self.cleanup_orphan_snapshots(sessions_dir: SESSIONS_DIR, snapshots_root: nil)
+      snapshots_root ||= File.join(Dir.home, ".clacky", "snapshots")
+      return 0 unless Dir.exist?(snapshots_root)
+
+      require_relative "utils/trash_directory"
+      known = _session_id_prefixes(File.join(sessions_dir, "*.json"))
+      trash_dir = Clacky::TrashDirectory.sessions_trash_dir
+      known += _session_id_prefixes(File.join(trash_dir, "*.json")) if Dir.exist?(trash_dir)
+      known = known.to_set
+
+      removed = 0
+      Dir.children(snapshots_root).each do |name|
+        dir = File.join(snapshots_root, name)
+        next unless File.directory?(dir)
+        next if known.include?(name[0, 8])
+
+        FileUtils.rm_rf(dir)
+        removed += 1
+      end
+      removed
+    end
+
+    # Session filenames look like "<datetime>-<8hexid>.json"; pull out the
+    # trailing 8-char id prefix, which matches a snapshot dir's name prefix.
+    def self._session_id_prefixes(glob)
+      Dir.glob(glob).filter_map do |p|
+        m = File.basename(p, ".json").match(/-([0-9a-f]{8})\z/)
+        m && m[1]
+      end
+    end
+    private_class_method :_session_id_prefixes
   end
 end