openclacky 1.2.18 → 1.3.0

data/lib/clacky/default_skills/media-gen/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: media-gen
-description: 'Generate images (and later videos / audio) inside the current task. Use this skill whenever the user asks to create, generate, or produce a picture / image / illustration / cover / poster / icon / artwork — including phrases like 生成图片, 画一张, 做封面, 来张配图, generate image, make a picture, draw, create artwork, design a cover. Also use when building documents (slides, PPT, posters, marketing pages, README hero shots) where an image is needed inline. Routes calls through the local Clacky HTTP server, which uses the user-configured `type=image` model — you do NOT need to know which provider; the server handles it.'
+description: 'Generate images, videos, or audio (text-to-speech) in the current task. Use whenever the user asks to create/generate/produce a picture / image / illustration / cover / poster / icon / artwork, a video / clip / animation, or speech / voiceover / narration / TTS — e.g. 生成图片, 画一张, 做封面, 配图, generate image, make a picture, draw, design a cover, 生成视频, 做个视频, text-to-video, 朗读, 配音, 旁白, 文字转语音, generate speech, voiceover. Also use when a document (slides, poster, README hero) needs an inline image.'
 disable-model-invocation: false
 user-invocable: true
 always-show: true
@@ -27,13 +27,29 @@ curl -s http://${CLACKY_SERVER_HOST}:${CLACKY_SERVER_PORT}/api/media/types
 
 If the response shows `image.configured = false`, stop and tell the user:
 
-> 还没有配置生图模型。请打开 Clacky 设置页 → 添加模型 → 类型选 `image`（推荐 `or-gemini-3-pro-image` 或 `or-gpt-image-1`）。配好后再让我生图。
+> 还没有配置生图模型。请打开设置页 → 添加模型 → 类型选 `image`（走 openclacky 官方网关时推荐 `or-gemini-3-pro-image` 或 `or-gpt-image-2`）。配好后再让我生图。
 
 Do NOT try to fall back to `terminal` + a hand-written `curl https://api.openai.com/...` — that bypasses the user's configured backend and won't be billed correctly.
 
+**You do NOT configure models — the user does, in the settings page.** Never
+edit the user's `config.yml` to add or change a model, and never invent a model
+name from memory (e.g. `or-gpt-5.4-image-2` does not exist). The real, current
+model is whatever `/api/media/types` reports under `image.model`. If you think a
+different model is needed, tell the user which one to set in the settings page —
+don't touch the config file yourself.
+
 ## Step 2 — Generate the image
 
-### ⚠️  Important: generation speed & concurrency
+### The model does NOT honor exact pixel sizes
+
+There is no `size` / `width` / `height` field — the only shape control is
+`aspect_ratio` (`landscape` / `square` / `portrait`), and even that is just a
+rough hint (ask for `576x96` and you may get `1408x768`). When the user needs an
+**exact pixel size, a grid, an icon at NxN, or a spritesheet**, generate first at
+whatever size the model gives, then resize / crop / tile to the exact pixels with
+ImageMagick (`magick`). Verify with `magick identify` before reporting done.
+
+### Important: generation speed & concurrency
 
 - **Image generation can be slow — up to 2 minutes per image depending on the model.** Before calling the API, warn the user that it may take a minute or two. The curl request blocks until the image is ready; do NOT run it in the background.
 - **One at a time only.** Never generate multiple images concurrently (e.g. by running several `curl` commands simultaneously or in a script loop). Each call consumes significant server-side resources, and parallel requests will almost certainly cause timeouts. If the user wants several images, generate them **sequentially**, one after another.
