openclacky 1.2.12 → 1.2.13

data/lib/clacky/cli.rb

@@ -50,6 +50,7 @@ module Clacky
     option :verbose, type: :boolean, aliases: "-v", default: false, desc: "Show detailed output"
     option :path, type: :string, desc: "Project directory path (defaults to current directory)"
     option :continue, type: :boolean, aliases: "-c", desc: "Continue most recent session"
+    option :fork, type: :string, desc: "Fork a session by number or session ID prefix (creates a copy)"
     option :list, type: :boolean, aliases: "-l", desc: "List recent sessions"
     option :attach, type: :string, aliases: "-a", desc: "Attach to session by number or keyword"
     option :json, type: :boolean, default: false, desc: "Output NDJSON to stdout (for scripting/piping)"
@@ -140,6 +141,9 @@ module Clacky
       elsif options[:attach]
         agent = load_session_by_number(client_factory.call, agent_config, session_manager, working_dir, options[:attach], profile: agent_profile)
         is_session_load = !agent.nil?
+      elsif options[:fork]
+        agent = fork_session(client_factory.call, agent_config, session_manager, working_dir, options[:fork], profile: agent_profile)
+        is_session_load = !agent.nil?
       end
 
       # Create new agent if no session loaded
@@ -549,8 +553,59 @@ module Clacky
         Clacky::Agent.from_session(client, agent_config, session_data, profile: resolved_profile)
       end
 
+      def fork_session(client, agent_config, session_manager, working_dir, identifier, profile:)
+        # Get a larger list to search through (for ID prefix matching)
+        sessions = session_manager.all_sessions(current_dir: working_dir, limit: 100)
+
+        if sessions.empty?
+          say "No sessions found.", :yellow
+          return nil
+        end
+
+        session_data = nil
+
+        # Same resolution logic as load_session_by_number
+        if identifier.match?(/^\d+$/) && identifier.to_i <= 99
+          index = identifier.to_i - 1
+          if index < 0 || index >= sessions.size
+            say "Invalid session number. Use -l to list available sessions.", :red
+            exit 1
+          end
+          session_data = sessions[index]
+        else
+          matching_sessions = sessions.select { |s| s[:session_id].start_with?(identifier) }
+          if matching_sessions.empty?
+            say "No session found matching ID prefix: #{identifier}", :red
+            say "Use -l to list available sessions.", :yellow
+            exit 1
+          elsif matching_sessions.size > 1
+            say "Multiple sessions found matching '#{identifier}':", :yellow
+            matching_sessions.each_with_index do |session, idx|
+              created_at = Time.parse(session[:created_at]).strftime("%Y-%m-%d %H:%M")
+              s_id = session[:session_id][0..7]
+              name = session[:name].to_s.empty? ? "Unnamed session" : session[:name]
+              say "  #{idx + 1}. [#{s_id}] #{created_at} - #{name}", :cyan
+            end
+            say "\nPlease use a more specific prefix.", :yellow
+            exit 1
+          else
+            session_data = matching_sessions.first
+          end
+        end
+
+        fork_data = session_manager.fork(session_data[:session_id])
+        return nil unless fork_data
+
+        # Fall back to CLI --agent flag for sessions that predate agent_profile
+        restored_profile = fork_data[:agent_profile].to_s
+        resolved_profile = restored_profile.empty? ? profile : restored_profile
+
+        Clacky::Agent.from_session(client, agent_config, fork_data, profile: resolved_profile)
+      end
+
       # Handle agent error/interrupt with cleanup
       def handle_agent_exception(ui_controller, agent, session_manager, exception)
+        Clacky::Logger.warn("[ph_debug] handle_agent_exception", klass: exception.class.name, msg: exception.message.to_s[0, 200])
         ui_controller.show_progress(phase: "done")
         ui_controller.set_idle_status
 

data/lib/clacky/default_skills/persist-memory/SKILL.md

@@ -48,10 +48,11 @@ Scan the list above:
 
 Use the `write` tool. Always include the YAML frontmatter shown above.
 
-## Hard constraints (CRITICAL)
+## Guidelines
 
