openclacky 1.3.2 → 1.3.4

data/lib/clacky/api_extension_loader.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Clacky
+  # Discovers and loads user-defined HTTP API extensions from
+  # ~/.clacky/api_ext/<name>/handler.rb. Each handler is expected to define a
+  # subclass of Clacky::ApiExtension; the subclass is auto-registered with the
+  # framework and its routes become available under /api/ext/<name>/.
+  #
+  # A broken extension (syntax error, missing base class, route conflict) is
+  # isolated: skipped with a logged warning, never aborts the load of others.
+  module ApiExtensionLoader
+    DEFAULT_DIR  = File.expand_path("~/.clacky/api_ext")
+    DISABLED_DIR = "_disabled"
+
+    Result = Struct.new(:loaded, :skipped, keyword_init: true)
+
+    class << self
+      def load_all(dir: DEFAULT_DIR)
+        result = Result.new(loaded: [], skipped: [])
+        Clacky::ApiExtension.reset_registry!
+
+        if Dir.exist?(dir)
+          Dir.glob(File.join(dir, "*", "handler.rb")).sort.each do |handler_path|
+            ext_dir = File.dirname(handler_path)
+            ext_id  = File.basename(ext_dir)
+            next if ext_id == DISABLED_DIR || ext_id.start_with?("_")
+            load_one(ext_id, ext_dir, handler_path, result)
+          end
+        end
+
+        @last_result = result
+        log_summary(result)
+        result
+      end
+
+      def last_result
+        @last_result || load_all
+      end
+
+      def load_one(ext_id, ext_dir, handler_path, result)
+        meta = read_meta(ext_dir)
+        before = Clacky::ApiExtension.pending_subclasses.size
+
+        require handler_path
+
+        new_subclasses = Clacky::ApiExtension.pending_subclasses[before..] || []
+        klass = new_subclasses.last
+
+        unless klass
+          result.skipped << [ext_id, "no Clacky::ApiExtension subclass defined in handler.rb"]
+          log_skip(ext_id, result.skipped.last[1])
+          return
+        end
+
+        klass.ext_id  = ext_id
+        klass.ext_dir = ext_dir
+        klass.meta    = meta
+
+        if klass.routes.empty?
+          result.skipped << [ext_id, "no routes declared (use get/post/... DSL)"]
+          log_skip(ext_id, result.skipped.last[1])
+          Clacky::ApiExtension.registry.delete(ext_id)
+          return
+        end
+
+        if (gap = validate_public_endpoints(klass, meta))
+          result.skipped << [ext_id, gap]
+          log_skip(ext_id, gap)
+          return
+        end
+
+        Clacky::ApiExtension.register(ext_id, klass)
+        result.loaded << ext_id
+        public_count = klass.public_paths.size
+        suffix = public_count > 0 ? " (#{public_count} public)" : ""
+        Clacky::Logger.info("[ApiExtensionLoader] Loaded '#{ext_id}' — #{klass.routes.size} route(s)#{suffix}")
+      rescue StandardError, ScriptError => e
+        result.skipped << [ext_id, e.message]
+        log_skip(ext_id, e.message)
+      end
+
+      private def read_meta(ext_dir)
+        path = File.join(ext_dir, "meta.yml")
+        return {} unless File.exist?(path)
+
+        YAMLCompat.load_file(path) || {}
+      rescue StandardError => e
+        Clacky::Logger.warn("[ApiExtensionLoader] Failed to read meta.yml in #{ext_dir}: #{e.message}")
+        {}
+      end
+
+      private def validate_public_endpoints(klass, meta)
+        return nil if klass.public_paths.empty?
+        return nil if meta["public"] == true
+
+        "uses public_endpoint but meta.yml is missing 'public: true'"
+      end
+
+      private def log_skip(ext_id, reason)
+        Clacky::Logger.warn("[ApiExtensionLoader] Skipped '#{ext_id}': #{reason}")
+      end
+
+      private def log_summary(result)
+        return if result.loaded.empty? && result.skipped.empty?
+
+        total_routes = result.loaded.sum { |id| Clacky::ApiExtension.registry[id]&.routes&.size || 0 }
+        Clacky::Logger.info("[ApiExtensionLoader] #{result.loaded.size} extension(s), #{total_routes} route(s); #{result.skipped.size} skipped")
+      end
+
+      # Generate a starter handler.rb at ~/.clacky/api_ext/<name>/handler.rb.
+      # Returns the path to the generated file.
+      def scaffold(name, dir: DEFAULT_DIR)
+        slug = name.to_s.strip.downcase.gsub(/[^a-z0-9_-]+/, "-").gsub(/\A-+|-+\z/, "")
+        raise ArgumentError, "invalid api_ext name: #{name.inspect}" if slug.empty?
+
+        target_dir = File.join(dir, slug)
+        path = File.join(target_dir, "handler.rb")
+        raise ArgumentError, "api_ext already exists: #{path}" if File.exist?(path)
+
+        FileUtils.mkdir_p(target_dir)
+        File.write(path, skeleton(slug))
+        path
+      end
+
+      private def skeleton(slug)
+        const = slug.split(/[-_]/).map(&:capitalize).join + "Ext"
+        <<~RUBY
+          # frozen_string_literal: true
+
+          # Custom HTTP API extension mounted at /api/ext/#{slug}/
+          # Scaffolded by `clacky api_ext_new #{slug}` — fill in the routes you need.
+          class #{const} < Clacky::ApiExtension
+            get "/hello" do
+              json(message: "hello from #{slug}")
+            end
+
+            # Examples — uncomment and adapt:
+            #
+            # post "/items" do
+            #   body = json_body
+            #   error!("name required", status: 422) unless body["name"]
+            #   File.write(data_path("items.json"), body.to_json)
+            #   json(ok: true)
+            # end
+            #
+            # get "/items/:id" do
+            #   json(id: params[:id])
+            # end
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/clacky/cli.rb

