openclacky 1.5.6 → 1.5.7

data/lib/clacky/ui2/ui_controller.rb

@@ -226,6 +226,9 @@ module Clacky
       # trigger a full output repaint (visible flicker) and the visual
       # order would have business messages appearing below the spinner.
       def append_output(content)
+        return nil if Thread.current[:clacky_chore_phase]
+
+        content = prefix_with_phase_label(content)
         @progress_mutex.synchronize do
           top = @progress_stack.last
           if top && top.entry_id
@@ -249,6 +252,17 @@ module Clacky
         @layout.append_output(content)
       end
 
+      # With several phases running at once the CLI's line-oriented output
+      # interleaves, so each line needs its origin stamped on it. A single
+      # active phase reads fine unprefixed (the banners already delimit it).
+      private def prefix_with_phase_label(content)
+        label = Thread.current[:clacky_phase_label]
+        return content unless label
+
+        tag = "[#{label}] "
+        content.to_s.split("\n", -1).map { |line| line.empty? ? line : "#{tag}#{line}" }.join("\n")
+      end
+
       # Log message to output area (use instead of puts)
       # @param message [String] Message to log
       # @param level [Symbol] Log level (:debug, :info, :warning, :error)
@@ -392,6 +406,8 @@ module Clacky
       # @param path [String] File path
       # @param is_new_file [Boolean] Whether this is a new file
       def show_file_write_preview(path, is_new_file:)
+        return if chore_capture(:file, path)
+
         theme = ThemeManager.current_theme
         file_label = theme.format_symbol(:file)
         status = is_new_file ? theme.format_text("Creating new file", :success) : theme.format_text("Modifying existing file", :warning)
@@ -402,6 +418,8 @@ module Clacky
       # Show file operation preview (Edit tool)
       # @param path [String] File path
       def show_file_edit_preview(path)
+        return if chore_capture(:file, path)
+
         theme = ThemeManager.current_theme
         file_label = theme.format_symbol(:file)
         append_output("\n#{file_label} #{path || '(unknown)'}")
@@ -410,6 +428,8 @@ module Clacky
       # Show file operation error
       # @param error_message [String] Error message
       def show_file_error(error_message)
+        return if chore_capture(:error, error_message)
+
         theme = ThemeManager.current_theme
         append_output("   #{theme.format_text("Warning:", :error)} #{error_message}")
       end
@@ -453,10 +473,69 @@ module Clacky
         filtered.strip
       end
 
+      # Record a noteworthy event that happened inside a chore phase. The raw
+      # transcript is suppressed (a line-oriented terminal has no folding),
+      # but the CLI still owes the user a digest — the collapsed-card
+      # equivalent of what the web UI lets you expand.
+      #
+      # @return [Boolean] true if a chore phase absorbed it.
+      private def chore_capture(kind, text)
+        return false unless Thread.current[:clacky_chore_phase]
+        text = text.to_s.strip
+        return true if text.empty?
+
+        @phase_mutex ||= Mutex.new
+        @phase_mutex.synchronize do
+          @chore_digest ||= { tools: Hash.new(0), files: [], errors: [] }
+          case kind
+          when :tool  then @chore_digest[:tools][text] += 1
+          when :file  then @chore_digest[:files] << text unless @chore_digest[:files].include?(text)
+          when :error then @chore_digest[:errors] << text
+          end
+        end
+        true
+      end
+
+      # Turn the captured digest into the handful of lines the CLI prints
+      # after a chore finishes. Errors are always listed in full; tools and
+      # files are condensed, since a memory update touching 20 files should
+      # not out-scroll the answer the user actually asked for.
+      private def chore_digest_lines
+        @phase_mutex ||= Mutex.new
+        digest = @phase_mutex.synchronize { @chore_digest }
+        return [] if digest.nil?
+
+        lines = []
+        digest[:files].first(CHORE_DIGEST_MAX_FILES).each { |f| lines << "· #{f}" }
+        if (extra = digest[:files].size - CHORE_DIGEST_MAX_FILES) > 0
+          lines << "· …#{extra} more file#{"s" if extra > 1}"
+        end
+
+        if digest[:tools].any?
+          total = digest[:tools].values.sum
+          ranked = digest[:tools].sort_by { |_n, c| -c }
+          names = ranked.first(CHORE_DIGEST_MAX_TOOLS).map do |name, count|
+            count > 1 ? "#{name}×#{count}" : name
+          end
+          if (extra = ranked.size - CHORE_DIGEST_MAX_TOOLS) > 0
+            names << "+#{extra} more"
+          end
+          lines << "· #{total} tool call#{"s" if total > 1}: #{names.join(", ")}"
+        end
+
+        digest[:errors].first(CHORE_DIGEST_MAX_ERRORS).each { |e| lines << "! #{e}" }
+        if (extra = digest[:errors].size - CHORE_DIGEST_MAX_ERRORS) > 0
+          lines << "! …#{extra} more error#{"s" if extra > 1}"
+        end
+        lines
+      end
+
       # Show tool call
       # @param name [String] Tool name
       # @param args [String, Hash] Tool arguments (JSON string or Hash)
       def show_tool_call(name, args)
