openclacky 1.5.18 → 1.5.20

data/lib/clacky/agent.rb

@@ -52,6 +52,9 @@ module Clacky
     attr_accessor :pinned
     attr_accessor :channel_info
     attr_accessor :project_id
+    # ISO8601 stamp set when the user archives the session; nil = active.
+    # Archived sessions stay on disk but drop out of every normal list.
+    attr_accessor :archived_at
 
     REASONING_EFFORTS = %w[low medium high xhigh max].freeze
     MAX_VIDEO_UNDERSTANDING_BYTES = Utils::FileProcessor::MAX_FILE_BYTES
@@ -93,6 +96,7 @@ module Clacky
       @session_id = session_id
       @name = ""
       @pinned = false
+      @archived_at = nil
       @history = MessageHistory.new
       @todos = []  # Store todos in memory
       @iterations = 0
@@ -329,6 +333,14 @@ module Clacky
       self
     end
 
+    # Built-in run failures share the persisted event trail, without exposing
+    # built-in event types through the extension API.
+    def record_error_event(message, code: nil, top_up_url: nil, raw_message: nil)
+      data = { message: message, code: code, top_up_url: top_up_url, raw_message: raw_message }.compact
+      @history.append_ext_event({ type: "error", data: data })
+      self
+    end
+
     # Resolve the model name the goal judge should use. Prefer the provider's
     # lite model (cheap/fast for a one-line verdict); fall back to the primary
     # model when no lite is resolvable.
@@ -485,11 +497,13 @@ module Clacky
       @name = new_name.to_s.strip
     end
 
-    def run(user_input, files: nil, reference_contexts: nil, display_text: nil, created_at: nil, references_display: nil)
+    def run(user_input, files: nil, reference_contexts: nil, display_text: nil, created_at: nil, references_display: nil, feedback: nil)
       # Initialized here (not mid-body) because run's rescue/ensure are
       # method-level and must be able to reference them on any exit path.
       result = nil
       run_turn_started = false
+      completion_sent = false
+      run_context = nil
 
       # Intercept /goal ... commands before any task/LLM work. Control-plane
       # commands (status/pause/resume/clear) return immediately without a turn;
@@ -520,6 +534,10 @@ module Clacky
 
       # Start new task for Time Machine
       task_id = start_new_task(title: display_text.to_s.empty? ? user_input.to_s : display_text.to_s)
+      @feedback = feedback
+      run_context = { session_id: @session_id, run_id: task_id.to_s,
+                      source: @source.to_s, input_created_at: created_at,
+                      observed_at: Time.now.utc.iso8601(6), status: "running" }
 
       # Continuation of a previously-interrupted task (e.g. user sent a
       # supplementary message without stopping the running task) keeps the
@@ -589,13 +607,15 @@ module Clacky
       @input_mutex.synchronize { @accepting_steering = true }
       notify_input_queue
       # The task and user history already exist. A terminal verdict skips the
-      # loop and completion hooks; ensure still cleans up this started turn.
-      hook_result = @hooks.trigger(:on_start, user_input)
+      # loop; ensure still reports completion and cleans up this started turn.
+      hook_result = @hooks.trigger(:on_start, user_input, run_context)
       case hook_result[:action]
       when :deny
+        run_context[:reason] = "hook_denied"
         @ui&.show_warning(hook_result[:reason] || "Task denied by hook")
         return result = build_result.merge(queue_paused: true)
       when :handled
+        run_context[:handled] = true
         return result = hook_result[:result]
       end
 
@@ -793,6 +813,7 @@ module Clacky
       notify_input_queue
       result = build_result(awaiting_user_feedback: awaiting_user_feedback)
       result[:queue_paused] = true if awaiting_user_feedback || task_interrupted
+      run_context[:reason] = "tool_denied" if task_interrupted
 
       # Run skill evolution hooks after main loop completes
       # Skip if task was interrupted by user (denied tool) or awaiting user feedback