@@ -47,6 +63,10 @@ curl -s -X POST http://${CLACKY_SERVER_HOST}:${CLACKY_SERVER_PORT}/api/media/ima
   }'
 ```
 
+- The terminal blocks multi-line commands — write the request into a `.sh` file and run it, don't paste a multi-line `curl`.
+- If a call fails with `400 / INVALID_ARGUMENT`, drop the `aspect_ratio` field and retry once before reporting the error.
+- If a call fails with `unknown image model` (400), the configured model name isn't recognized by its backend — tell the user to fix the model name in the settings page; do NOT guess another name and retry.
+
 ### Request fields
 
 | Field          | Required | Values                              | Notes |
@@ -129,6 +149,153 @@ When the user gives a vague request like "给我配张图", ask one clarifying q
 - The user wants a **diagram / chart** with specific data — use a charting library (matplotlib, mermaid, etc.) instead; image gen is for illustrations, not data viz
 - The user asks for **screenshots** of real software — use the browser tool
 
-## Future modalities
+## Generating video (Veo)
+
+The same `/api/media/` namespace serves video generation. The user must
+configure a `type=video` model in settings (recommended: `or-veo-3-1`).
+
+### Endpoint
+
+```
+POST http://${CLACKY_SERVER_HOST}:${CLACKY_SERVER_PORT}/api/media/video
+```
+
+Check `GET /api/media/types` first — if `video.configured = false`, tell the
+user to add a `type=video` model in settings before generating.
+
+### Video is slow and expensive
+
+- **A single clip can take 1–3 minutes (sometimes longer).** Warn the user
+  before calling, and run the curl in the foreground — it blocks until the
+  MP4 is ready. Do NOT background it.
+- **One at a time.** Never run multiple video generations concurrently.
+- Each clip costs real money (billed per output-second). Confirm the prompt
+  with the user before generating.
+
+### Request
+
+```bash
+curl -s -X POST http://${CLACKY_SERVER_HOST}:${CLACKY_SERVER_PORT}/api/media/video \
+  -H "Content-Type: application/json" \
+  -d '{
+    "prompt": "A cinematic drone shot flying over a misty mountain range at sunrise, golden light, 4K.",
+    "aspect_ratio": "landscape",
+    "duration_seconds": 8
+  }'
+```
+
+| Field              | Required | Values                          | Notes |
+|--------------------|----------|---------------------------------|-------|
+| `prompt`           | yes      | string                          | Same prompt-craft tips as images apply. |
+| `aspect_ratio`     | no       | `landscape` / `portrait`        | Defaults to `landscape` (16:9). |
+| `duration_seconds` | no       | 4–8                             | Defaults to 8. |
+| `image`            | no       | `{ "b64_json": "...", "mime_type": "image/png" }` | Optional first frame for image-to-video. |
+| `output_dir`       | no       | absolute path                   | MP4 saved under `<output_dir>/assets/generated/`. |
+
+### Response (success)
+
+```json
+{
+  "success": true,
+  "video": "/abs/path/to/working_dir/assets/generated/vid_20260615_011820_a1b2c3d4.mp4",
+  "model": "or-veo-3-1",
+  "provider": "openclacky",
+  "prompt": "A cinematic drone shot ...",
+  "aspect_ratio": "landscape",
+  "duration_seconds": 8,
+  "cost_usd": 2.688
+}
+```
+
+The `video` field is an absolute path on disk. Show it to the user with a
+markdown link or an HTML5 `<video>` tag pointing at the `file://` path; embed
+it in documents with a relative path under `./assets/generated/`.
+
+### Response (failure)
+
+Same shape and `error_type` values as image generation, but with `"video": null`.
+`not_configured` means no `type=video` model is set up.
+
+## Generating speech (Gemini TTS)
+
+The same `/api/media/` namespace serves text-to-speech. The user must
+configure a `type=audio` model in settings (recommended:
+`or-tts-gemini-2-5-flash`, the cheap+fast default).
+
+### Endpoint
+
+```
+POST http://${CLACKY_SERVER_HOST}:${CLACKY_SERVER_PORT}/api/media/audio/speech
+```
+
+Check `GET /api/media/types` first — if `audio.configured = false`, tell the
+user to add a `type=audio` model in settings before generating.
+
+### Request
+
+```bash
+curl -s -X POST http://${CLACKY_SERVER_HOST}:${CLACKY_SERVER_PORT}/api/media/audio/speech \
+  -H "Content-Type: application/json" \
+  -d '{
+    "input": "Hello and welcome to openclacky. Today we will explore...",
+    "voice": "Kore"
+  }'
+```
+
+| Field        | Required | Values                          | Notes |
+|--------------|----------|---------------------------------|-------|
+| `input`      | yes      | string                          | The text to speak. Plain prose works best; you can prefix with style cues like "Say cheerfully:" or "In a calm tone:". |
+| `voice`      | no       | string voice name               | Defaults to `Kore`. Common Gemini voices: `Kore`, `Puck`, `Charon`, `Fenrir`, `Aoede`. |
+| `output_dir` | no       | absolute path                   | WAV saved under `<output_dir>/assets/generated/`. |
+
+Generation typically takes 2–10 seconds depending on length. The request
+blocks until the WAV is ready.
+
+### Response (success)
+
+```json
+{
+  "success": true,
+  "audio": "/abs/path/to/working_dir/assets/generated/tts_20260615_233522_4ff02705.wav",
+  "model": "or-tts-gemini-2-5-flash",
+  "provider": "openclacky",
+  "input": "Hello and welcome to openclacky...",
+  "voice": "Kore",
+  "mime_type": "audio/wav",
+  "usage": { "prompt_tokens": 13, "completion_tokens": 122, "total_tokens": 135 },
+  "cost_usd": 0.000259
+}
+```
+
+The `audio` field is an absolute path on disk. Output is mono 16-bit PCM at
+24 kHz wrapped in a standard WAV container — playable by any browser, OS
+player, or `<audio>` tag without conversion.
+
+To let the user hear it, write a markdown link in your reply:
+
+```markdown
+[🔊 听一下](file:///abs/path/from/response.wav)
+```
+
+For embedding in HTML documents, use:
+
+```html
+<audio controls src="./assets/generated/xxx.wav"></audio>
+```
+
+### Response (failure)
+
+Same shape and `error_type` values as image generation, but with `"audio": null`.
+`not_configured` means no `type=audio` model is set up.
+
+### Cost & length tips
+
+- Gemini TTS bills by tokens (input text + generated audio). A typical
+  one-paragraph narration costs well under $0.001.
+- For long-form audio (>1 minute), split the script into paragraphs and
+  generate each separately, then concatenate locally — avoids upstream
+  truncation and gives you finer control over pacing.
+- Voice consistency: Gemini TTS does not currently support voice cloning;
+  use the same `voice` name across calls in one project to keep the
+  narrator consistent.
 