+        return if chore_capture(:tool, name)
+
         # Reset stdout buffer on each new tool call so previous command output
         # doesn't bleed into the next one, and so the buffer is ready before
         # on_output starts firing (which can happen before show_progress is called).
@@ -506,6 +585,8 @@ module Clacky
       # @param error [String, Exception] Error message or exception
       def show_tool_error(error)
         error_msg = error.is_a?(Exception) ? error.message : error.to_s
+        return if chore_capture(:error, error_msg)
+
         output = @renderer.render_tool_error(error: error_msg)
         append_output(output)
       end
@@ -655,6 +736,22 @@ module Clacky
 
       # Called by ProgressHandle#start.
       def register_progress(handle)
+        # Inside a chore phase only the phase's own indicator occupies a line.
+        # Nested handles (the subagent's LLM calls and tool runs) get no entry
+        # of their own — otherwise each one commits a permanent final frame on
+        # finish, since unregister_progress writes straight into the buffer and
+        # never passes through append_output's chore gate. Their activity is
+        # instead folded into the chore line by +fold_into_chore_line+.
+        if Thread.current[:clacky_chore_phase] && @chore_progress
+          @progress_mutex.synchronize do
+            @chore_nested ||= []
+            @chore_nested << handle
+            @chore_steps = @chore_steps.to_i + 1 if handle.style == :primary
+            fold_into_chore_line(handle)
+          end
+          return nil
+        end
+
         @progress_mutex.synchronize do
           prev_top = @progress_stack.last
           if prev_top
@@ -675,6 +772,17 @@ module Clacky
       # Called by ProgressHandle#finish.
       def unregister_progress(handle, final_frame:)
         @progress_mutex.synchronize do
+          if @chore_nested&.delete(handle)
+            # Folded handles own no entry; hand the chore line back to
+            # whatever is still running underneath (or the bare label).
+            fold_into_chore_line(@chore_nested.last)
+            next
+          end
+
+          # A handle that was never stacked owns nothing here: restoring
+          # "the new top" would duplicate what is legitimately on screen.
+          next unless @progress_stack.include?(handle)
+
           if handle.entry_id
             if final_frame && !final_frame.to_s.strip.empty?
               update_entry(handle.entry_id, @renderer.render_progress(final_frame))
@@ -705,6 +813,19 @@ module Clacky
       # +register_progress+).
       def render_frame(handle, frame)
         @progress_mutex.synchronize do
+          if @chore_nested&.include?(handle)
+            fold_into_chore_line(handle)
+            return
+          end
+
+          # The chore's own ticker must render the folded view too, otherwise
+          # every tick repaints the bare label and the line flickers between
+          # "<label>…" and "<label> · <activity>…".
+          if @chore_progress && @chore_progress == handle && @chore_nested&.any?
+            fold_into_chore_line(@chore_nested.last)
+            return
+          end
+
           return unless @progress_stack.last == handle
           return unless handle.entry_id
 
@@ -726,6 +847,27 @@ module Clacky
         end
       end
 