-- Each file MUST stay under **4000 characters of content** (after the frontmatter).
-- If merging would exceed this limit, remove the least important information — do NOT split into multiple files for the same topic.
+- Aim for around 4000 characters of content (after the frontmatter). This is a soft target — moderate overshoot is fine, do NOT iterate writes just to shave characters.
+- If a file grows much larger than that (say, well past 8000), trim the least important information rather than splitting one topic across multiple files.
+- Prefer merging into an existing file over creating a new one. Only create a new file when no existing topic genuinely covers the area.
 - Write concise, factual Markdown — no fluff, no redundant headings.
 - One topic per file. Don't bundle unrelated facts together.
 - Do NOT use `terminal` or `file_reader` to list the memories directory — the list above is authoritative.

data/lib/clacky/default_skills/search-skills/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: search-skills
+description: 'Search ALL installed skills (including ones not shown in AVAILABLE SKILLS) by keyword. Use this whenever you suspect a fitting skill might exist but is not listed in your system prompt — for example before building a new skill, when the user mentions a domain not covered by visible skills, or after seeing the (N more skills installed) hint. Triggers on phrases like search skills, find a skill for, is there a skill that, 查找skill, 有没有skill做.'
+disable-model-invocation: false
+user-invocable: true
+fork_agent: true
+auto_summarize: true
+forbidden_tools:
+  - write
+  - edit
+  - terminal
+  - web_search
+  - web_fetch
+  - browser
+---
+
+# Search Skills Subagent
+
+You are a Skill Search Subagent. Given a keyword or topic from the parent agent, scan the complete list of installed skills below and return the best matches.
+
+The AVAILABLE SKILLS section in the parent agent system prompt is capped (~30 entries). The list below is the FULL list — pre-loaded for you, no scanning required. Your job is to look beyond that cap so the parent does not redundantly create a new skill when one already exists.
+
+## Complete Skill Inventory
+
+This list was pre-loaded — do NOT re-scan the filesystem or call any tools.
+
+<%= all_skills_meta %>
+
+## Workflow
+
+### Step 1 — Extract keywords
+
+Pull 2-4 keywords from the input task. Both English and Chinese terms are valid (skill descriptions are bilingual).
+
+### Step 2 — Match against the inventory above
+
+For each skill in the inventory, judge relevance against the keywords:
+- Strong match: keyword appears in the skill `name` or clearly in the `description`'s purpose statement
+- Weak match: keyword appears only in the trigger examples or peripheral mentions
+
+### Step 3 — Return a ranked summary
+
+Return at most 5 results, strongest matches first:
+
+```
+Found N matching skill(s) for: <keywords>
+
+1. <name>  (<source>)
+   <description trimmed to ~200 chars>
+
+2. ...
+```
+
+If nothing genuinely matches, return exactly: `No installed skill matches: <task>`
+
+## Rules
+
+- Do NOT invoke any tool. The inventory above is authoritative; just match and return.
+- Do NOT recommend creating a new skill — that is the parent agent's call.
+- If the task is vague, return what genuinely matched, do not invent relevance.
+- Default skills (built-in) are part of the inventory but typically also visible to the parent — flagging them is still useful as a reminder.

data/lib/clacky/idle_compression_timer.rb

@@ -17,7 +17,7 @@ module Clacky
     # Seconds of inactivity before idle compression is triggered.
     # Kept under the 5-minute prompt cache TTL so the compression call itself
     # still hits the existing prefix cache.
-    IDLE_DELAY = 314
+    IDLE_DELAY = 266
 
     # @param agent [Clacky::Agent] the agent whose messages will be compressed
     # @param session_manager [Clacky::SessionManager, nil] used to persist session after compression

data/lib/clacky/message_format/open_ai.rb

@@ -206,7 +206,13 @@ module Clacky
           # Skip malformed tool calls where name or arguments is nil (broken API response)
           next if name.nil? || arguments.nil?
 
-          { id: call["id"], type: call["type"], name: name, arguments: arguments }
+          tc = { id: call["id"], type: call["type"], name: name, arguments: arguments }
+          # Vertex Gemini's OpenAI shim returns thought_signature inside
+          # tool_calls[i].extra_content.google and requires it echoed back on
+          # replay, otherwise the next turn 400s with "Function call is missing
+          # a thought_signature". Preserve it through the canonical layer.
+          tc[:extra_content] = call["extra_content"] if call["extra_content"]
+          tc
         end
       end
 

data/lib/clacky/openai_stream_aggregator.rb

@@ -72,7 +72,7 @@ module Clacky
     def to_h
       tool_calls = @tool_calls.keys.sort.map do |idx|
         tc = @tool_calls[idx]