-The same `/api/media/` namespace will gain `video` and `audio` endpoints. The pattern is identical: the user configures `type=video` / `type=audio` models in settings, this skill (or its successor) calls the matching endpoint.

data/lib/clacky/media/base.rb

@@ -29,6 +29,28 @@ module Clacky
         raise NotImplementedError, "#{self.class.name} must implement #generate_image"
       end
 
+      # @return [Hash] either video_success_response(...) or
+      #   video_error_response(...)
+      def generate_video(prompt:, aspect_ratio: "landscape", duration_seconds: nil, output_dir: nil, **_kwargs)
+        video_error_response(
+          error: "Video generation is not supported by #{self.class.name.split("::").last}. Use the openclacky gateway with a video model such as or-veo-3-1.",
+          error_type: "not_implemented",
+          provider: "",
+          prompt: prompt,
+          aspect_ratio: aspect_ratio
+        )
+      end
+
+      # @return [Hash] either audio_success_response(...) or audio_error_response(...)
+      def generate_speech(input:, voice: nil, output_dir: nil, **_kwargs)
+        audio_error_response(
+          error: "Speech synthesis is not supported by #{self.class.name.split("::").last}. Use the openclacky gateway with a TTS model such as or-tts-gemini-2-5-flash.",
+          error_type: "not_implemented",
+          provider: "",
+          input: input
+        )
+      end
+
       # Persist a base64-encoded image under <output_dir>/assets/generated/.
       # Returns the absolute path on disk.
       private def save_b64_image(b64_data, output_dir:, prefix: "img", extension: "png")
@@ -41,6 +63,29 @@ module Clacky
         path
       end
 
