openclacky 1.3.2 → 1.3.3

data/lib/clacky/agent/time_machine.rb

@@ -41,22 +41,39 @@ module Clacky
         @task_parents ||= {}      # { task_id => parent_id }
         @current_task_id ||= 0    # Latest created task ID
         @active_task_id ||= 0     # Current active task ID (for undo/redo)
+        @task_meta ||= {}         # { task_id => { title:, started_at:, ended_at: } }
+        @latest_after_dirty = false if @latest_after_dirty.nil?
       end
 
       # Start a new task and establish parent relationship
+      # @param title [String, nil] Short label for this turn (typically the
+      #   user's first message, truncated). Used by the UI to label snapshots
+      #   even after the original conversation has been compressed out of
+      #   @history. nil → leave unset; the UI falls back to "Task N".
       # Made public for testing
-      def start_new_task
+      def start_new_task(title: nil)
         # Before the currently-active task stops being the latest, freeze its
         # end-of-task disk state into an AFTER snapshot. Without this, a task
         # that later gets superseded by a sibling branch would have no record
         # of its result, making a forward switch back to it impossible.
         checkpoint_latest_task_after
 
+        # Close out the task we're leaving.
+        if @active_task_id.to_i > 0 && @task_meta[@active_task_id]
+          @task_meta[@active_task_id][:ended_at] ||= Time.now.to_f
+        end
+
         parent_id = @active_task_id
         @current_task_id += 1
         @active_task_id = @current_task_id
         @task_parents[@current_task_id] = parent_id
 
+        @task_meta[@current_task_id] = {
+          title: title ? truncate_task_title(title) : nil,
+          started_at: Time.now.to_f,
+          ended_at: nil,
+        }
+
         # Claim ownership of this task for the current thread.
         # If a stale thread (e.g. a slow subagent) wakes up later it will see
         # @task_thread != Thread.current via check_stale! and self-terminate
@@ -68,6 +85,21 @@ module Clacky
         @current_task_id
       end
 
+      # Update the title of the currently-active task. Used by callers that
+      # only learn the user-facing label after start_new_task has run.
+      def set_current_task_title(title)
+        return if @active_task_id.to_i <= 0
+        @task_meta[@active_task_id] ||= { started_at: Time.now.to_f, ended_at: nil }
+        @task_meta[@active_task_id][:title] = truncate_task_title(title)
+      end
+
+      private def truncate_task_title(text)
+        s = text.to_s
+        # Collapse whitespace so multi-line inputs render as a single label.
+        s = s.gsub(/\s+/, " ").strip
+        s.length > 60 ? "#{s[0...57]}..." : s
+      end
+
       # Record a file's BEFORE state for the current task, the first time the
       # task touches it. Call this immediately before a tool mutates the file.
       # Subsequent calls within the same task are no-ops so the earliest state
@@ -157,10 +189,27 @@ module Clacky
         # Freeze the task we're leaving so a later forward switch can return.
         checkpoint_latest_task_after
 
+        plan = build_restore_plan(task_id)
+        plan.each do |rel, decision|
+          target = File.join(@working_dir, rel)
+          if decision[:action] == :delete
+            FileUtils.rm_f(target)
+          else
+            FileUtils.mkdir_p(File.dirname(target))
+            FileUtils.cp(decision[:source], target)
+          end
+        end
+      rescue StandardError
+        raise
+      end
+
+      # Decide, for every file the session has ever touched, whether restoring
+      # to `task_id` should overwrite it with a snapshot or delete it. Pure
+      # function over the snapshot tree — does not touch the working dir.
+      # @return [Hash{String => Hash}] rel_path => { action: :delete | :restore, source: String|nil }
+      private def build_restore_plan(task_id)
         session_root = TimeMachine.session_dir(@session_id)
 
-        # Ancestor chain from the target task up to (and excluding) root 0,
-        # ordered nearest-first so the closest writer of each file wins.
         ancestors = []
         tid = task_id
         until tid.nil? || tid <= 0 || ancestors.include?(tid)
@@ -168,22 +217,20 @@ module Clacky
           tid = @task_parents[tid]
         end
 
-        # Every file ever touched by any task in this session.
         all_rels = Set.new
         Dir.glob(File.join(session_root, "task-*", "before", "**", "*"), File::FNM_DOTMATCH).each do |path|
           next if File.directory?(path)