-        {
+        out = {
           "id"       => tc[:id],
           "type"     => tc[:type] || "function",
           "function" => {
@@ -80,6 +80,8 @@ module Clacky
             "arguments" => tc[:arguments].to_s
           }
         }
+        out["extra_content"] = tc[:extra_content] if tc[:extra_content]
+        out
       end
 
       message = {
@@ -104,6 +106,7 @@ module Clacky
         slot[:name] ||= fn["name"] if fn["name"]
         slot[:arguments] << fn["arguments"].to_s if fn["arguments"]
       end
+      slot[:extra_content] = tc["extra_content"] if tc["extra_content"]
     end
 
     private def parse_or_nil(s)

data/lib/clacky/providers.rb

@@ -39,18 +39,25 @@ module Clacky
           "abs-claude-haiku-4-5",
           "dsk-deepseek-v4-pro",
           "dsk-deepseek-v4-flash",
-          "or-gemini-3-1-pro"
+          "or-gemini-3-1-pro",
+          "or-gemini-3-5-flash"
         ],
         # Image generation models served by the openclacky platform
         # gateway. The gateway exposes a standard OpenAI-compatible
         # /v1/images/generations endpoint, so the same OpenAICompat
-        # provider class handles them. `or-` prefix mirrors the chat
-        # model naming — these are routed through the OpenRouter
-        # backend by the platform.
+        # provider class handles them. `or-` prefix is a routing alias
+        # only — the platform may dispatch to OpenRouter or Vertex AI
+        # (Gemini Nano Banana family) depending on the model.
         "image_models" => [
           "or-gemini-3-pro-image",
+          "or-gemini-3-1-flash-image",
           "or-gpt-image-2"
         ],
+        "image_model_aliases" => {
+          "or-gemini-3-pro-image"      => "Nano Banana Pro",
+          "or-gemini-3-1-flash-image"  => "Nano Banana 2",
+          "or-gpt-image-2"             => "GPT Image 2"
+        },
         "default_image_model" => "or-gpt-image-2",
         # Provider-level default: the Claude family served here is vision-capable.
         "capabilities" => { "vision" => true }.freeze,
@@ -65,20 +72,17 @@ module Clacky
         # Per-primary lite pairing: keys are "strong" primary models, values
         # are the lite sidekick to auto-inject when that primary is the
         # default. Lite is consumed by some subagents for cheap/fast work;
-        # weak models (haiku / v4-flash) ARE the lite tier themselves, so
-        # they're intentionally not listed here — no injection happens when
-        # the default model is already lite-class.
-        #
-        # or-gemini-3-1-pro is intentionally absent: Gemini has no lite
-        # sibling wired up (yet) on this provider; subagents using the
-        # Gemini default will just reuse it for lite work until we add one.
+        # weak models (haiku / v4-flash / 3-5-flash) ARE the lite tier
+        # themselves, so they're intentionally not listed here as keys —
+        # no injection happens when the default model is already lite-class.
         "lite_models" => {
           "abs-claude-opus-4-8"   => "abs-claude-haiku-4-5",
           "abs-claude-opus-4-7"   => "abs-claude-haiku-4-5",
           "abs-claude-opus-4-6"   => "abs-claude-haiku-4-5",
           "abs-claude-sonnet-4-6" => "abs-claude-haiku-4-5",
           "abs-claude-sonnet-4-5" => "abs-claude-haiku-4-5",
-          "dsk-deepseek-v4-pro"   => "dsk-deepseek-v4-flash"
+          "dsk-deepseek-v4-pro"   => "dsk-deepseek-v4-flash",
+          "or-gemini-3-1-pro"     => "or-gemini-3-5-flash"
         },
         # Fallback chain: if a model is unavailable, try the next one in order.
         # Keys are primary model names; values are the fallback model to use instead.
@@ -487,6 +491,30 @@ module Clacky
         preset&.dig("image_models") || []
       end
 
+      def image_model_aliases(provider_id)
+        preset = PRESETS[provider_id]
+        preset&.dig("image_model_aliases") || {}
+      end
+
+      def video_model_aliases(provider_id)
+        preset = PRESETS[provider_id]
+        preset&.dig("video_model_aliases") || {}
+      end
+
+      def audio_model_aliases(provider_id)
+        preset = PRESETS[provider_id]
+        preset&.dig("audio_model_aliases") || {}
+      end
+
+      def media_model_aliases(provider_id, kind)
+        case kind.to_s
+        when "image" then image_model_aliases(provider_id)
+        when "video" then video_model_aliases(provider_id)
+        when "audio" then audio_model_aliases(provider_id)
+        else {}
+        end
+      end
+
       # Video generation models — placeholder. No provider supports video
       # via Clacky yet; once they do, declare "video_models" alongside
       # "image_models" in the relevant PRESETS entry and this returns it.

data/lib/clacky/server/http_server.rb

@@ -5,6 +5,7 @@ require "websocket"
 require "socket"
 require "json"
 require "net/http"
+require "faraday"
 require "thread"
 require "fileutils"
 require "tmpdir"
@@ -437,6 +438,7 @@ module Clacky
         when ["PATCH",  "/api/config/settings"]  then api_update_settings(req, res)
         when ["POST",   "/api/config/models"] then api_add_model(req, res)
         when ["POST",   "/api/config/test"]   then api_test_config(req, res)
+        when ["POST",   "/api/config/media/test"] then api_test_media_config(req, res)
         when ["GET",    "/api/config/media"]  then api_get_media_config(res)
         when ["GET",    "/api/providers"]     then api_list_providers(res)
         when ["GET",    "/api/onboard/status"]    then api_onboard_status(res)
@@ -552,6 +554,9 @@ module Clacky
           elsif method == "PATCH" && path.match?(%r{^/api/sessions/[^/]+/working_dir$})
             session_id = path.sub("/api/sessions/", "").sub("/working_dir", "")
             api_change_session_working_dir(session_id, req, res)
+          elsif method == "POST" && path.match?(%r{^/api/sessions/[^/]+/fork$})
+            session_id = path.sub("/api/sessions/", "").sub("/fork", "")
+            api_fork_session(session_id, req, res)
           elsif method == "DELETE" && path.start_with?("/api/sessions/")
             session_id = path.sub("/api/sessions/", "")
             api_delete_session(session_id, res)
@@ -610,6 +615,7 @@ module Clacky
         limit   = [query["limit"].to_i.then { |n| n > 0 ? n : 20 }, 50].min
         before  = query["before"].to_s.strip.then  { |v| v.empty? ? nil : v }
         q       = query["q"].to_s.strip.then       { |v| v.empty? ? nil : v }
+        q_scope = query["q_scope"].to_s.strip.then { |v| %w[name content].include?(v) ? v : "name" }
         date    = query["date"].to_s.strip.then    { |v| v.empty? ? nil : v }
         type    = query["type"].to_s.strip.then    { |v| v.empty? ? nil : v }
         # Backward-compat: ?source=<x> and ?profile=coding → type
@@ -620,7 +626,7 @@ module Clacky
         # `registry.list` always returns ALL matching pinned rows first (on the
         # first page; `before` == nil), followed by non-pinned rows up to `limit+1`.
         # So has_more is determined by whether the non-pinned section overflowed.
-        sessions = @registry.list(limit: limit + 1, before: before, q: q, date: date, type: type)
+        sessions = @registry.list(limit: limit + 1, before: before, q: q, q_scope: q_scope, date: date, type: type)
 
         # Split pinned vs non-pinned to apply has_more only to the non-pinned tail.
         pinned_part, non_pinned_part = sessions.partition { |s| s[:pinned] }
@@ -935,6 +941,9 @@ module Clacky
             api_key_masked: entry ? mask_api_key(entry["api_key"]) : nil,
             provider:   state["provider"],
             available:  state["available"],
+            aliases:    state["aliases"] || {},
+            stale:      state["stale"] || false,
+            requested_model: state["requested_model"],
             configured: state["configured"]
           }
         end