+      # Persist a base64-encoded video under <output_dir>/assets/generated/.
+      # Returns the absolute path on disk. Mirrors #save_b64_image; the only
+      # difference is the default extension (mp4).
+      private def save_b64_video(b64_data, output_dir:, prefix: "vid", extension: "mp4")
+        target_dir = File.join(output_dir, "assets", "generated")
+        FileUtils.mkdir_p(target_dir)
+        ts    = Time.now.strftime("%Y%m%d_%H%M%S")
+        short = SecureRandom.hex(4)
+        path  = File.join(target_dir, "#{prefix}_#{ts}_#{short}.#{extension}")
+        File.binwrite(path, Base64.decode64(b64_data))
+        path
+      end
+
+      private def save_b64_audio(b64_data, output_dir:, prefix: "tts", extension: "wav")
+        target_dir = File.join(output_dir, "assets", "generated")
+        FileUtils.mkdir_p(target_dir)
+        ts    = Time.now.strftime("%Y%m%d_%H%M%S")
+        short = SecureRandom.hex(4)
+        path  = File.join(target_dir, "#{prefix}_#{ts}_#{short}.#{extension}")
+        File.binwrite(path, Base64.decode64(b64_data))
+        path
+      end
+
       # Download a remote image URL and persist it under
       # <output_dir>/assets/generated/, mirroring save_b64_image so providers
       # that return URLs (e.g. DashScope, whose links expire after 24h) land
@@ -95,6 +140,54 @@ module Clacky
           "provider"     => provider
         }
       end
+
+      private def video_success_response(video:, prompt:, aspect_ratio:, provider:, extra: {})
+        {
+          "success"      => true,
+          "video"        => video,
+          "model"        => @model,
+          "prompt"       => prompt,
+          "aspect_ratio" => aspect_ratio,
+          "provider"     => provider
+        }.merge(extra)
+      end
+
+      private def video_error_response(error:, error_type: "provider_error", provider: "", prompt: "", aspect_ratio: "landscape")
+        {
+          "success"      => false,
+          "video"        => nil,
+          "error"        => error,
+          "error_type"   => error_type,
+          "model"        => @model,
+          "prompt"       => prompt,
+          "aspect_ratio" => aspect_ratio,
+          "provider"     => provider
+        }
+      end
+
+      private def audio_success_response(audio:, input:, voice:, provider:, extra: {})
+        {
+          "success"  => true,
+          "audio"    => audio,
+          "model"    => @model,
+          "input"    => input,
+          "voice"    => voice,
+          "provider" => provider
+        }.merge(extra)
+      end
+
+      private def audio_error_response(error:, error_type: "provider_error", provider: "", input: "", voice: "")
+        {
+          "success"    => false,
+          "audio"      => nil,
+          "error"      => error,
+          "error_type" => error_type,
+          "model"      => @model,
+          "input"      => input,
+          "voice"      => voice,
+          "provider"   => provider
+        }
+      end
     end
   end
 end

data/lib/clacky/media/gemini.rb

@@ -31,6 +31,16 @@ module Clacky
           aspect_ratio: aspect_ratio
         )
       end
+
+      def generate_video(prompt:, aspect_ratio: "landscape", duration_seconds: nil, output_dir: nil, **_kwargs)
+        video_error_response(
+          error: "Direct Google AI Studio video generation is not supported. Use the openclacky gateway (base_url https://api.openclacky.com) with a video model such as or-veo-3-1.",
+          error_type: "not_implemented",
+          provider: "gemini-direct",
+          prompt: prompt,
+          aspect_ratio: aspect_ratio
+        )
+      end
     end
   end
 end

data/lib/clacky/media/generator.rb

@@ -44,6 +44,16 @@ module Clacky
         @agent_config.find_model_by_type("image")
       end
 
+      # @return [Hash, nil] the type=video model entry, or nil if not configured
+      def video_model_entry
+        @agent_config.find_model_by_type("video")
+      end
+
+      # @return [Hash, nil] the type=audio model entry, or nil if not configured
+      def audio_model_entry
+        @agent_config.find_model_by_type("audio")
+      end
+
       def generate_image(prompt:, aspect_ratio: "landscape", output_dir: nil, **kwargs)
         entry = image_model_entry
         if entry.nil?
@@ -67,6 +77,53 @@ module Clacky
         )
       end
 