-
           rel = path.sub(%r{\A.*/before/}, "")
           rel = rel.sub(/\.#{Regexp.escape(ABSENT_MARKER)}\z/, "")
           all_rels << rel
         end
 
+        plan = {}
         all_rels.each do |rel|
           action = :delete
           source = nil
           matched = false
 
-          # Closest ancestor (starting at the target) that produced this file.
           ancestors.each do |aid|
             after_dir = File.join(session_root, "task-#{aid}", "after")
             content_path = File.join(after_dir, rel)
@@ -201,11 +248,6 @@ module Clacky
             end
           end
 
-          # No task on the chain produced this file. Restore the session's
-          # INITIAL content for it — captured as the earliest BEFORE recorded
-          # for this file by any task (BEFORE = state just before that task
-          # ran; the smallest task id therefore holds the pre-session state).
-          # No BEFORE at all => the file never existed initially, so delete.
           unless matched
             initial = earliest_before_snapshot(session_root, rel)
             if initial
@@ -216,16 +258,49 @@ module Clacky
             end
           end
 
+          plan[rel] = { action: action, source: source }
+        end
+
+        plan
+      end
+
+      # Preview the file-level effect of restore_to_task_state(task_id) without
+      # touching disk. Compares the resolved restore plan against the current
+      # working-dir state and returns only files that would actually change.
+      # @return [Array<Hash>] [{ path:, action: "create"|"modify"|"delete" }]
+      def preview_restore_to_task(task_id)
+        return [] unless task_id.is_a?(Integer) && task_id >= 0
+
+        checkpoint_latest_task_after
+        plan = build_restore_plan(task_id)
+        changes = []
+
+        plan.each do |rel, decision|
           target = File.join(@working_dir, rel)
-          if action == :delete
-            FileUtils.rm_f(target)
+          target_exists = File.exist?(target)
+
+          if decision[:action] == :delete
+            changes << { path: rel, action: "delete" } if target_exists
           else
-            FileUtils.mkdir_p(File.dirname(target))
-            FileUtils.cp(source, target)
+            src = decision[:source]
+            next unless src && File.exist?(src)
+
+            if !target_exists
+              changes << { path: rel, action: "create" }
+            elsif !files_equal?(src, target)
+              changes << { path: rel, action: "modify" }
+            end
           end
         end
+
+        changes.sort_by { |c| c[:path] }
+      end
+
+      private def files_equal?(a, b)
+        return false unless File.size(a) == File.size(b)
+        File.binread(a) == File.binread(b)
       rescue StandardError
-        raise
+        false
       end
 
       # The initial (pre-session) content path for a file, taken from the
@@ -331,6 +406,143 @@ module Clacky
         @task_parents.select { |_, parent| parent == task_id }.keys
       end
 
+      # Cheap version of task_diff_files: just count how many distinct files
+      # this task touched, so the timeline can grey out no-op tasks without
+      # paying for a full diff walk per row.
+      def task_change_count(task_id)
+        return 0 unless task_id.is_a?(Integer) && task_id > 0
+
+        session_root = TimeMachine.session_dir(@session_id)
+        before_dir = File.join(session_root, "task-#{task_id}", "before")
+        after_dir  = File.join(session_root, "task-#{task_id}", "after")
+        return 0 unless Dir.exist?(before_dir)
+        return 0 if task_id == @current_task_id && @latest_after_dirty == true && !Dir.exist?(after_dir)
+
+        rels = Set.new
+        [before_dir, after_dir].each do |root|
+          next unless Dir.exist?(root)
+          Dir.glob(File.join(root, "**", "*"), File::FNM_DOTMATCH).each do |path|
+            next if File.directory?(path)
+            rel = path.sub(root + "/", "").sub(/\.#{Regexp.escape(ABSENT_MARKER)}\z/, "")
+            rels << rel
+          end
+        end
+        rels.size
+      end
+
+      # File-level summary of changes a task introduced. Diff is task-N/before
+      # vs task-N/after (after is captured by checkpoint_latest_task_after when
+      # the task stops being the latest, so this method has no useful answer
+      # for the currently-active task — callers get an empty list back).
+      # @return [Array<Hash>] Each entry: { path:, status: "added"|"modified"|"deleted", binary: Bool }
+      def task_diff_files(task_id)
+        return [] unless task_id.is_a?(Integer) && task_id > 0
+
+        session_root = TimeMachine.session_dir(@session_id)
+        before_dir = File.join(session_root, "task-#{task_id}", "before")
+        after_dir  = File.join(session_root, "task-#{task_id}", "after")
+        return [] unless Dir.exist?(before_dir)
+        return [] if task_id == @current_task_id && @latest_after_dirty == true && !Dir.exist?(after_dir)
+
+        rels = Set.new
+        [before_dir, after_dir].each do |root|
+          next unless Dir.exist?(root)
+          Dir.glob(File.join(root, "**", "*"), File::FNM_DOTMATCH).each do |path|
+            next if File.directory?(path)
+            rel = path.sub(root + "/", "").sub(/\.#{Regexp.escape(ABSENT_MARKER)}\z/, "")
+            rels << rel
+          end
+        end
+
+        rels.sort.map do |rel|
+          before_file, before_absent = snapshot_paths(before_dir, rel)
+          after_file,  after_absent  = snapshot_paths(after_dir,  rel)
+
+          status = if before_absent && after_file
+            "added"
+          elsif before_file && after_absent
+            "deleted"
+          elsif before_file && after_file
+            "modified"
+          elsif before_file && !File.exist?(after_dir)
+            # No AFTER captured (e.g. the very latest task) — still surface
+            # what was touched as "modified" so the UI can list the file.
+            "modified"
+          else
+            "modified"
+          end
+
+          binary = looks_binary?(before_file) || looks_binary?(after_file)
+          { path: rel, status: status, binary: binary }
+        end
+      end
+
+      # Unified diff of a single file for a task. Returns nil if either side
+      # is missing or binary. text format = "@@ ... @@" patch (3-context),
+      # ready for the UI to render with a diff renderer.
+      # @return [Hash, nil] { path:, before:, after:, patch:, binary: }
+      def task_file_diff(task_id, rel_path)
+        return nil unless task_id.is_a?(Integer) && task_id > 0
+        return nil if rel_path.to_s.include?("..")
+
+        session_root = TimeMachine.session_dir(@session_id)
+        before_dir = File.join(session_root, "task-#{task_id}", "before")
+        after_dir  = File.join(session_root, "task-#{task_id}", "after")
+
+        before_file, before_absent = snapshot_paths(before_dir, rel_path)
+        after_file,  after_absent  = snapshot_paths(after_dir,  rel_path)
+
+        before_text = before_absent ? "" : (before_file ? read_text_safe(before_file) : nil)
+        after_text  = after_absent  ? "" : (after_file  ? read_text_safe(after_file)  : nil)
+
+        if before_text.nil? && after_text.nil?
+          return nil
+        end
+
+        # Detect binary on either side: bail out, the UI will render a stub.
+        if (before_file && looks_binary?(before_file)) || (after_file && looks_binary?(after_file))
+          return { path: rel_path, before: nil, after: nil, patch: nil, binary: true }
+        end
+
+        require "diffy" unless defined?(Diffy)
+        raw = Diffy::Diff.new(before_text || "", after_text || "",
+                              context: 3, include_diff_info: true).to_s(:text)
+        # Strip Diffy's "--- /tmp/diffy.../before" header pair: it leaks
+        # tempfile paths and adds noise the UI doesn't need.
+        patch = raw.sub(/\A(?:---[^\n]*\n[^\n]*\n)/, "")
+
+        { path: rel_path, before: before_text, after: after_text, patch: patch, binary: false }
+      end
+
+      private def snapshot_paths(dir, rel)
+        content_path = File.join(dir, rel)
+        absent_path  = "#{content_path}.#{ABSENT_MARKER}"
+        if File.exist?(content_path)
+          [content_path, false]
+        elsif File.exist?(absent_path)
+          [nil, true]
+        else
+          [nil, false]
+        end
+      end
+
+      private def looks_binary?(path)
+        return false if path.nil? || !File.exist?(path)
+        sample = File.binread(path, 8000)
+        sample.include?("\x00") || !sample.dup.force_encoding("UTF-8").valid_encoding?
+      rescue StandardError
+        true
+      end
+
+      private def read_text_safe(path)
+        File.read(path, mode: "rb").then do |s|
+          s.encoding == Encoding::UTF_8 && s.valid_encoding? ? s :
+            s.encode("UTF-8", invalid: :replace, undef: :replace, replace: "\u{FFFD}")
+        end
+      rescue StandardError
+        ""
+      end
+
       # Get task history with summaries for UI display
       # @param limit [Integer] Maximum number of recent tasks to return
       # @return [Array<Hash>] Task history with metadata
@@ -341,17 +553,23 @@ module Clacky
 
         tasks = []
         (1..@current_task_id).to_a.reverse.take(limit).reverse.each do |task_id|
-          # Find first user message for this task
-          first_user_msg = @history.to_a.find do |msg|
-            msg[:task_id] == task_id && msg[:role] == "user"
-          end
+          meta = (@task_meta || {})[task_id] || {}
 
-          summary = if first_user_msg
-            content = extract_message_text(first_user_msg[:content])
-            # Truncate to 60 characters (including "...")
-            content.length > 60 ? "#{content[0...57]}..." : content
+          summary = if meta[:title] && !meta[:title].to_s.empty?
+            meta[:title]
           else
-            "Task #{task_id}"
+            # Best-effort fallback: scan @history for the task's first real
+            # user message. Returns nothing for tasks that have already been
+            # compressed out — the UI then shows "Task N".
+            first = @history.to_a.find do |msg|
+              msg[:role] == "user" && msg[:task_id] == task_id && !msg[:system_injected]
+            end
+            if first
+              text = extract_message_text(first[:content]).to_s.gsub(/\s+/, " ").strip
+              text.length > 60 ? "#{text[0...57]}..." : text
+            else
+              "Task #{task_id}"
+            end
           end
 
           # Status relative to the ACTIVE task chain (not a linear id compare),
@@ -372,8 +590,11 @@ module Clacky
           tasks << {
             task_id: task_id,
             summary: summary,
+            started_at: meta[:started_at],
+            ended_at: meta[:ended_at],
             status: status,
-            has_branches: has_branches
+            has_branches: has_branches,
+            change_count: task_change_count(task_id),
           }
         end
 

data/lib/clacky/agent.rb

@@ -262,7 +262,7 @@ module Clacky
       @ui&.show_progress
 
       # Start new task for Time Machine
-      task_id = start_new_task
+      task_id = start_new_task(title: display_text.to_s.empty? ? user_input.to_s : display_text.to_s)
 
       # Continuation of a previously-interrupted task (e.g. user sent a
       # supplementary message without stopping the running task) keeps the
@@ -1371,6 +1371,17 @@ module Clacky
       cloned_messages = deep_clone(@history.to_a)
       subagent.instance_variable_set(:@history, MessageHistory.new(cloned_messages))
 
+      # The cloned history carries per-message task_id tags. Without the parent's
+      # Time Machine task state the subagent's @active_task_id stays 0, so
+      # active_task_chain collapses to {0} and active_messages filters out every
+      # message tagged task_id > 0 — silently shrinking the context and busting
+      # prompt caching. Carry the task state alongside @history so the subagent
+      # sees the same chain (and cache prefix) as the parent.
+      subagent.instance_variable_set(:@task_parents, deep_clone(@task_parents))
+      subagent.instance_variable_set(:@current_task_id, @current_task_id)
+      subagent.instance_variable_set(:@active_task_id, @active_task_id)
+      subagent.instance_variable_set(:@task_meta, deep_clone(@task_meta))
+
       # Append system prompt suffix as user message (for cache reuse)
       if system_prompt_suffix
         subagent_history = subagent.history

data/lib/clacky/agent_config.rb

@@ -165,7 +165,8 @@ module Clacky
                   :memory_update_enabled, :skill_evolution,
                   :max_running_agents, :max_idle_agents,
                   :default_working_dir,
-                  :proxy_url
+                  :proxy_url,
+                  :media_output_dir
 
     def initialize(options = {})
       @permission_mode = validate_permission_mode(options[:permission_mode])
@@ -223,6 +224,15 @@ module Clacky
       # a proxy. Leave nil to go direct.
       @proxy_url = options[:proxy_url]
 
+      # User-configured directory where generated images / videos / audio
+      # land when a /api/media/* call doesn't pass an explicit output_dir.
+      # Final on-disk path is `<media_output_dir>/assets/generated/<file>`
+      # (the `assets/generated/` suffix is fixed by Media::Base for stable
+      # markdown/relative-path semantics across docs).
+      # Leave nil → fall back to Dir.pwd (legacy behavior, preserved for
+      # older configs that have no key set).
+      @media_output_dir = options[:media_output_dir]
+
       # Per-session virtual model overlay.
       # When set, #current_model returns a *merged* hash (the resolved @models
       # entry merged with this overlay) without mutating the shared @models
@@ -415,6 +425,7 @@ module Clacky
       skill_evolution max_running_agents max_idle_agents
       default_working_dir
       proxy_url
+      media_output_dir
     ].freeze
 
     # Serialize the current agent configuration to YAML.
@@ -434,7 +445,8 @@ module Clacky
         "max_running_agents" => @max_running_agents,
         "max_idle_agents" => @max_idle_agents,
         "default_working_dir" => @default_working_dir,
-        "proxy_url" => @proxy_url
+        "proxy_url" => @proxy_url,
+        "media_output_dir" => @media_output_dir
       }
       YAML.dump("settings" => settings, "models" => persistable_models)
     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: (typeof I18n !== "undefined" ? (I18n.t("changes.tab") !== "changes.tab" ? I18n.t("changes.tab") : "Git 管理") : "Git 管理") },
+  });
+})();