@@ -952,7 +961,8 @@ module Clacky
           defaults[t] = {
             provider:  provider_id,
             model:     provider_id ? Clacky::Providers.default_media_model(provider_id, t) : nil,
-            available: provider_id ? Clacky::Providers.media_models(provider_id, t) : []
+            available: provider_id ? Clacky::Providers.media_models(provider_id, t) : [],
+            aliases:   provider_id ? Clacky::Providers.media_model_aliases(provider_id, t) : {}
           }
         end
 
@@ -965,6 +975,85 @@ module Clacky
       # off / auto — remove any custom entry; "auto" lets the virtual
       # derivation in AgentConfig#find_model_by_type take over.
       # custom — replace any existing custom entry with the supplied fields.
+      # POST /api/config/media/test
+      # Body: { kind, source, model, base_url, api_key }
+      # Lightweight preflight: GET <base_url>/models to verify connectivity,
+      # auth, and that the requested model is exposed by the endpoint.
+      # No image is generated — zero cost, sub-second.
+      def api_test_media_config(req, res)
+        body = parse_json_body(req) || {}
+        kind = body["kind"].to_s
+        return json_response(res, 422, { error: "invalid kind" }) unless %w[image video audio].include?(kind)
+        return json_response(res, 422, { error: "only image kind supported" }) unless kind == "image"
+
+        api_key = body["api_key"].to_s
+        if api_key.empty? || api_key.include?("****")
+          existing = @agent_config.find_model_by_type(kind) || {}
+          api_key = existing["api_key"].to_s
+        end
+
+        model    = body["model"].to_s.strip
+        base_url = body["base_url"].to_s.strip
+
+        if model.empty? || base_url.empty? || api_key.empty?
+          return json_response(res, 200, { ok: false, message: "model, base_url, api_key are required" })
+        end
+
+        result = preflight_media_endpoint(base_url: base_url, api_key: api_key, model: model)
+        json_response(res, 200, result)
+      rescue => e
+        json_response(res, 200, { ok: false, message: e.message })
+      end
+
+      private def preflight_media_endpoint(base_url:, api_key:, model:)
+        url = "#{base_url.chomp("/")}/models"
+        conn = Faraday.new(url: url) do |f|
+          f.options.timeout      = 10
+          f.options.open_timeout = 5
+        end
+
+        response =
+          begin
+            conn.get do |req|
+              req.headers["Authorization"] = "Bearer #{api_key}"
+              req.headers["Accept"]        = "application/json"
+            end
+          rescue Faraday::Error => e
+            return { ok: false, message: "Network error: #{e.message}" }
+          end
+
+        case response.status
+        when 401, 403
+          return { ok: false, message: "Authentication failed (HTTP #{response.status}). Check API key." }
+        when 404
+          return { ok: false, message: "Endpoint not found at #{url}. Check Base URL." }
+        end
+
+        unless response.success?
+          return { ok: false, message: "HTTP #{response.status}: #{response.body.to_s[0, 200]}" }
+        end
+
+        body = JSON.parse(response.body) rescue nil
+        ids =
+          if body.is_a?(Hash) && body["data"].is_a?(Array)
+            body["data"].map { |m| m["id"].to_s }
+          elsif body.is_a?(Array)
+            body.map { |m| m["id"].to_s }
+          else
+            []
+          end
+
+        if ids.empty?
+          return { ok: true, message: "Connected (model list unavailable; cannot verify model id)" }
+        end
+
+        if ids.include?(model)
+          { ok: true, message: "Connected. Model '#{model}' is available." }
+        else
+          { ok: false, message: "Connected, but model '#{model}' not found on this endpoint." }
+        end
+      end
+
       def api_update_media_config(kind, req, res)
         body = parse_json_body(req) || {}
         source = body["source"].to_s