+      def generate_video(prompt:, aspect_ratio: "landscape", duration_seconds: nil, output_dir: nil, **kwargs)
+        entry = video_model_entry
+        if entry.nil?
+          return {
+            "success"    => false,
+            "video"      => nil,
+            "error"      => "No video model configured. Add a model with type=video in settings.",
+            "error_type" => "not_configured",
+            "provider"   => "",
+            "model"      => "",
+            "prompt"     => prompt
+          }
+        end
+
+        provider = build_provider_for(entry)
+        provider.generate_video(
+          prompt: prompt,
+          aspect_ratio: aspect_ratio,
+          duration_seconds: duration_seconds,
+          output_dir: output_dir,
+          **kwargs
+        )
+      end
+
+      def generate_speech(input:, voice: nil, output_dir: nil, **kwargs)
+        entry = audio_model_entry
+        if entry.nil?
+          return {
+            "success"    => false,
+            "audio"      => nil,
+            "error"      => "No audio model configured. Add a model with type=audio in settings.",
+            "error_type" => "not_configured",
+            "provider"   => "",
+            "model"      => "",
+            "input"      => input
+          }
+        end
+
+        provider = build_provider_for(entry)
+        provider.generate_speech(
+          input: input,
+          voice: voice,
+          output_dir: output_dir,
+          **kwargs
+        )
+      end
+
       # Pick the adapter class for a media model entry.
       #
       # Routing rules:

data/lib/clacky/media/openai_compat.rb

@@ -22,6 +22,12 @@ module Clacky
 
       DEFAULT_ASPECT = "landscape"
 
+      # Video aspect ratios accepted by the gateway's /videos/generations
+      # endpoint. The human-friendly labels map straight through; the gateway
+      # normalises to Veo's "16:9" / "9:16" internally.
+      VIDEO_ASPECTS = %w[landscape portrait].freeze
+      DEFAULT_VIDEO_DURATION = 8
+
       def generate_image(prompt:, aspect_ratio: DEFAULT_ASPECT, output_dir: nil, n: 1, **_kwargs)
         provider_id = Clacky::Providers.find_by_base_url(@base_url) || "custom"
         aspect      = ASPECT_TO_SIZE.key?(aspect_ratio) ? aspect_ratio : DEFAULT_ASPECT
@@ -135,6 +141,143 @@ module Clacky
         )
       end
 