@@ -825,7 +846,8 @@ module Clacky
           awaiting_user_feedback: awaiting_user_feedback
         )
       end
-      @hooks.trigger(:on_complete, result)
+      completion_sent = true
+      complete_run_hook(result, run_context)
 
       # Standing-goal loop: after a completed turn, ask the judge whether the
       # goal is met. If not (and budget/health allow), auto-run the next turn
@@ -840,6 +862,8 @@ module Clacky
       result[:queue_paused] = true if @goal_manager&.state&.paused?
       result
     rescue Clacky::AgentInterrupted
+      result = { status: :cancelled }
+      run_context[:reason] = (Thread.current[:interrupt_reason] || :user).to_s if run_context
       # A cancelled fan-out captured its subagents' progress but never reached
       # observe() to persist it — anchor those trails now so a page reload
       # after the interrupt still shows what the subagents did.
@@ -852,6 +876,7 @@ module Clacky
       # Let CLI handle the interrupt message
       raise
     rescue StandardError => e
+      run_context[:error_code] = e.error_code if run_context && e.respond_to?(:error_code)
       # Log complete error information to debug_logs for troubleshooting
       @debug_logs << {
         timestamp: Time.now.iso8601,
@@ -871,6 +896,11 @@ module Clacky
       result = build_result(:error, error: e.message)
       raise
     ensure
+      # A recursive goal continuation owns its own completion. Do not let an
+      # unwinding predecessor settle a newer turn or report the same turn twice.
+      if run_context && !completion_sent && task_id == @current_task_id
+        complete_run_hook(result, run_context)
+      end
       if run_turn_started && task_id == @current_task_id
         @input_mutex.synchronize do
           @accepting_steering = false
@@ -888,10 +918,56 @@ module Clacky
       Clacky::Telemetry.task!(result: result) if run_turn_started
     end
 
+    private def complete_run_hook(result, context)
+      result = { status: :error } unless result.is_a?(Hash)
+      cancelled = context[:reason] || [:cancelled, :interrupted].include?(result[:status])
+      status = if cancelled
+                 "cancelled"
+               elsif result[:status] != :success
+                 "failed"
+               elsif result[:awaiting_user_feedback]
+                 "awaiting_user"
+               else
+                 "completed"
+               end
+      # Denied work can retain its historical return value for queue control,
+      # but completion observers must never interpret it as a successful run.
+      notification = cancelled ? result.merge(status: :cancelled) : result
+      @hooks.trigger(:on_complete, notification,
+                     context.merge(status: status, observed_at: Time.now.utc.iso8601(6)))
+    end
+
     # Shared by initial input and steering; only the execution thread writes history.
     private def append_user_input(user_input, files: nil, reference_contexts: nil,
                                   display_text: nil, created_at: nil, references_display: nil,
                                   task_id: @current_task_id)
+      # Resolve lightweight metadata first, then commit the accepted user turn
+      # before any attachment parser/OCR/sidecar work can block or fail. Session
+      # switching and graceful shutdown both read from @history, so the turn
+      # must already be authoritative while those slow operations are running.
+      skill_command = parse_skill_command(user_input)
+      skill_command_display = if skill_command[:found] && skill_command[:skill]
+                                skill_command[:skill].display_name(Thread.current[:lang])
+                              end
+      created_at ||= Time.now.to_f
+      message_id = SecureRandom.uuid
+      staged = Array(files).any?
+      staged_display_files = display_files_for(files)
+      message_metadata = {
+        role: "user", message_id: message_id, task_id: task_id, created_at: created_at,
+        display_text: display_text,
+        skill_command: skill_command[:found] ? skill_command[:skill_name] : nil,
+        skill_command_display: skill_command_display,
+        display_references: Array(references_display).empty? ? nil : references_display
+      }
+      if staged
+        @history.append(message_metadata.merge(
+          content: user_input,
+          display_files: staged_display_files.empty? ? nil : staged_display_files
+        ))
+        staged_message_id = message_id
+      end
+
       # Split files into vision images and disk files; downgrade oversized images to disk
       image_files, disk_files = partition_files(Array(files))
       vision_images, downgraded = resolve_vision_images(image_files)
@@ -963,37 +1039,21 @@ module Clacky
       # stored here — they recover from image_url blocks in user_content. Downgraded
       # images (provider has no vision / too large / OCR'd) DO need path here so the
       # UI can re-render them from the on-disk copy across session switches.
-      display_files = all_disk_files.filter_map do |f|
-        # @mention file/directory references are replayed from display_references
-        # (with mention badges), so skip them here to avoid double-rendering as
-        # plain attachment badges.
-        next if f[:reference] || f["reference"]
-        name = f[:name] || f["name"]
-        next unless name
-        { name: name, type: f[:type] || f["type"] || "file",
-          path: f[:path] || f["path"],
-          preview_path: f[:preview_path] || f["preview_path"] }
+      display_files = display_files_for(all_disk_files)
+      resolved_message = message_metadata.merge(
+        content: user_content,
+        display_files: display_files.empty? ? nil : display_files
+      )
+      if staged
+        replaced = @history.replace_user_message(
+          message_id: message_id,
+          message: resolved_message
+        )
+        raise AgentError, "Accepted user message disappeared during attachment processing" unless replaced
+      else
+        @history.append(resolved_message)
       end
 
-      # Resolved once here (not after append) so the user message can carry the
-      # confirmed skill name: only a skill that actually dispatches gets marked,
-      # so the UI never highlights a typo'd or unavailable command. The display
-      # name is resolved against the client's language (Thread.current[:lang],
-      # seeded from the WS message / X-Lang header) so the Web UI and third-party
-      # clients can render a localized label without re-resolving the skill.
-      skill_command = parse_skill_command(user_input)
-      skill_command_display = if skill_command[:found] && skill_command[:skill]
-                                skill_command[:skill].display_name(Thread.current[:lang])
-                              end
-
-      created_at ||= Time.now.to_f
-      @history.append({ role: "user", content: user_content, task_id: task_id, created_at: created_at,
-                        display_text: display_text,
-                        skill_command: skill_command[:found] ? skill_command[:skill_name] : nil,
-                        skill_command_display: skill_command_display,
-                        display_files: display_files.empty? ? nil : display_files,
-                        display_references: Array(references_display).empty? ? nil : references_display })
-
       # Inject disk file references as a system_injected message so:
       #   - LLM sees the file info (system_injected is NOT stripped from to_api)
       #   - replay_history skips it (next if ev[:system_injected]), keeping the user bubble clean
@@ -1108,6 +1168,36 @@ module Clacky
       # skill-declared model not found) still stops the progress spinner.
       inject_skill_command_as_assistant_message(skill_command, task_id)
 
+    rescue Clacky::AgentInterrupted, StandardError
+      # The staged turn exists only to make an accepted upload replayable while
+      # attachment work is in progress. If that work crashes, remove this turn
+      # and anything injected after it so the next request cannot inherit a
+      # half-resolved attachment context. Parser failures returned as FileRef
+      # metadata do not raise and therefore remain visible/actionable.
+      @history.truncate_from_message(staged_message_id) if staged_message_id
+      raise
+    end
+
+    # Build replay-only attachment metadata without parsing file contents.
+    # @mention references render through display_references and must not also
+    # appear as plain attachment badges.
+    private def display_files_for(files)
+      Array(files).filter_map do |file|
+        next if file[:reference] || file["reference"]
+
+        name = file[:name] || file["name"]
+        next unless name
+
+        mime_type = file[:mime_type] || file["mime_type"]
+        type = file[:type] || file["type"]
+        type ||= "image" if mime_type.to_s.start_with?("image/")
+        {
+          name: name,
+          type: type || "file",
+          path: file[:path] || file["path"],
+          preview_path: file[:preview_path] || file["preview_path"]
+        }
+      end
     end
 
     def enqueue_input(content, delivery: :queue, **options)
@@ -1240,6 +1330,7 @@ module Clacky
       end
       entries.each do |entry|
         options = entry[:options].dup
+        options.delete(:feedback)
         source = options.delete(:source) || :web
         history_size = @history.size
         begin
@@ -1655,9 +1746,20 @@ module Clacky
             # can extract the questions and emit a "request_feedback" event
             # (renders as a clickable card in the browser).
             # Fallback UIs (terminal, IM channels) receive the formatted text message.
-            @ui&.show_tool_call(call[:name], call[:arguments])
-
-            if @config.permission_mode == :auto_approve
+            if @feedback && @ui.respond_to?(:wait_for_feedback)
+              questions = Tools::AskUser.normalize_questions(args)
+              question = questions.first
+              label = if questions.one? && !question[:multi] && question[:recommended]
+                question[:options][question[:recommended]]
+              end
+              answer, feedback_options = @ui.wait_for_feedback(timeout_seconds: @feedback[:timeout_seconds], question: question[:question], recommended_label: label) do
+                @ui.show_tool_call(call[:name], call[:arguments])
+              end
+              check_stale!
+              result[:awaiting_feedback] = awaiting_feedback = !answer
+              enqueue_input("Answer: #{answer}", delivery: :steer, created_at: Time.now.to_f, **(feedback_options || {})) if answer
+            elsif @config.permission_mode == :auto_approve
+              @ui&.show_tool_call(call[:name], call[:arguments])
               # auto_approve means the agent runs unattended by default, but a
               # human MAY be watching the terminal. Show a short interactive
               # countdown: if the user steps in, hand control over and wait for
@@ -1680,6 +1782,7 @@ module Clacky
               end
             else
               # confirm_all / confirm_safes — a human is present, truly wait for user input.
+              @ui&.show_tool_call(call[:name], call[:arguments])
               awaiting_feedback = true
             end
           else

data/lib/clacky/billing/platform_billing.rb

@@ -24,6 +24,7 @@ module Clacky
         "dsk-deepseek-v4-flash-vision-exp" => "deepseek-v4-flash-vision-exp",
         # gpt via bedrock (abs-, OpenAI-compatible endpoint)
         "abs-gpt-6-astra"  => "global.openai.gpt-6-astra",
+        "abs-gpt-6.1-sol"  => "global.openai.gpt-6.1-sol",
         "abs-gpt-6-sol"    => "global.openai.gpt-6-sol",
         "abs-gpt-6-luna"   => "global.openai.gpt-6-luna",
         "abs-gpt-5.6-sol"   => "global.openai.gpt-5.6-sol",
@@ -37,11 +38,20 @@ module Clacky
         "abs-claude-opus-4-8"   => "global.anthropic.claude-opus-4-8",
         "abs-claude-opus-4-7"   => "global.anthropic.claude-opus-4-7",
         "abs-claude-opus-4-6"   => "global.anthropic.claude-opus-4-6",
+        "abs-claude-sonnet-5-5" => "global.anthropic.claude-sonnet-5-5",
         "abs-claude-sonnet-5"   => "global.anthropic.claude-sonnet-5",
         "abs-claude-sonnet-4-6" => "global.anthropic.claude-sonnet-4-6",
         "abs-claude-sonnet-4-5" => "global.anthropic.claude-sonnet-4-5",
+        "abs-claude-haiku-5-5"  => "global.anthropic.claude-haiku-5-5",
         "abs-claude-haiku-4-5"  => "global.anthropic.claude-haiku-4-5",
+        # GLM / Kimi / Grok via TokHub (oc-). The gateway books these under the
+        # alias itself, so the mapping is an identity — it exists so the billing UI
+        # can resolve the alias instead of dropping the record as unknown.
+        "oc-glm-5.3"            => "oc-glm-5.3",
+        "oc-kimi-k3"            => "oc-kimi-k3",
+        "oc-grok-4.7"           => "oc-grok-4.7",
         # gemini chat (or-)
+        "or-gemini-4-argon"   => "gemini-4-argon",
         "or-gemini-3-1-pro"   => "gemini-3.1-pro-preview",
         "or-gemini-3-8-flash" => "gemini-3.8-flash",
         "or-gemini-3-7-flash" => "gemini-3.7-flash",

data/lib/clacky/cli.rb

@@ -481,8 +481,8 @@ module Clacky
       private def auto_name_session(agent, input)
         return unless agent.history.empty?
 
-        auto_name = input.to_s.gsub(/\s+/, " ").strip[0, 30]
-        auto_name += "…" if input.to_s.strip.length > 30
+        auto_name = input.to_s.gsub(/\s+/, " ").strip[0, 80]
+        auto_name += "…" if input.to_s.strip.length > 80
         agent.rename(auto_name)
       end
 

data/lib/clacky/client.rb

@@ -56,6 +56,13 @@ module Clacky
       @read_timeout = read_timeout
     end
 
+    # Console URL where the user can inspect credit / API key state. nil when
+    # the provider has no preset (custom base_url).
+    def account_url
+      preset = Providers.get(@provider_id)
+      preset && preset["website_url"]
+    end
+
     # Returns true when the client is using the AWS Bedrock Converse API.
     def bedrock?
       @use_bedrock

data/lib/clacky/default_extensions/advisor/hooks/advisor.rb

@@ -127,7 +127,7 @@ module Clacky
       # rounds with no tool calls at all (e.g. the very first "hi"). The
       # pending event is emitted synchronously so the UI can show a "working"
       # state immediately instead of the card popping in out of nowhere.
-      def finish_run
+      def finish_run(analyze: true)
         snapshot = @mutex.synchronize do
           snap = {
             tools: @tools_this_run,
@@ -139,6 +139,7 @@ module Clacky
           @tools_this_run = 0
           snap
         end
+        return unless analyze
         Clacky::Logger.info("[Advisor] finish_run",
                             session: @agent.session_id.to_s,
                             tools: snapshot[:tools],

data/lib/clacky/default_extensions/advisor/hooks/advisor_complete.rb

@@ -4,8 +4,9 @@ require_relative "advisor"
 
 # on_complete: a run has ended — reset the per-run analysis budget so the
 # next run starts fresh.
-Clacky::ExtensionHookRegistry.add do |_result, agent|
+Clacky::ExtensionHookRegistry.add do |result, agent, context|
   next unless Clacky::Advisor.enabled_for?(agent)
 
-  Clacky::Advisor.worker_for(agent).finish_run
+  successful = result.is_a?(Hash) && result[:status] == :success && !context&.dig(:handled)
+  Clacky::Advisor.worker_for(agent).finish_run(analyze: successful)
 end

data/lib/clacky/default_extensions/ext-studio/panels/studio/view.js

@@ -112,6 +112,12 @@
       "pub.screenshot.err": "Upload failed: {{msg}}",
       "pub.screenshot.err.type": "Only PNG / JPG / GIF are allowed",
       "pub.screenshot.err.size": "File size must be under 5 MB",
+      "pub.screenshot.err.unbound": "this device isn't linked to a platform account",
+      "pub.screenshot.err.missingFile": "no file received",
+      "pub.screenshot.err.extId": "missing extension ID",
+      "pub.screenshot.err.service": "the upload service is unavailable, please try again later",
+      "pub.screenshot.err.generic": "Upload failed, please try again",
+      "pub.screenshot.bind": "Authorize",
       "pub.readme.edit.title": "Edit README",
       "readme.pane.editor": "Markdown editor",
       "readme.pane.preview": "Preview",
@@ -318,6 +324,12 @@
       "pub.screenshot.err": "上传失败：{{msg}}",
       "pub.screenshot.err.type": "仅支持 PNG / JPG / GIF 格式",
       "pub.screenshot.err.size": "文件大小不能超过 5 MB",
+      "pub.screenshot.err.unbound": "设备未绑定平台账号",
+      "pub.screenshot.err.missingFile": "未收到文件",
+      "pub.screenshot.err.extId": "缺少扩展 ID",
+      "pub.screenshot.err.service": "上传服务暂不可用，请稍后重试",
+      "pub.screenshot.err.generic": "上传失败，请重试",
+      "pub.screenshot.bind": "去授权",
       "pub.readme.edit.title": "编辑使用说明",
       "readme.pane.editor": "Markdown 编写",
       "readme.pane.preview": "预览",
@@ -651,15 +663,17 @@
 
       const status = el("p", { class: "studio-modal-status", text: t("bind.body") });
       const codeLine = el("p", { class: "studio-modal-code" });
-      const link = el("a", { class: "studio-modal-link", target: "_blank", rel: "noopener", text: t("bind.openLink") });
+      const link = el("a", { class: "btn-primary", target: "_blank", rel: "noopener", text: t("bind.openLink") });
       link.style.display = "none";
 
       const modal = openModal({
         title: t("bind.title"),
-        body: el("div", null, [status, codeLine, link]),
+        body: el("div", null, [status, codeLine]),
         onClose: () => { polling = false; resolve(false); },
         buttons: [{ label: t("bind.cancel"), keepOpen: false, onClick: () => { polling = false; resolve(false); } }],
       });
+      // A real link (not a button) so it still opens when the browser blocks our popup.
+      modal.footer.appendChild(link);
 
       function finish(ok) { polling = false; modal.close(); resolve(ok); }
 
@@ -1342,21 +1356,38 @@
 
     const screenshotErr = el("p", { class: "studio-modal-status studio-modal-status-error", style: "display:none;margin-top:6px" });
     screenshotsSection.appendChild(screenshotErr);
-    fileInput.addEventListener("change", async () => {
-      const file = fileInput.files[0];
-      if (!file) return;
-      fileInput.value = "";
-      screenshotErr.style.display = "none";
-      if (!["image/png", "image/jpeg", "image/gif"].includes(file.type)) {
-        screenshotErr.textContent = t("pub.screenshot.err", { msg: t("pub.screenshot.err.type") });
-        screenshotErr.style.display = "";
-        return;
-      }
-      if (file.size > 5 * 1024 * 1024) {
-        screenshotErr.textContent = t("pub.screenshot.err", { msg: t("pub.screenshot.err.size") });
-        screenshotErr.style.display = "";
-        return;
+
+    // Shows a localized error; passing retryFile appends an "Authorize" link that
+    // reopens device binding and re-uploads that file once bound.
+    function showScreenshotError(text, retryFile) {
+      screenshotErr.textContent = text;
+      if (retryFile) {
+        screenshotErr.appendChild(document.createTextNode(" "));
+        screenshotErr.appendChild(el("button", {
+          type: "button",
+          class: "studio-link-btn",
+          text: t("pub.screenshot.bind"),
+          onclick: () => bindThenUploadScreenshot(retryFile),
+        }));
       }
+      screenshotErr.style.display = "";
+    }
+
+    function screenshotErrorText(e) {
+      if (e.status === 422 && e.message === "missing file") return t("pub.screenshot.err", { msg: t("pub.screenshot.err.missingFile") });
+      if (e.status === 422 && e.message === "ext_id required") return t("pub.screenshot.err", { msg: t("pub.screenshot.err.extId") });
+      if (e.status === 502) return t("pub.screenshot.err", { msg: t("pub.screenshot.err.service") });
+      return t("pub.screenshot.err.generic");
+    }
+
+    async function bindThenUploadScreenshot(file) {
+      screenshotErr.style.display = "none";
+      if (await runBindingFlow()) return uploadScreenshot(file);
+      showScreenshotError(t("pub.screenshot.err", { msg: t("pub.screenshot.err.unbound") }), file);
+    }
+
+    async function uploadScreenshot(file) {
+      let needsBinding = false;
       uploadBtn.disabled = true;
       uploadBtn.textContent = t("pub.screenshot.uploading");
       screenshotErr.style.display = "none";
@@ -1366,7 +1397,12 @@
         form.append("file", file);
         const res = await fetch("/api/ext/ext-studio/screenshot", { method: "POST", body: form });
         const json = await res.json();
-        if (!res.ok || !json.ok) throw new Error(json.error || "upload failed");
+        if (!res.ok || !json.ok) {
+          const err = new Error(json.error || `Request failed (${res.status})`);
+          err.status = res.status;
+          err.data = json;
+          throw err;
+        }
         // Insert ![](url) at cursor position in the editor.
         // Ensure the image tag is on its own line by adding newlines if needed.
         const mdImg = `![](${json.url})`;
@@ -1382,12 +1418,33 @@
         readmeArea.focus();
         readmeArea.dispatchEvent(new Event("input"));
       } catch (e) {
-        screenshotErr.textContent = t("pub.screenshot.err", { msg: e.message });
-        screenshotErr.style.display = "";
+        if (e.status === 428 && e.data && e.data.needs_binding) {
+          needsBinding = true;
+        } else {
+          console.error("[ext-studio] screenshot upload failed:", e);
+          showScreenshotError(screenshotErrorText(e));
+        }
       } finally {
         uploadBtn.disabled = false;
         uploadBtn.textContent = t("pub.screenshot.upload");
       }
+      if (needsBinding) await bindThenUploadScreenshot(file);
+    }
+
+    fileInput.addEventListener("change", () => {
+      const file = fileInput.files[0];
+      if (!file) return;
+      fileInput.value = "";
+      screenshotErr.style.display = "none";
+      if (!["image/png", "image/jpeg", "image/gif"].includes(file.type)) {
+        showScreenshotError(t("pub.screenshot.err", { msg: t("pub.screenshot.err.type") }));
+        return;
+      }
+      if (file.size > 5 * 1024 * 1024) {
+        showScreenshotError(t("pub.screenshot.err", { msg: t("pub.screenshot.err.size") }));
+        return;
+      }
+      uploadScreenshot(file);
     });
 
     box.appendChild(screenshotsSection);
@@ -2312,7 +2369,7 @@
     .studio-input:focus { border-color: var(--color-accent-primary); outline: none; }
     .studio-input-error { border-color: var(--color-error) !important; }
     .studio-modal-code { margin: 0 0 8px; font-size: 13px; font-family: monospace; color: var(--color-text-primary); }
-    .studio-modal-link { display: inline-block; font-size: 13px; color: var(--color-accent-primary); }
+    .studio-modal .modal-footer a.btn-primary { display: inline-flex; align-items: center; font-size: 14px; text-decoration: none; }
     .studio-pub-success { margin-right: auto; font-size: 13px; font-weight: 500; color: var(--color-success); }
     .studio-section { margin-bottom: 20px; }
     .studio-detail-head { display: flex; align-items: center; justify-content: space-between; gap: 8px; margin-bottom: 6px; }

data/lib/clacky/default_extensions/time_machine/panels/time_machine/view.js

@@ -392,6 +392,7 @@
       });
       if (res.ok) {
         state.footEl.textContent = res.message || t("tm.restored", "已恢复");
+        if (Clacky.Workspace) Clacky.Workspace.notifyTaskCompleted(state.sessionId);
         state.expanded = null;
         closeDetail(state);
         await loadHistory(state);