@@ -974,7 +1063,23 @@ module Clacky
 
         @agent_config.models.reject! { |m| m["type"] == kind }
 
-        if source == "custom"
+        case source
+        when "off"
+          @agent_config.models << {
+            "id"       => SecureRandom.uuid,
+            "type"     => kind,
+            "disabled" => true
+          }
+        when "auto"
+          override = body["model"].to_s.strip
+          unless override.empty?
+            @agent_config.models << {
+              "id"    => SecureRandom.uuid,
+              "type"  => kind,
+              "model" => override
+            }
+          end
+        when "custom"
           model    = body["model"].to_s.strip
           base_url = body["base_url"].to_s.strip
           api_key  = body["api_key"].to_s
@@ -4201,6 +4306,15 @@ module Clacky
         json_response(res, 500, { error: e.message })
       end
 
+      def api_fork_session(session_id, req, res)
+        fork_data = @session_manager.fork(session_id)
+        return json_response(res, 404, { error: "Session not found" }) unless fork_data
+
+        fork_id = fork_data[:session_id]
+        broadcast_session_update(fork_id)
+        json_response(res, 201, { session: @registry.snapshot(fork_id) })
+      end
+
       def api_delete_session(session_id, res)
         # A session exists if it's either in the runtime registry OR on disk.
         # Old sessions that were never restored into memory this server run