+      # Repaint the chore phase's single line to reflect the innermost nested
+      # activity: "<label> · <what it's doing> (Ns · step K)". Keeps the user
+      # informed without letting the chore's subagent spam one permanent line
+      # per LLM call. Must be called with @progress_mutex held.
+      private def fold_into_chore_line(inner)
+        chore = @chore_progress
+        return unless chore&.entry_id
+
+        parts = [chore.message]
+        parts << inner.message.to_s.strip if inner && !inner.message.to_s.strip.empty?
+
+        suffix = []
+        elapsed = chore.start_time ? (Time.now - chore.start_time).to_i : 0
+        suffix << "#{elapsed}s" if elapsed > 0
+        suffix << "step #{@chore_steps}" if @chore_steps.to_i > 0
+
+        line = parts.join(" · ")
+        line = "#{line}… (#{suffix.join(" · ")})" unless suffix.empty?
+        update_entry(chore.entry_id, @renderer.render_progress(line))
+      end
+
       # Render the very first frame of +handle+ (used when registering or
       # restoring). Mirrors +render_frame+'s formatting minus the implicit
       # elapsed-time tick (handle hasn't ticked yet).
@@ -888,28 +1030,86 @@ module Clacky
         append_output(output)
       end
 
-      def phase_start(kind:, label:)
+      # Phases the user never asked for: post-task chores that run after the
+      # answer is already on screen. The web UI folds them into a card; a
+      # line-oriented terminal has no folding, so their transcript is
+      # swallowed and only a one-line progress indicator remains.
+      CHORE_PHASE_KINDS = %w[memory_update skill_evolution].freeze
+
+      # Caps for the post-chore digest. A chore is background work the user
+      # never asked for, so its recap must stay far shorter than the answer.
+      CHORE_DIGEST_MAX_FILES = 5
+      CHORE_DIGEST_MAX_TOOLS = 4
+      CHORE_DIGEST_MAX_ERRORS = 3
+
+      def phase_start(kind:, label:, concurrent: false)
         phase_id = SecureRandom.uuid
-        @active_phases ||= {}
-        @active_phases[phase_id] = { kind: kind, label: label, started_at: Time.now }
+        chore = CHORE_PHASE_KINDS.include?(kind.to_s) && !verbose_phases?
+        @phase_mutex ||= Mutex.new
+        @phase_mutex.synchronize do
+          @active_phases ||= {}
+          @active_phases[phase_id] = { kind: kind, label: label, started_at: Time.now, chore: chore }
+        end
         Thread.current[:clacky_phase_id] = phase_id
 
+        if chore
+          # Start the indicator before arming the gate: this handle is the
+          # one thing that stays visible during the chore.
+          @chore_progress = start_progress(message: label, style: :quiet)
+          Thread.current[:clacky_chore_phase] = phase_id
+          return phase_id
+        end
+
         banner = "──────── ▼ #{label} ────────"
         append_output(@renderer.render_system_message(banner, prefix_newline: true))
+        # Only concurrent phases interleave, so only they need per-line tagging.
+        Thread.current[:clacky_phase_label] = concurrent ? label : nil
         phase_id
       end
 
       def phase_end(phase_id, summary: nil)
-        Thread.current[:clacky_phase_id] = nil
-        return unless @active_phases&.key?(phase_id)
+        Thread.current[:clacky_phase_id] = nil if Thread.current[:clacky_phase_id] == phase_id
+        Thread.current[:clacky_phase_label] = nil
+        @phase_mutex ||= Mutex.new
+        info = @phase_mutex.synchronize { @active_phases&.delete(phase_id) }
+        return unless info
 
-        info = @active_phases.delete(phase_id)
         label = info[:label]
+
+        if info[:chore]
+          Thread.current[:clacky_chore_phase] = nil
+          handle = @chore_progress
+          @chore_progress = nil
+          @chore_nested = nil
+          @chore_steps = 0
+          handle&.discard
+
+          digest = chore_digest_lines
+          @phase_mutex.synchronize { @chore_digest = nil }
+
+          # No summary and nothing captured means nothing worth reporting
+          # happened (the common "no memory updates needed" path) — leave no
+          # trace at all.
+          has_summary = summary && !summary.to_s.strip.empty?
+          return if !has_summary && digest.empty?
+
+          elapsed = (Time.now - info[:started_at]).round
+          head = has_summary ? "#{label} — #{summary.to_s.strip} (#{elapsed}s)" : "#{label} (#{elapsed}s)"
+          append_output(@renderer.render_system_message(head, prefix_newline: false))
+          theme = ThemeManager.current_theme
+          digest.each { |line| append_output(theme.format_text("    #{line}", :thinking)) }
+          return
+        end
+
         tail = summary && !summary.to_s.strip.empty? ? " — #{summary.to_s.strip}" : ""
         banner = "──────── ▲ #{label} done#{tail} ────────"
         append_output(@renderer.render_system_message(banner, prefix_newline: false))
       end
 