@@ -268,8 +268,9 @@ module Clacky
           config.save
         end
 
-        # Refresh UI bar
+        # Refresh UI bar and model list
         ui_controller.config[:model] = config.model_name
+        ui_controller.available_models = config.model_names
         ui_controller.update_sessionbar(
           tasks: agent.total_tasks,
           cost: agent.total_cost
@@ -836,11 +837,12 @@ module Clacky
             say "Error: Rich UI requires Ruby >= 2.6. Use --ui ui2 on Ruby #{RUBY_VERSION}.", :red
             exit 1
           end
-          require_relative "rich_ui_controller"
+          require_relative "rich_ui"
           RichUIController.new(
             working_dir: working_dir,
             mode: agent_config.permission_mode.to_s,
             model: agent_config.model_name,
+            model_names: agent_config.model_names,
             theme: options[:theme]
           )
         else
@@ -901,6 +903,21 @@ module Clacky
           agent_config.permission_mode = new_mode.to_sym
         end
 
+        # Set up model switch handler (from /model slash command)
+        ui_controller.on_model_switch do |model, persist|
+          next unless agent_config.switch_model_by_name(model)
+
+          id = agent_config.current_model_id
+          agent.switch_model_by_id(id)
+          if persist
+            agent_config.set_default_model_by_id(id)
+            agent_config.save
+            ui_controller.show_success("Model switched to #{model} (saved)")
+          else
+            ui_controller.show_success("Model switched to #{model} (session only)")
+          end
+        end
+
         # Set up time machine handler (ESC key)
         ui_controller.on_time_machine do
           handle_time_machine_command(ui_controller, agent, session_manager)
@@ -921,6 +938,16 @@ module Clacky
           end
 
           if (not current_task_thread&.alive?) && input_was_empty
+            # Rich UI: require double-tap Ctrl+C to exit.  When the user
+            # just copied terminal-native text selection, the viewport
+            # has no knowledge of the selection, yet Ctrl+C must not exit.
+            # First press only sets the warning; second press exits.
+            if ui_controller.respond_to?(:ctrl_c_warning) && !ui_controller.ctrl_c_warning
+              ui_controller.instance_variable_set(:@ctrl_c_warning, "Press Ctrl+C again to exit")
+              ui_controller.set_input_tips("Press Ctrl+C again to exit.", type: :info)
+              next
+            end
+
             # Save final session state before exit
             if session_manager && agent.total_tasks > 0
               session_data = agent.to_session_data(status: :exited)
@@ -1038,7 +1065,13 @@ module Clacky
               # Update session bar with agent's cumulative stats
               ui_controller.update_sessionbar(tasks: agent.total_tasks, cost: agent.total_cost)
             rescue Clacky::AgentInterrupted, StandardError => e
-              handle_agent_exception(ui_controller, agent, session_manager, e)
+              begin
+                handle_agent_exception(ui_controller, agent, session_manager, e)
+              rescue StandardError => ex
+                # If handle_agent_exception itself raises (e.g. UI in bad state),
+                # prevent the thread from dying with an unhandled exception.
+                $stderr.puts "[cli] handle_agent_exception failed: #{ex.class}: #{ex.message}"
+              end
             ensure
               current_task_thread = nil
               # Start idle timer after agent completes
@@ -1181,6 +1214,63 @@ module Clacky
       exit 1 if result.skipped.any?
     end
 
+    desc "api_ext_new NAME", "Scaffold a custom HTTP API extension at ~/.clacky/api_ext/NAME/"
+    long_desc <<-LONGDESC
+      Generate a ready-to-edit HTTP API extension skeleton. The skeleton mounts
+      a sample route under /api/ext/NAME/ — fill in your routes, then verify with
+      `clacky api_ext_verify`.
+
+      Examples:
+        $ clacky api_ext_new my-dashboard
+    LONGDESC
+    def api_ext_new(name)
+      path = Clacky::ApiExtensionLoader.scaffold(name)
+      puts "Created api extension: #{path}"
+      puts "Edit the routes, then run: clacky api_ext_verify"
+    rescue ArgumentError => e
+      warn "Error: #{e.message}"
+      exit 1
+    end
+
+    desc "api_ext_verify", "Load user API extensions and report which are valid"
+    def api_ext_verify
+      result = Clacky::ApiExtensionLoader.load_all
+
+      if result.loaded.empty? && result.skipped.empty?
+        puts "No api extensions found in ~/.clacky/api_ext/"
+        return
+      end
+
+      result.loaded.each do |id|
+        klass = Clacky::ApiExtension.registry[id]
+        public_count = klass.public_paths.size
+        suffix = public_count > 0 ? " (#{public_count} public)" : ""
+        puts "[OK]   #{id} — #{klass.routes.size} route(s)#{suffix}"
+      end
+      result.skipped.each { |(n, reason)| puts "[SKIP] #{n} — #{reason}" }
+      exit 1 if result.skipped.any?
+    end
+
+    desc "api_ext_list", "List loaded API extensions and their routes"
+    def api_ext_list
+      Clacky::ApiExtensionLoader.load_all if Clacky::ApiExtension.registry.empty?
+
+      if Clacky::ApiExtension.registry.empty?
+        puts "No api extensions loaded."
+        return
+      end
+
+      Clacky::ApiExtension.registry.each do |id, klass|
+        public_tag = klass.public_paths.any? ? " (public)" : ""
+        puts "#{id}#{public_tag}"
+        klass.routes.each do |route|
+          full_path = "/api/ext/#{id}#{route.pattern}".chomp("/")
+          full_path = "/api/ext/#{id}/" if full_path == "/api/ext/#{id}"
+          puts "  #{route.method.to_s.upcase.ljust(6)} #{full_path}"
+        end
+      end
+    end
+
     desc "billing", "Show billing summary and usage statistics"
     long_desc <<-LONGDESC
       Display billing summary with token usage and cost breakdown.

data/lib/clacky/client.rb

@@ -515,6 +515,12 @@ module Clacky
       end
     end
 
+    def reset_connections!
+      @bedrock_connection = nil
+      @openai_connection = nil
+      @anthropic_connection = nil
+    end
+
     def bedrock_connection
       current_epoch = Clacky::ProxyConfig.epoch
       if @bedrock_connection.nil? ||
@@ -598,11 +604,24 @@ module Clacky
       return { success: true, status: response.status } if response.status == 200
 
       error_body = JSON.parse(response.body) rescue nil
+      error_code = extract_error_code(error_body)
+
+      translated = case response.status
+      when 402       then I18n.t("llm.error.insufficient_credit")
+      when 400       then I18n.t("llm.error.rate_limit_400")
+      when 401       then I18n.t("llm.error.invalid_api_key")
+      when 403       then I18n.t("llm.error.403.#{error_code || "default"}")
+      when 404       then I18n.t("llm.error.endpoint_not_found")
+      when 429       then I18n.t("llm.error.rate_limit_429")
+      when 500..599  then I18n.t("llm.error.server_error", status: response.status)
+      else                extract_error_message(error_body, response.body)
+      end
+
       {
         success:    false,
         status:     response.status,
-        error:      extract_error_message(error_body, response.body),
-        error_code: extract_error_code(error_body)
+        error:      translated,
+        error_code: error_code
       }
     end
 
@@ -620,7 +639,7 @@ module Clacky
 
       if error_code == "insufficient_credit" || response.status == 402
         raise InsufficientCreditError.new(
-          "[LLM] Insufficient credit: #{error_message}",
+          "[LLM] #{I18n.t("llm.error.insufficient_credit")}",
           error_code: "insufficient_credit",
           provider_id: @provider_id
         )
@@ -632,19 +651,25 @@ module Clacky
         # However, some proxy/relay providers do — so we inspect the message first.
         # Also, Bedrock returns ThrottlingException as 400 instead of 429.
         if error_message.match?(/ThrottlingException|unavailable|quota/i)
-          hint = error_message.match?(/quota/i) ? " (possibly out of credits)" : ""
-          raise RetryableError, "[LLM] Rate limit or service issue: #{error_message}#{hint}"
+          raise RetryableError, "[LLM] #{I18n.t("llm.error.rate_limit_400")}"
         end
 
         # True bad request — our message was malformed. Roll back history so the
         # broken message is not replayed on the next user turn.
-        raise BadRequestError, "[LLM] Client request error: #{error_message}"
-      when 401 then raise AgentError, "[LLM] Invalid API key"
-      when 403 then raise AgentError, "[LLM] Access denied: #{error_message}"
-      when 404 then raise AgentError, "[LLM] API endpoint not found: #{error_message}"
-      when 429 then raise RetryableError, "[LLM] Rate limit exceeded, please wait a moment"
-      when 500..599 then raise RetryableError, "[LLM] Service temporarily unavailable (#{response.status}), retrying..."
-      else raise AgentError, "[LLM] Unexpected error (#{response.status}): #{error_message}"
+        raise BadRequestError.new(
+          "[LLM] Client request error: #{error_message}",
+          display_message: "[LLM] #{I18n.t("llm.error.bad_request")}"
+        )
+      when 401 then raise AgentError, "[LLM] #{I18n.t("llm.error.invalid_api_key")}"
+      when 403
+        i18n_key = "llm.error.403.#{error_code}"
+        translated = I18n.t(i18n_key)
+        translated = I18n.t("llm.error.403.default") if translated == i18n_key
+        raise AgentError, "[LLM] #{translated}"
+      when 404 then raise AgentError, "[LLM] #{I18n.t("llm.error.endpoint_not_found")}"
+      when 429 then raise RetryableError, "[LLM] #{I18n.t("llm.error.rate_limit_429")}"
+      when 500..599 then raise RetryableError, "[LLM] #{I18n.t("llm.error.server_error", status: response.status)}"
+      else raise AgentError, "[LLM] #{I18n.t("llm.error.unexpected", status: response.status)}"
       end
     end
 
@@ -652,7 +677,7 @@ module Clacky
     def check_html_response(response)
       body = response.body.to_s.lstrip
       if body.start_with?("<!DOCTYPE", "<!doctype", "<html", "<HTML")
-        raise RetryableError, "[LLM] Service temporarily unavailable (received HTML error page), retrying..."
+        raise RetryableError, "[LLM] #{I18n.t("llm.error.html_response")}"
       end
     end
 

data/lib/clacky/default_agents/_panels/git/panel.js

@@ -0,0 +1,201 @@
+// ── Official panel: changes (git, made friendly) ──────────────────────────
+//
+// "改动 / Changes": a non-technical view of what the AI changed, backed by the
+// built-in git API (GET/POST /api/sessions/:id/git/*). Mounted as a tab in the
+// "session.aside" slot, scoped to agents declaring `panels: [git]`.
+//
+// Deliberately hides git jargon: no porcelain status codes (M/??), no
+// branch/ahead/behind unless the branch is NOT the main line (main/master) —
+// then it's surfaced as a gentle notice. The only write is a zero-input
+// "save version" that auto-generates the commit message.
+//
+// Native DOM + textContent on all git output (paths, branch) so nothing can
+// inject. tab.badge tracks the number of changed files.
+// ───────────────────────────────────────────────────────────────────────────
+
+(() => {
+  if (!window.Clacky || !Clacky.ext) return;
+
+  const MAIN_BRANCHES = { main: true, master: true };
+  const t = (k, fallback) => {
+    const v = (typeof I18n !== "undefined") ? I18n.t(k) : null;
+    return (v && v !== k) ? v : fallback;
+  };
+
+  if (!document.getElementById("changes-panel-style")) {
+    const style = document.createElement("style");
+    style.id = "changes-panel-style";
+    style.textContent = `
+      .changes-panel { display: flex; flex-direction: column; flex: 1; min-height: 0; }
+      .changes-summary { flex: none; padding: 14px 16px 10px; border-bottom: 1px solid var(--color-border-secondary); }
+      .changes-summary .h { font-size: 13px; color: var(--color-text-secondary); }
+      .changes-summary .h b { color: var(--color-text-primary); }
+      .changes-summary .sub { font-size: 12px; color: var(--color-text-tertiary); margin-top: 3px; }
+      .changes-branch { display: flex; align-items: center; gap: 6px; margin-top: 8px; padding: 5px 8px; border-radius: var(--radius-sm); background: var(--color-warning-bg); color: var(--color-warning); font-size: 11.5px; }
+      .changes-branch code { font-family: ui-monospace, monospace; font-weight: 600; }
+      .changes-list { flex: 1; min-height: 0; overflow: auto; padding: 6px 8px; }
+      .change-row { display: flex; align-items: center; gap: 8px; padding: 7px 8px; border-radius: var(--radius-sm); }
+      .change-row:hover { background: var(--color-bg-hover); }
+      .change-tag { flex: none; font-size: 11px; padding: 1px 7px; border-radius: var(--radius-pill); font-weight: 500; }
+      .change-tag.add { background: var(--color-success-bg); color: var(--color-success); }
+      .change-tag.mod { background: #eff6ff; color: #2563eb; }
+      .change-tag.del { background: var(--color-error-bg); color: var(--color-error); }
+      .change-path { font-size: 13px; color: var(--color-text-primary); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+      .change-dir { color: var(--color-text-tertiary); }
+      .changes-foot { flex: none; padding: 12px 16px; border-top: 1px solid var(--color-border-primary); }
+      .changes-save-btn { width: 100%; padding: 9px; border: none; border-radius: var(--radius-md); background: var(--color-accent-primary); color: var(--color-text-inverse); font-size: 13px; font-weight: 500; cursor: pointer; }
+      .changes-save-btn:hover:not(:disabled) { background: var(--color-accent-hover); }
+      .changes-save-btn:disabled { opacity: 0.5; cursor: default; }
+      .changes-hint { text-align: center; font-size: 11px; color: var(--color-text-tertiary); margin-top: 7px; min-height: 1em; }
+      .changes-empty, .changes-loading, .changes-error { color: var(--color-text-tertiary); padding: 16px; font-size: 12px; text-align: center; }
+      .changes-error { color: var(--color-error); }
+    `;
+    document.head.appendChild(style);
+  }
+
+  function el(tag, attrs, ...kids) {
+    const node = document.createElement(tag);
+    if (attrs) {
+      for (const [k, v] of Object.entries(attrs)) {
+        if (k === "class") node.className = v;
+        else if (k === "text") node.textContent = v;
+        else if (k.startsWith("on") && typeof v === "function") node.addEventListener(k.slice(2), v);
+        else node.setAttribute(k, v);
+      }
+    }
+    kids.forEach((c) => node.appendChild(typeof c === "string" ? document.createTextNode(c) : c));
+    return node;
+  }
+
+  async function api(sessionId, action, opts) {
+    const res = await fetch(`/api/sessions/${encodeURIComponent(sessionId)}/git/${action}`, opts);
+    return res.json();
+  }
+
+  // Map a porcelain status entry to a friendly kind without exposing codes.
+  function classify(f) {
+    if (f.untracked) return "add";
+    const code = `${f.x || ""}${f.y || ""}`;
+    if (code.includes("D")) return "del";
+    if (code.includes("A")) return "add";
+    return "mod";
+  }
+
+  const TAG_LABEL = {
+    add: () => t("changes.tag.add", "新增"),
+    mod: () => t("changes.tag.mod", "修改"),
+    del: () => t("changes.tag.del", "删除"),
+  };
+
+  function splitPath(path) {
+    const i = path.lastIndexOf("/");
+    return i < 0 ? { dir: "", name: path } : { dir: path.slice(0, i + 1), name: path.slice(i + 1) };
+  }
+
+  function autoMessage() {
+    const d = new Date();
+    const pad = (n) => String(n).padStart(2, "0");
+    const stamp = `${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+    return `${t("changes.save.prefix", "手动存档")} · ${stamp}`;
+  }
+
+  function renderFiles(files) {
+    const list = el("div", { class: "changes-list" });
+    files.forEach((f) => {
+      const kind = classify(f);
+      const { dir, name } = splitPath(f.path);
+      const path = el("span", { class: "change-path" });
+      if (dir) path.appendChild(el("span", { class: "change-dir", text: dir }));
+      path.appendChild(document.createTextNode(name));
+      list.appendChild(el("div", { class: "change-row" },
+        el("span", { class: `change-tag ${kind}`, text: TAG_LABEL[kind]() }),
+        path,
+      ));
+    });
+    return list;
+  }
+
+  async function refresh(sessionId, root, body, ctx) {
+    body.replaceChildren(el("div", { class: "changes-loading", text: t("changes.loading", "正在读取改动…") }));
+
+    let status;
+    try {
+      status = await api(sessionId, "status");
+    } catch (_e) {
+      body.replaceChildren(el("div", { class: "changes-error", text: t("changes.error", "读取改动失败") }));
+      return;
+    }
+    if (!status.repo) {
+      if (ctx && ctx.setBadge) ctx.setBadge(null);
+      body.replaceChildren(el("div", { class: "changes-empty", text: t("changes.noRepo", "这个项目还没有启用版本管理。") }));
+      return;
+    }
+
+    const files = status.files || [];
+    if (ctx && ctx.setBadge) ctx.setBadge(files.length || null);
+
+    const count = files.length;
+    const summary = el("div", { class: "changes-summary" });
+    const h = el("div", { class: "h" });
+    if (count === 0) {
+      h.textContent = t("changes.cleanTitle", "暂无改动");
+    } else {
+      h.appendChild(document.createTextNode(t("changes.changedPre", "AI 改了 ")));
+      h.appendChild(el("b", { text: `${count} ${t("changes.filesUnit", "个文件")}` }));
+    }
+    summary.appendChild(h);
+    summary.appendChild(el("div", { class: "sub", text: t("changes.sub", "由 Git 管理 · 自上次存档以来") }));
+
+    const branch = (status.branch || "").trim();
+    if (branch && !MAIN_BRANCHES[branch.toLowerCase()]) {
+      const note = el("div", { class: "changes-branch" });
+      note.appendChild(document.createTextNode(t("changes.branchPre", "当前分支：")));
+      note.appendChild(el("code", { text: branch }));
+      summary.appendChild(note);
+    }
+
+    const hint = el("div", { class: "changes-hint" });
+    const saveBtn = el("button", { class: "changes-save-btn", type: "button", text: t("changes.save.btn", "存档当前版本") });
+    saveBtn.disabled = count === 0;
+    saveBtn.addEventListener("click", async () => {
+      saveBtn.disabled = true;
+      hint.textContent = t("changes.save.saving", "正在存档…");
+      try {
+        const paths = files.map((f) => f.path);
+        const res = await api(sessionId, "commit", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ message: autoMessage(), files: paths }),
+        });
+        if (res.ok) {
+          hint.textContent = t("changes.save.done", "已存档，可在「时光机」里回到这个版本");
+          refresh(sessionId, root, body, ctx);
+        } else {
+          hint.textContent = res.error || t("changes.save.failed", "存档失败");
+          saveBtn.disabled = false;
+        }
+      } catch (_e) {
+        hint.textContent = t("changes.save.failed", "存档失败");
+        saveBtn.disabled = false;
+      }
+    });
+
+    body.replaceChildren(
+      summary,
+      count === 0 ? el("div", { class: "changes-empty", text: t("changes.clean", "工作区是干净的，没有未存档的改动。") }) : renderFiles(files),
+      el("div", { class: "changes-foot" }, saveBtn, hint),
+    );
+  }
+
+  Clacky.ext.ui.mount("session.aside", (ctx) => {
+    if (!ctx || !ctx.sessionId) return null;
+    const body = el("div", { class: "changes-panel" });
+    const root = el("div", { class: "changes-root", "data-panel": "changes" }, body);
+    refresh(ctx.sessionId, root, body, ctx);
+    return root;
+  }, {
+    panel: "git",
+    order: 10,
+    tab: { id: "changes", label: () => t("changes.tab") },
+  });
+})();