+      def generate_video(prompt:, aspect_ratio: DEFAULT_ASPECT, duration_seconds: nil, output_dir: nil, image: nil, **_kwargs)
+        provider_id = Clacky::Providers.find_by_base_url(@base_url) || "custom"
+        aspect      = VIDEO_ASPECTS.include?(aspect_ratio) ? aspect_ratio : DEFAULT_ASPECT
+        duration    = duration_seconds.to_i
+        duration    = DEFAULT_VIDEO_DURATION if duration <= 0
+
+        if prompt.to_s.strip.empty?
+          return video_error_response(
+            error: "Prompt is required and must be a non-empty string",
+            error_type: "invalid_argument", provider: provider_id, aspect_ratio: aspect
+          )
+        end
+        if @api_key.to_s.empty?
+          return video_error_response(
+            error: "api_key not configured for video model '#{@model}'",
+            error_type: "auth_required", provider: provider_id, prompt: prompt, aspect_ratio: aspect
+          )
+        end
+
+        payload = { model: @model, prompt: prompt, aspect_ratio: aspect, duration_seconds: duration }
+        payload[:image] = image if image.is_a?(Hash) && image["b64_json"]
+
+        begin
+          response = video_connection.post("videos/generations") do |req|
+            req.headers["Content-Type"]  = "application/json"
+            req.headers["Authorization"] = "Bearer #{@api_key}"
+            req.body = JSON.generate(payload)
+          end
+        rescue Faraday::Error => e
+          return video_error_response(
+            error: "HTTP request failed: #{e.message}",
+            error_type: "network_error", provider: provider_id, prompt: prompt, aspect_ratio: aspect
+          )
+        end
+
+        unless response.success?
+          return video_error_response(
+            error: "Upstream #{response.status}: #{truncate(response.body, 500)}",
+            error_type: "api_error", provider: provider_id, prompt: prompt, aspect_ratio: aspect
+          )
+        end
+
+        body = parse_json(response.body)
+        return video_error_response(
+          error: "Invalid JSON response from upstream",
+          error_type: "invalid_response", provider: provider_id, prompt: prompt, aspect_ratio: aspect
+        ) unless body.is_a?(Hash)
+
+        first = (body["data"] || []).first
+        if first.nil? || first["b64_json"].to_s.empty?
+          return video_error_response(
+            error: "Upstream returned no video data",
+            error_type: "empty_response", provider: provider_id, prompt: prompt, aspect_ratio: aspect
+          )
+        end
+
+        path = save_b64_video(first["b64_json"], output_dir: output_dir || Dir.pwd, prefix: "vid")
+        video_success_response(
+          video: path, prompt: prompt, aspect_ratio: aspect, provider: provider_id,
+          extra: {
+            "duration_seconds" => duration,
+            "usage"            => body["usage"],
+            "cost_usd"         => body["cost_usd"]
+          }.compact
+        )
+      end
+
+      def generate_speech(input:, voice: nil, output_dir: nil, **_kwargs)
+        provider_id = Clacky::Providers.find_by_base_url(@base_url) || "custom"
+
+        if input.to_s.strip.empty?
+          return audio_error_response(
+            error: "input is required and must be a non-empty string",
+            error_type: "invalid_argument", provider: provider_id, voice: voice.to_s
+          )
+        end
+        if @api_key.to_s.empty?
+          return audio_error_response(
+            error: "api_key not configured for audio model '#{@model}'",
+            error_type: "auth_required", provider: provider_id, input: input, voice: voice.to_s
+          )
+        end
+
+        payload = { model: @model, input: input }
+        payload[:voice] = voice if voice && !voice.to_s.strip.empty?
+
+        begin
+          response = audio_connection.post("audio/speech") do |req|
+            req.headers["Content-Type"]  = "application/json"
+            req.headers["Authorization"] = "Bearer #{@api_key}"
+            req.body = JSON.generate(payload)
+          end
+        rescue Faraday::Error => e
+          return audio_error_response(
+            error: "HTTP request failed: #{e.message}",
+            error_type: "network_error", provider: provider_id, input: input, voice: voice.to_s
+          )
+        end
+
+        unless response.success?
+          return audio_error_response(
+            error: "Upstream #{response.status}: #{truncate(response.body, 500)}",
+            error_type: "api_error", provider: provider_id, input: input, voice: voice.to_s
+          )
+        end
+
+        body = parse_json(response.body)
+        return audio_error_response(
+          error: "Invalid JSON response from upstream",
+          error_type: "invalid_response", provider: provider_id, input: input, voice: voice.to_s
+        ) unless body.is_a?(Hash)
+
+        first = (body["data"] || []).first
+        if first.nil? || first["b64_json"].to_s.empty?
+          return audio_error_response(
+            error: "Upstream returned no audio data",
+            error_type: "empty_response", provider: provider_id, input: input, voice: voice.to_s
+          )
+        end
+
+        ext = case first["mime_type"].to_s
+              when "audio/mpeg", "audio/mp3" then "mp3"
+              when "audio/ogg" then "ogg"
+              else "wav"
+              end
+
+        path = save_b64_audio(first["b64_json"], output_dir: output_dir || Dir.pwd, prefix: "tts", extension: ext)
+        audio_success_response(
+          audio: path, input: input, voice: body["voice"] || voice.to_s, provider: provider_id,
+          extra: {
+            "mime_type" => first["mime_type"],
+            "usage"     => body["usage"],
+            "cost_usd"  => body["cost_usd"]
+          }.compact
+        )
+      end
+
       private def connection
         Faraday.new(url: normalized_base_url) do |f|
           f.options.timeout      = 240
@@ -142,6 +285,23 @@ module Clacky
         end
       end
 