+      private def verbose_phases?
+        @config.respond_to?(:verbose) && @config.verbose
+      end
+
       # Set workspace status to idle (called when agent stops working)
       def set_idle_status
         # Safety net: close any legacy progress slots that were opened via

data/lib/clacky/ui_interface.rb

@@ -159,19 +159,29 @@ module Clacky
     # === Lifecycle ===
     def stop(clear_screen: false); end
 
+    # === Custom events (extension bus) ===
+    # Push an arbitrary typed event to the UI transport. Streaming UIs (web,
+    # json) override this; UIs with no event channel (CLI, null) drop it.
+    #
+    # Extensions must namespace `type` as "ext.<extension>.<event>" so custom
+    # events never collide with the built-in protocol. The web UI forwards
+    # namespaced events straight to the `Clacky.ext` bus, where a subscriber
+    # receives them under that same name.
+    def emit(type, **data); end
+
     # === Phase grouping (optional, web UI uses this to fold subagent runs) ===
     # Begin a logical phase. Events emitted between phase_start and phase_end
     # carry the phase_id so the UI can group them visually.
     # Returns the phase_id (caller is responsible for passing it to phase_end).
-    def phase_start(kind:, label: nil)
+    def phase_start(kind:, label: nil, concurrent: false)
       SecureRandom.uuid
     end
 
     def phase_end(phase_id, summary: nil); end
 
     # Run block within a phase. Always closes via ensure.
-    def with_phase(kind:, label: nil)
-      pid = phase_start(kind: kind, label: label)
+    def with_phase(kind:, label: nil, concurrent: false)
+      pid = phase_start(kind: kind, label: label, concurrent: concurrent)
       begin
         yield pid
       ensure

data/lib/clacky/utils/arguments_parser.rb

@@ -88,12 +88,78 @@ module Clacky
         result
       end
 
+      # Undo one layer of accidental double-serialization, guided by the tool's
+      # parameter schema.
+      #
+      # Some LLMs (e.g. glm-5.2) emit array/object parameters as a JSON *string*
+      # (e.g. {"task":"[\"a\",\"b\"]"}) instead of a native JSON value. JSON.parse
+      # only strips the outer layer, so such values arrive here as a literal
+      # String and break downstream tools that expect an Array/Hash.
+      #
+      # To stay safe we rely on the declared schema type instead of a blind
+      # "looks like JSON" heuristic:
+      #   - a parameter declared `type: "string"` is NEVER parsed, so a value
+      #     that merely happens to be valid JSON text (file content, a code
+      #     snippet, a JSON blob to be written) is preserved verbatim;
+      #   - a parameter declared `type: "array"`/`"object"` that still arrives
+      #     as a String is unwrapped exactly once;
+      #   - additionally, when a concrete type IS declared, the parsed result
+      #     must match it (an array-typed param that receives a JSON object
+      #     string is left untouched rather than silently coerced to a Hash);
+      #   - a parameter with no declared `type` (e.g. flexible params such as
+      #     todo_manager's task/id, which may be a scalar or a list) falls back
+      #     to a conservative heuristic: unwrap only if the stripped value
+      #     starts with "["/"{" and parses cleanly.
+      # Strings that fail JSON.parse are always left untouched.
+      def self.undouble_serialize_args(args, properties = {})
+        args.to_h do |key, value|
+          expected = schema_type(properties, key)
+          # Explicit string params: never unwrap (protects content / code / JSON text).
+          next [key, value] if expected == "string"
+          # Scalar-typed params (integer/number/boolean): no JSON shape to recover.
+          next [key, value] if expected && expected != "array" && expected != "object"
+          # For array/object/untyped params, only unwrap a String that looks like JSON.
+          next [key, value] unless value.is_a?(String)
+          stripped = value.strip
+          next [key, value] unless stripped.start_with?("[") || stripped.start_with?("{")
+          begin
+            # symbolize_names keeps unwrapped Hash keys consistent with the
+            # outer JSON.parse(call[:arguments], symbolize_names: true).
+            parsed = JSON.parse(value, symbolize_names: true)
+            # Type-match guard: if the schema declares a concrete type, the
+            # parsed value must match it. Prevents silently turning a Hash into
+            # an Array (or vice-versa) when an array-typed param receives a
+            # JSON object string, etc.
+            if expected == "array" && !parsed.is_a?(Array)
+              next [key, value]
+            elsif expected == "object" && !parsed.is_a?(Hash)
+              next [key, value]
+            end
+            [key, parsed]
+          rescue JSON::ParserError
+            [key, value]
+          end
+        end
+      end
+
+      # Look up a parameter's declared JSON-Schema type, tolerating string/symbol
+      # keys in both +properties+ and the per-param spec hash.
+      def self.schema_type(properties, key)
+        spec = properties[key] || properties[key.to_s] || properties[key.to_sym]
+        return nil unless spec.is_a?(Hash)
+        spec[:type] || spec["type"]
+      end
+
       # Validate required parameters and filter unknown parameters
       def self.validate_required_params(call, args, tool_registry)
         tool = tool_registry.get(call[:name])
         required = tool.parameters&.dig(:required) || []
         properties = tool.parameters&.dig(:properties) || {}
 