data/lib/clacky/server/session_registry.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "set"
+
 module Clacky
   module Server
     # SessionRegistry is the single authoritative source for session state.
@@ -158,7 +160,7 @@ module Clacky
       #   [ ...all_pinned_matching (newest-first), ...non_pinned (newest-first, limited) ]
       #
       # source and profile are orthogonal — either can be nil independently.
-      def list(limit: nil, before: nil, q: nil, date: nil, type: nil, include_pinned: true)
+      def list(limit: nil, before: nil, q: nil, q_scope: "name", date: nil, type: nil, include_pinned: true)
         return [] unless @session_manager
 
         live = @mutex.synchronize do
@@ -195,13 +197,25 @@ module Clacky
         # ── date filter (YYYY-MM-DD, matches created_at prefix) ──────────────
         all = all.select { |s| s[:created_at].to_s.start_with?(date) } if date
 
-        # ── name / id search ─────────────────────────────────────────────────
+        # ── name / id / content search ───────────────────────────────────────
+        content_snippets = nil
         if q && !q.empty?
-          q_down = q.downcase
-          all = all.select { |s|
-            (s[:name] || "").downcase.include?(q_down) ||
-              (s[:session_id] || "").downcase.include?(q_down)
-          }
+          if q_scope == "content"
+            content_snippets = @session_manager.search_content(q)
+            if content_snippets.empty?
+              all = []
+            else
+              prefix_set = content_snippets.keys.to_set
+              all = all.select { |s| prefix_set.include?((s[:session_id] || "")[0, 8]) }
+            end
+          else
+            q_down = q.downcase
+            id_match_eligible = q_down.match?(/\A[0-9a-f]{6,}\z/)
+            all = all.select { |s|
+              (s[:name] || "").downcase.include?(q_down) ||
+                (id_match_eligible && (s[:session_id] || "").downcase.include?(q_down))
+            }
+          end
         end
 
         # ── Split pinned vs non-pinned BEFORE applying `before`/`limit`.
@@ -223,7 +237,15 @@ module Clacky
 
         ordered = pinned_section + non_pinned
 
-        ordered.map { |s| build_enriched_row(s, live[s[:session_id]]) }
+        ordered.map do |s|
+          row = build_enriched_row(s, live[s[:session_id]])
+          if content_snippets
+            short = (s[:session_id] || "")[0, 8]
+            snip = content_snippets[short]
+            row[:search_snippet] = snip if snip
+          end
+          row
+        end
       end
 
       # Return the same enriched hash that a `list` row would produce, for a

data/lib/clacky/server/web_ui_controller.rb

@@ -171,7 +171,6 @@ module Clacky
 
       def show_diff(old_content, new_content, max_lines: 50)
         emit("diff", old_size: old_content.bytesize, new_size: new_content.bytesize)
-        # Diffs are too verbose for IM — intentionally not forwarded
       end
 
       def show_token_usage(token_data)
@@ -210,6 +209,27 @@ module Clacky
         forward_to_subscribers { |sub| sub.show_warning(message) }
       end
 
+      # === Phase grouping ===
+
+      def phase_start(kind:, label: nil)
+        pid = SecureRandom.uuid
+        Thread.current[:clacky_phase_id] = pid
+        # Emit without auto-injection (the start event itself defines the phase)
+        event = { type: "phase_start", session_id: @session_id, phase_id: pid, kind: kind.to_s }
+        event[:label] = label if label
+        @broadcaster.call(@session_id, event)
+        pid
+      end
+
+      def phase_end(phase_id, summary: nil)
+        # Clear thread-local before emitting end so the end event itself
+        # doesn't get tagged with the phase_id it's closing.
+        Thread.current[:clacky_phase_id] = nil if Thread.current[:clacky_phase_id] == phase_id
+        event = { type: "phase_end", session_id: @session_id, phase_id: phase_id }
+        event[:summary] = summary if summary
+        @broadcaster.call(@session_id, event)
+      end
+
       def show_error(message, code: nil, top_up_url: nil)
         payload = { message: message }
         payload[:code] = code if code
@@ -414,6 +434,9 @@ module Clacky
 
       def emit(type, **data)
         event = { type: type, session_id: @session_id }.merge(data)
+        if (pid = Thread.current[:clacky_phase_id]) && !data.key?(:phase_id)
+          event[:phase_id] = pid
+        end
         @broadcaster.call(@session_id, event)
       end