+      # Video generation runs the gateway's submit+poll cycle inside one
+      # request, which can take several minutes; give it a much longer read
+      # timeout than the image path.
+      private def video_connection
+        Faraday.new(url: normalized_base_url) do |f|
+          f.options.timeout      = 600
+          f.options.open_timeout = 10
+        end
+      end
+
+      private def audio_connection
+        Faraday.new(url: normalized_base_url) do |f|
+          f.options.timeout      = 120
+          f.options.open_timeout = 10
+        end
+      end
+
       private def gemini_family?(model_name)
         model_name.to_s.match?(/gemini|imagen/i)
       end

data/lib/clacky/message_history.rb

@@ -150,11 +150,6 @@ module Clacky
       @messages.find { |m| m[:subagent_instructions] }
     end
 
-    # Return all messages where task_id <= given id (Time Machine support).
-    def for_task(task_id)
-      @messages.select { |m| !m[:task_id] || m[:task_id] <= task_id }
-    end
-
     # ─────────────────────────────────────────────
     # Size helpers
     # ─────────────────────────────────────────────
@@ -191,8 +186,18 @@ module Clacky
     #   can't fire when the previous turns came from a provider that keeps
     #   thinking inline (e.g. MiniMax: <think>...</think> in content), so
     #   this bypass lets us recover on the retry without a server restart.
-    def to_api(force_reasoning_content_pad: false)
-      msgs = @messages.map { |m| strip_for_api(m) }
+    # Convert to API-ready messages. When `task_chain` is given (a Set of
+    # task IDs forming the active task's ancestor chain), messages tagged with
+    # a task_id outside that chain are dropped first — this is the Time Machine
+    # path, ensuring undone/sibling-branch turns never reach the LLM. Messages
+    # without a task_id (system / injected context) are always kept.
+    def to_api(force_reasoning_content_pad: false, task_chain: nil)
+      source = if task_chain
+        @messages.select { |m| !m[:task_id] || task_chain.include?(m[:task_id]) }
+      else
+        @messages
+      end
+      msgs = source.map { |m| strip_for_api(m) }
       msgs = repair_tool_call_pairing(msgs)
       ensure_reasoning_content_consistency(msgs, force: force_reasoning_content_pad)
     end

data/lib/clacky/providers.rb

@@ -60,6 +60,34 @@ module Clacky
           "or-gpt-image-2"             => "GPT Image 2"
         },
         "default_image_model" => "or-gpt-image-2",
+        # Video generation models served by the openclacky gateway, which
+        # routes them to Vertex AI Veo (async predictLongRunning under the
+        # hood; the gateway hides the polling and returns the MP4 inline).
+        "video_models" => [
+          "or-veo-3-1",
+          "or-veo-3-1-fast",
+          "or-veo-3",
+          "or-veo-3-fast"
+        ],
+        "video_model_aliases" => {
+          "or-veo-3-1"      => "Veo 3.1",
+          "or-veo-3-1-fast" => "Veo 3.1 Fast",
+          "or-veo-3"        => "Veo 3",
+          "or-veo-3-fast"   => "Veo 3 Fast"
+        },
+        "default_video_model" => "or-veo-3-1",
+        # Text-to-speech models served by the openclacky gateway, which
+        # routes them to Vertex AI Gemini 2.5 (responseModalities=["AUDIO"]).
+        # The gateway returns WAV inline as base64.
+        "audio_models" => [
+          "or-tts-gemini-2-5-flash",
+          "or-tts-gemini-2-5-pro"
+        ],
+        "audio_model_aliases" => {
+          "or-tts-gemini-2-5-flash" => "Gemini 2.5 Flash TTS",
+          "or-tts-gemini-2-5-pro"   => "Gemini 2.5 Pro TTS"
+        },
+        "default_audio_model" => "or-tts-gemini-2-5-flash",
         # Default OCR sidecar — used when the primary model is text-only.
         # Candidates are derived from the provider's vision-capable models;
         # this just picks the cheap+fast default to surface in "auto" mode.

data/lib/clacky/rich_ui_controller.rb

@@ -559,7 +559,9 @@ module Clacky
       @running = false
     end
 
-    def stop(clear_screen: false)
+    # Clears the screen on exit by default — the Rich UI repaints fullscreen
+    # and leaves no useful scrollback to preserve.
+    def stop(clear_screen: true)
       @running = false
       @shell.stop
       RubyRich::Terminal.clear if clear_screen