+        # Undo accidental double-serialization BEFORE filtering, using the schema
+        # so that parameters declared as "string" are never touched.
+        args = undouble_serialize_args(args, properties)
+
         missing = required.reject { |param|
           args.key?(param.to_sym) || args.key?(param.to_s)
         }
@@ -161,11 +227,14 @@ module Clacky
         lines << "  Name: #{tool.name}"
         lines << "  Description: #{tool.description}"
 
-        if tool.parameters[:properties]
+        params = tool.parameters
+        properties = params && params[:properties]
+        if properties
           lines << "  Parameters:"
-          tool.parameters[:properties].each do |param, spec|
-            required_mark = tool.parameters[:required]&.include?(param.to_s) ? " (required)" : ""
-            lines << "    - #{param}#{required_mark}: #{spec[:description]}"
+          properties.each do |param, spec|
+            required_mark = params[:required]&.include?(param.to_s) ? " (required)" : ""
+            desc = spec.is_a?(Hash) ? spec[:description] : spec.to_s
+            lines << "    - #{param}#{required_mark}: #{desc}"
           end
         end
 

data/lib/clacky/utils/model_pricing.rb

@@ -377,6 +377,25 @@ module Clacky
         }
       },
 
+      # Gemini 3.6 Flash (GA 2026-07-21). Flat pricing, 1M context, 64K max output.
+      # Source: https://deepmind.google/models/gemini/flash/
+      # Cache write billed at input rate (Vertex doesn't expose a separate
+      # cache-write charge in the OpenAI shim usage response).
+      "gemini-3.6-flash" => {
+        input: {
+          default: 1.50,
+          over_200k: 1.50
+        },
+        output: {
+          default: 7.50,
+          over_200k: 7.50
+        },
+        cache: {
+          write: 1.50,
+          read: 0.15
+        }
+      },
+
       # OpenAI GPT-5.5 / GPT-5.4 — breakpoint at 272K input tokens
       # Source: https://openai.com/api/pricing/ (USD / 1M tokens)
       # Note: OpenAI's actual tiered-pricing threshold is 272K, not the
@@ -882,6 +901,8 @@ module Clacky
           "gemini-3.1-pro"
         when /^or-gemini-3-5-flash$/i, /^gemini-3\.5-flash$/i, /^gemini-3-flash(-preview)?$/i
           "gemini-3-flash"
+        when /^or-gemini-3-6-flash$/i, /^gemini-3\.6-flash$/i
+          "gemini-3.6-flash"
 
         # OpenAI GPT-5.x models — match various dashed/dotted/compact forms
         # (e.g. "gpt-5.5", "gpt-5-5", "gpt5.5", "gpt55")

data/lib/clacky/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Clacky
-  VERSION = "1.5.6"
+  VERSION = "1.5.7"
 end

data/lib/clacky/web/app.css

@@ -1021,6 +1021,12 @@ body {
   color: #10b981;
   border-color: transparent;
 }
+/* Source: ext — violet tint (created by an installed extension). */
+.session-badge--ext     {
+  background: color-mix(in srgb, #8b5cf6 10%, transparent);
+  color: #8b5cf6;
+  border-color: transparent;
+}
 /* Source: setup — muted neutral (rarely visible in normal use). */
 .session-badge--setup   {
   background: var(--color-bg-tertiary);
@@ -5555,7 +5561,8 @@ body {
   gap: 0.5rem;
   align-items: center;
 }
-.settings-network-url-row .field-input { flex: 1; }
+.settings-network-url-row .field-input,
+.settings-network-url-row .field-select { flex: 1; }
 .settings-loading, .settings-empty, .settings-error {
   color: var(--color-text-secondary);
   font-size: 0.8125rem;
@@ -5719,7 +5726,7 @@ body {
   width: 100%;
   cursor: pointer;
   appearance: none;
-  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 12 12'%3E%3Cpath fill='%238b949e' d='M6 8L1 3h10z'/%3E%3C/svg%3E");
+  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 24 24' fill='none' stroke='%238b949e' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='M19 9l-7 7-7-7'/%3E%3C/svg%3E");
   background-repeat: no-repeat;
   background-position: right 10px center;
   padding-right: 1.75rem;
@@ -6889,7 +6896,7 @@ body {
 .modal-select {
   cursor: pointer;
   appearance: none;
-  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 12 12'%3E%3Cpath fill='%238b949e' d='M6 8L1 3h10z'/%3E%3C/svg%3E");
+  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 24 24' fill='none' stroke='%238b949e' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='M19 9l-7 7-7-7'/%3E%3C/svg%3E");
   background-repeat: no-repeat;
   background-position: right 12px center;
   padding-right: 2rem;

data/lib/clacky/web/features/new-session/view.js

@@ -222,6 +222,18 @@ const NewSessionView = (() => {
 
   async function _prefillDefaultDir() {
     if (NewSessionStore.state.advanced.workingDir) return;  // already set
+    // When a project is selected (possibly restored from localStorage by
+    // loadAgents), prefer its working directory over the global default so
+    // the new session lands in the project's folder — same behavior as
+    // picking the project explicitly from the context bar popover.
+    const project = typeof Projects !== "undefined" && Projects.find
+      ? Projects.find(NewSessionStore.state.advanced.projectId)
+      : null;
+    if (project && project.working_dir) {
+      NewSessionStore.updateAdvanced({ workingDir: project.working_dir });
+      _renderContextBar();
+      return;
+    }
     const home = await NewSessionStore.loadDefaultDirectory();
     if (home) {
       NewSessionStore.updateAdvanced({ workingDir: home });
@@ -857,14 +869,19 @@ const NewSessionView = (() => {
     const sendBtn = $("new-session-send");
     if (sendBtn) sendBtn.addEventListener("click", _submit);
 
-    // Context bar: load models + default dir eagerly, then render chips
+    // Context bar: load models eagerly, then render chips. The working-dir
+    // prefill happens in onPanelShow() instead, so it runs after loadAgents()
+    // restores the remembered project from localStorage.
     _populateModels().then(() => _renderContextBar());
-    _prefillDefaultDir().then(() => _renderContextBar());
   }
 
   async function onPanelShow() {
     _bindOnce();
     await NewSessionStore.loadAgents();
+    // Must run after loadAgents(): that call restores the remembered
+    // projectId from localStorage, which decides whether the working dir is
+    // prefilled from the project or from the global default.
+    await _prefillDefaultDir();
     _renderContextBar();
     _updateSendButton();
     const input = $("new-session-input");

data/lib/clacky/web/i18n.js

@@ -13,6 +13,9 @@ const I18n = (() => {
   // ── Translation dictionary ─────────────────────────────────────────────────
   const TRANSLATIONS = {
     en: {
+      // ── Phases ──
+      "phase.no_changes":      "no changes needed",
+
       // ── Sidebar ──
       "sidebar.chat":     "Chat",
       "sidebar.projects": "Projects",
@@ -52,9 +55,11 @@ const I18n = (() => {
       "projects.menu.rename": "Rename",
       "projects.menu.edit": "Edit",
       "projects.menu.delete": "Delete",
+      "projects.menu.deleteSessions": "Delete Sessions",
       "projects.edit.title": "Edit Project",
       "projects.edit.submit": "Save",
       "projects.delete.confirm": "Delete project \"{{name}}\"? All sessions in this project will also be deleted.",
+      "projects.deleteSessions.confirm": "Delete all sessions in project \"{{name}}\"? The project itself will be kept.",
       "projects.modal.name":         "Project Name",
 
       // ── Welcome screen ──
@@ -210,10 +215,12 @@ const I18n = (() => {
       "sib.reasoning.max": "Max",
       "sessions.thinking":      "Thinking…",
       "sessions.default_name":  "Session {{n}}",
-      "sessions.cronGroup":     "Scheduled Tasks",
-      "sessions.cronGroupMeta": "{{n}} sessions",
-      "sessions.cronLoading":   "Loading scheduled tasks...",
+      "sessions.group.cron":     "Scheduled Tasks",
+      "sessions.group.ext":      "Extensions",
+      "sessions.groupMeta":      "{{n}} sessions",
+      "sessions.groupLoading":   "Loading sessions...",
       "sessions.badge.cron":    "Auto",
+      "sessions.badge.ext":     "Ext",
       "sessions.badge.channel": "Channel",
       "sessions.badge.coding":  "Coding",
       "sessions.badge.setup":   "Setup",
@@ -766,7 +773,7 @@ const I18n = (() => {
       "settings.network.cleared":          "Cleared — direct connection",
       "settings.network.invalidUrl":       "Invalid URL — use http://host:port or http://user:pass@host:port",
       "settings.search.title":             "Web Search",
-      "settings.search.desc":              "By default web_search scrapes DuckDuckGo and Bing, which needs no key but returns lower-quality results. Select a search provider to use an API instead — it falls back to the built-in engines if the provider fails.",
+      "settings.search.desc":              "Free built-in search (DuckDuckGo / Bing) works out of the box. Connect an API provider below for higher-quality results — falls back to built-in if unavailable.",
       "settings.search.provider":          "Provider",
       "settings.search.builtin":           "Built-in (DuckDuckGo / Bing)",
       "settings.search.key":               "API Key",
@@ -1086,6 +1093,9 @@ const I18n = (() => {
       "billing.disclaimer":      "Costs are estimated based on token usage and may differ from your provider's actual bill.",
     },
     zh: {
+      // ── Phases ──
+      "phase.no_changes":      "无需改动",
+
       // ── Sidebar ──
       "sidebar.chat":     "会话",
       "sidebar.projects": "项目",
@@ -1124,9 +1134,11 @@ const I18n = (() => {
       "projects.menu.rename": "重命名",
       "projects.menu.edit": "编辑",
       "projects.menu.delete": "删除",
+      "projects.menu.deleteSessions": "删除会话",
       "projects.edit.title": "编辑项目",
       "projects.edit.submit": "保存",
       "projects.delete.confirm": "删除项目「{{name}}」？该项目下的所有会话也将被删除。",
+      "projects.deleteSessions.confirm": "删除项目「{{name}}」下的所有会话？项目本身会被保留。",
       "projects.modal.name":         "项目名称",
 
       // ── Welcome screen ──
@@ -1280,10 +1292,12 @@ const I18n = (() => {
       "sib.reasoning.max": "Max",
       "sessions.thinking":      "思考中…",
       "sessions.default_name":  "会话 {{n}}",
-      "sessions.cronGroup":     "定时任务",
-      "sessions.cronGroupMeta": "{{n}} 个会话",
-      "sessions.cronLoading":   "正在加载定时任务...",
+      "sessions.group.cron":     "定时任务",
+      "sessions.group.ext":      "扩展",
+      "sessions.groupMeta":      "{{n}} 个会话",
+      "sessions.groupLoading":   "正在加载会话...",
       "sessions.badge.cron":    "定时",
+      "sessions.badge.ext":     "扩展",
       "sessions.badge.channel": "频道",
       "sessions.badge.coding":  "Coding",
       "sessions.badge.setup":   "配置",
@@ -1842,7 +1856,7 @@ const I18n = (() => {
       "settings.network.cleared":          "已清除 — 直连",
       "settings.network.invalidUrl":       "地址格式不正确，请使用 http://host:port 或 http://user:pass@host:port",
       "settings.search.title":             "网页搜索",
-      "settings.search.desc":              "默认 web_search 抓取 DuckDuckGo 和 Bing，无需密钥但结果质量较低。选择搜索服务商可改用 API 搜索，服务商失败时会自动回退到内置引擎。",
+      "settings.search.desc":              "内置免费搜索（DuckDuckGo / Bing）开箱即用。在下方接入 API 服务商可获得更高质量的搜索结果，不可用时自动回退到内置引擎。",
       "settings.search.provider":          "服务商",
       "settings.search.builtin":           "内置（DuckDuckGo / Bing）",
       "settings.search.key":               "API 密钥",