openclacky 1.3.4 → 1.3.6

data/lib/clacky/web/sessions.js

@@ -41,6 +41,7 @@ const Sessions = (() => {
   let   _searchToken       = 0;       // monotonic counter; in-flight requests check against this
   let   _cronView          = false;  // are we in the cron sub-view?
   let   _cronCount         = 0;      // total cron sessions from server
+  let   _latestCronUpdatedAt = null; // updated_at of the newest cron session (for virtual entry sort position)
   // ── Cron sub-view independent pagination (commit 2) ──────────────────────
   // The folded cron sub-view paginates *independently* of the outer list so
   // that "Load more" inside it never advances the outer list's cursor, and so
@@ -411,42 +412,27 @@ const Sessions = (() => {
       _hideNewMessageBanner();
     });
 
-    // Detect actual user scroll interactions (wheel, touch, keyboard)
-    // These fire BEFORE the scroll event, so we can set the flag reliably.
-    const detectUserScroll = (e) => {
-      // Only flag if user is scrolling up (negative deltaY = scroll up)
-      // For wheel events: deltaY < 0 means scroll up
-      // For touch/keyboard: check scroll position in the scroll event
-      const isWheelUp = e.type === "wheel" && e.deltaY < 0;
-      const isKeyboardUp = e.type === "keydown" && (e.key === "ArrowUp" || e.key === "PageUp" || e.key === "Home");
-      
-      if (isWheelUp || isKeyboardUp) {
-        _userScrolledUp = true;
-      }
-    };
-
-    messages.addEventListener("wheel", detectUserScroll, { passive: true });
-    messages.addEventListener("keydown", detectUserScroll);
-    
-    // For touch devices: touchmove doesn't tell us direction, so check in scroll event
-    let touchStartY = 0;
-    messages.addEventListener("touchstart", (e) => {
-      touchStartY = e.touches[0].clientY;
-    }, { passive: true });
-    
-    messages.addEventListener("touchmove", (e) => {
-      const touchDeltaY = e.touches[0].clientY - touchStartY;
-      // touchDeltaY > 0 means finger moved down = content scrolls up
-      if (touchDeltaY > 5) {
-        _userScrolledUp = true;
-      }
-    }, { passive: true });
-
-    // Monitor scroll position: clear flag when user reaches bottom
+    // Single source of truth for "is the user browsing history?": the scroll
+    // position itself. Every scrolling method — mouse wheel, dragging the
+    // scrollbar, keyboard (Up/PageUp/Home/Space), touch swipe and momentum
+    // scrolling — funnels through the `scroll` event, so reading the position
+    // here covers them all with no blind spots.
+    //
+    // The previous approach instead listened to specific input events
+    // (wheel/keydown/touchmove) to *infer* intent. Dragging the scrollbar
+    // fires `scroll` but none of those, so it was never detected and AI
+    // messages kept yanking the view back to the bottom — see C-5629.
+    //
+    // Streaming-append safety: appending content grows scrollHeight but leaves
+    // scrollTop untouched (verified in-browser, even with overflow-anchor:auto),
+    // so a content update never moves us "away from bottom" and never trips a
+    // false positive here. The 150px threshold in _isAtBottom is extra slack.
     messages.addEventListener("scroll", () => {
       if (_isAtBottom(messages)) {
         _userScrolledUp = false;
         _hideNewMessageBanner();
+      } else {
+        _userScrolledUp = true;
       }
     });
   }
@@ -468,30 +454,26 @@ const Sessions = (() => {
     document.getElementById("btn-new-session-inline")
       .addEventListener("click", () => Sessions.create("general"));
 
-    // Split button: arrow (toggle dropdown)
-    document.getElementById("btn-new-session-arrow")
-      .addEventListener("click", (e) => {
-        e.stopPropagation();
-        const dd = document.getElementById("new-session-dropdown");
-        dd.hidden = !dd.hidden;
-      });
+    // Split button: arrow — show dropdown on hover, hide when leaving the whole wrap
+    const arrow = document.getElementById("btn-new-session-arrow");
+    const wrap  = arrow.closest(".btn-split-wrap");
+    const dd    = document.getElementById("new-session-dropdown");
+
+    arrow.addEventListener("mouseenter", () => { dd.hidden = false; });
+    dd.addEventListener("mouseenter",    () => { dd.hidden = false; });
+    wrap.addEventListener("mouseleave",  () => { dd.hidden = true; });
+    dd.addEventListener("mouseleave",    () => { dd.hidden = true; });
 
-    // Dropdown item "Advanced Options…" — delegated because the dropdown
-    // panel may be re-rendered; this keeps the binding stable.
+    // Dropdown item "Advanced Options…"
     document.addEventListener("click", (e) => {
       if (e.target && e.target.id === "btn-new-session-modal") {
-        e.stopPropagation();
-        document.getElementById("new-session-dropdown").hidden = true;
+        dd.hidden = true;
         Sessions.openNewSessionModal();
+      } else if (!wrap.contains(e.target)) {
+        dd.hidden = true;
       }
     });
 
-    // Close dropdown when clicking anywhere else
-    document.addEventListener("click", () => {
-      const dd = document.getElementById("new-session-dropdown");
-      if (dd && !dd.hidden) dd.hidden = true;
-    });
-
     // Welcome screen "+ New Session" button
     document.getElementById("btn-welcome-new")
       .addEventListener("click", () => Sessions.create("general"));
@@ -1404,6 +1386,7 @@ const Sessions = (() => {
         el.dataset.raw = ev.content || "";
         el.innerHTML = _renderMarkdown(ev.content || "");
         _appendCopyButton(el);
+        _enhanceTaskItems(el, ev.content || "");
         container.appendChild(el);
         break;
       }
@@ -1667,6 +1650,7 @@ const Sessions = (() => {
                   code: session.error_code,
                   message: session.error,
                   top_up_url: session.top_up_url,
+                  raw_message: session.raw_message,
                 });
               } else {
                 Sessions.appendMsg("error", session.error);
@@ -1925,6 +1909,78 @@ const Sessions = (() => {
     _ensureCopyDelegation();
   }
 
+  // System feature: any assistant message containing GFM task-list items
+  // (`- [ ] ...`) gets a "spawn" button on each UNCHECKED item, turning a
+  // todo into its own session. The new session's first prompt is the item
+  // text plus the full message for context.
+  function _stripThink(text) {
+    if (!text) return "";
+    return text.replace(/<think>[\s\S]*?<\/think>/g, "").replace(/^\s+/, "");
+  }
+
+  function _enhanceTaskItems(el, rawText) {
+    const seen = new Set();
+    const context = _stripThink(rawText);
+    el.querySelectorAll("li").forEach((li) => {
+      const box = li.querySelector('input[type="checkbox"]');
+      if (!box || box.checked) return;          // only unchecked todos
+      if (seen.has(li)) return;
+      seen.add(li);
+
+      const text = li.textContent.trim();
+      if (!text) return;
+
+      const btn = document.createElement("button");
+      btn.type = "button";
+      btn.className = "msg-todo-spawn";
+      btn.title = I18n.t("chat.todo.spawn");
+      btn.textContent = I18n.t("chat.todo.spawn");
+      btn.dataset.todoText = text;
+      btn.dataset.todoContext = context;
+      li.appendChild(btn);
+    });
+    _ensureTodoSpawnDelegation();
+  }
+
+  let _todoSpawnDelegationInstalled = false;
+  function _ensureTodoSpawnDelegation() {
+    if (_todoSpawnDelegationInstalled) return;
+    const messages = RenderTarget.outer();
+    if (!messages) return;
+    _todoSpawnDelegationInstalled = true;
+    messages.addEventListener("click", (e) => {
+      const btn = e.target.closest(".msg-todo-spawn");
+      if (!btn) return;
+      e.preventDefault();
+      e.stopPropagation();
+      _spawnFromTodo(btn);
+    });
+  }
+
+  async function _spawnFromTodo(btn) {
+    if (btn.disabled) return;
+    btn.disabled = true;
+    const original = btn.textContent;
+    btn.textContent = I18n.t("chat.todo.spawning");
+
+    const todoText = btn.dataset.todoText || "";
+    const context  = btn.dataset.todoContext || "";
+    const prompt =
+      `Task:\n${todoText}\n\n` +
+      `--- Context (the message this task came from) ---\n${context}`;
+
+    try {
+      await Sessions.startWith(prompt, {
+        name: todoText.slice(0, 60),
+        display: `📋 ${todoText}`,
+      });
+    } catch (err) {
+      btn.disabled = false;
+      btn.textContent = original;
+      alert(I18n.t("chat.todo.spawnFailed", { msg: err.message }));
+    }
+  }
+
   // Install the click-delegation listener on #messages exactly once.
   // Handles copy clicks for all current AND future assistant bubbles
   // AND code block copy buttons.
@@ -2323,11 +2379,12 @@ const Sessions = (() => {
     // ── List management ───────────────────────────────────────────────────
 
     /** Populate list from initial session_list WS event (connect only). */
-    setAll(list, hasMore = false, cronCount = 0) {
+    setAll(list, hasMore = false, cronCount = 0, latestCronUpdatedAt = null) {
       _sessions.length = 0;
       _sessions.push(...list);
-      _hasMore   = !!hasMore;
-      _cronCount = cronCount;
+      _hasMore              = !!hasMore;
+      _cronCount            = cronCount;
+      _latestCronUpdatedAt  = latestCronUpdatedAt || null;
     },
 
     /** Insert a newly created session into the local list. */
@@ -2338,6 +2395,36 @@ const Sessions = (() => {
       }
     },
 
+    // Create a session, queue a command to run once subscribed, and navigate to
+    // it. The user bubble is rendered locally on the "subscribed" event (see
+    // ws-dispatcher), so callers never touch history or WS timing.
+    // Returns the created session.
+    async startWith(command, { name, source = "setup", display = null } = {}) {
+      if (!name) {
+        const maxN = _sessions.reduce((max, s) => {
+          const m = s.name && s.name.match(/^Session (\d+)$/);
+          return m ? Math.max(max, parseInt(m[1], 10)) : max;
+        }, 0);
+        name = "Session " + (maxN + 1);
+      }
+
+      const res  = await fetch("/api/sessions", {
+        method:  "POST",
+        headers: { "Content-Type": "application/json" },
+        body:    JSON.stringify({ name, source }),
+      });
+      const data = await res.json();
+      if (!res.ok) throw new Error(data.error || "failed to create session");
+      const session = data.session;
+      if (!session) throw new Error("no session returned");
+
+      Sessions.add(session);
+      Sessions.renderList();
+      Sessions.setPendingMessage(session.id, command, display);
+      Sessions.select(session.id);
+      return session;
+    },
+
     /** Patch a single session's fields (from session_update event).
      *  If the session is not in the list yet (e.g. just created by another tab),
      *  prepend it so the sidebar shows it immediately. */
@@ -2348,6 +2435,14 @@ const Sessions = (() => {
       } else {
         _sessions.unshift({ id, ...fields });
       }
+      // Keep _latestCronUpdatedAt current when a cron session is patched/added.
+      const updated = _sessions.find(s => s.id === id);
+      if (updated?.source === "cron") {
+        const t = updated.updated_at || updated.created_at;
+        if (t && (!_latestCronUpdatedAt || t > _latestCronUpdatedAt)) {
+          _latestCronUpdatedAt = t;
+        }
+      }
     },
 
     /** Remove a session from the list (from session_deleted event). */
@@ -2375,21 +2470,17 @@ const Sessions = (() => {
       Sessions.renderList();
 
       try {
-        // Cursor: oldest activity time (updated_at, falling back to
-        // created_at) in the current list, EXCLUDING pinned sessions. The
-        // backend always returns ALL pinned sessions on the first page (they
-        // bypass pagination), so their time is irrelevant for the cursor.
-        // Including them here would cause the cursor to jump too far back and
-        // skip sessions between the oldest pinned one and the real
-        // last-loaded non-pinned row.
+        // Cursor: oldest activity time of non-pinned, non-cron sessions.
+        // Cron sessions are excluded from the normal list pagination and have
+        // their own independent cursor (_cronBefore) in the sub-view.
         const oldest = _sessions.reduce((min, s) => {
-          if (s.pinned) return min;                       // ignore pinned
+          if (s.pinned || s.source === "cron") return min;
           const t = s.updated_at || s.created_at;
           if (!t) return min;
           return (!min || t < min) ? t : min;
         }, null);
 
-        const params = new URLSearchParams({ limit: "20" });
+        const params = new URLSearchParams({ limit: "20", exclude_type: "cron" });
         if (oldest)          params.set("before", oldest);
         if (_filter.q)       params.set("q",    _filter.q);
         if (_filter.date)    params.set("date", _filter.date);
@@ -2402,8 +2493,9 @@ const Sessions = (() => {
         (data.sessions || []).forEach(s => {
           if (!_sessions.find(x => x.id === s.id)) _sessions.push(s);
         });
-        _hasMore   = !!data.has_more;
-        _cronCount = data.cron_count || 0;
+        _hasMore             = !!data.has_more;
+        _cronCount           = data.cron_count ?? _cronCount;
+        if (data.latest_cron_updated_at) _latestCronUpdatedAt = data.latest_cron_updated_at;
       } catch (e) {
         console.error("loadMore error:", e);
       } finally {
@@ -2799,35 +2891,28 @@ const Sessions = (() => {
         }
         cronSessions.forEach(s => _renderSessionItem(list, s));
       } else if (_cronCount > 0) {
-        // Normal list view: the cron group entry is a *virtual* row that
-        // participates in the time-ordering instead of being pinned to the
-        // top. We walk the already-sorted `visible` list and drop the group
-        // entry at the position of the newest (first-encountered) cron
-        // session — so it sits exactly where the latest folded cron task
-        // would sort by created_at. Pinning is intentionally ignored for the
-        // entry itself: a pinned cron session only takes effect *inside* the
-        // folded sub-view, not on the outer entry.
-        const cronHasRunning = cronSessions.some(s => s.status === "running");
+        // Normal list view: virtual cron group entry positioned by _latestCronUpdatedAt.
+        // Walk the sorted non-cron list and insert the entry at the first row
+        // whose time is older than the newest cron session's updated_at.
+        const cronHasRunning = _sessions.some(s => s.source === "cron" && s.status === "running");
+        const nonCron = visible.filter(s => s.source !== "cron");
         let cronEntryRendered = false;
-        visible.forEach(s => {
-          if (s.source === "cron") {
-            // Render the group entry once, at the first (newest) cron slot;
-            // skip every individual cron session in the flat list.
-            if (!cronEntryRendered) {
+
+        nonCron.forEach(s => {
+          if (!cronEntryRendered && _latestCronUpdatedAt) {
+            const t = s.updated_at || s.created_at;
+            if (!t || t < _latestCronUpdatedAt) {
               _renderCronGroupItem(list, _cronCount, cronHasRunning);
               cronEntryRendered = true;
             }
-            return;
           }
           _renderSessionItem(list, s);
         });
-        // NOTE: we intentionally do NOT append a fallback entry when no cron
-        // session is loaded yet. The group entry is a virtual row that must
-        // ride along with pagination: it only appears at the sort slot of the
-        // first loaded cron session. If the newest cron lives on a later page,
-        // the entry simply shows up once that page is loaded — rather than
-        // being forced onto the bottom of page 1 (which would mislead the
-        // sort position and miss the running state of an unpaged cron).
+        // If no insertion point found (all normal sessions are newer, or list is empty),
+        // append the entry at the bottom of the loaded rows.
+        if (!cronEntryRendered) {
+          _renderCronGroupItem(list, _cronCount, cronHasRunning);
+        }
       } else {
         // Normal list view, no cron sessions
         visible.forEach(s => _renderSessionItem(list, s));
@@ -3508,6 +3593,7 @@ const Sessions = (() => {
         el.dataset.raw = html || "";
         el.innerHTML = _renderMarkdown(html);
         _appendCopyButton(el);
+        _enhanceTaskItems(el, html || "");
       } else {
         el.innerHTML = html;
       }
@@ -3535,7 +3621,11 @@ const Sessions = (() => {
             });
             retryBtn.disabled = true;
           };
+          // Move any .error-raw-detail to after the retry button
+          const rawDetail = el.querySelector(".error-raw-detail");
+          if (rawDetail) el.removeChild(rawDetail);
           el.appendChild(retryBtn);
+          if (rawDetail) el.appendChild(rawDetail);
         }
         messages.appendChild(el);
       }
@@ -3928,8 +4018,8 @@ const Sessions = (() => {
     },
 
     /** Register a slash-command message to send after subscribe is confirmed. */
-    setPendingMessage(sessionId, content) {
-      _pendingMessage = { session_id: sessionId, content };
+    setPendingMessage(sessionId, content, display = null) {
+      _pendingMessage = { session_id: sessionId, content, display };
     },
 
     /** Consume and return the pending message (clears it). */

data/lib/clacky/web/settings.js

@@ -1508,6 +1508,7 @@ const Settings = (() => {
         _showBrandResult(true, I18n.t("settings.brand.activated", { name: data.product_name || "configured" }));
         // Apply brand name and logo across the entire UI immediately
         if (data.product_name) Brand.applyBrandName(data.product_name);
+        if (data.theme_color) _applyAccentColor(data.theme_color, { persist: true });
         Brand.clearBrandCache();
         Brand.applyHeaderLogo();
         // Refresh brand status flags (user_licensed may have flipped from false
@@ -1683,7 +1684,7 @@ const Settings = (() => {
   // The state object per kind:
   //   { source, configured, model, base_url, api_key_masked, provider, available }
 
-  const MEDIA_KINDS = ["image", "video", "audio", "ocr"];
+  const MEDIA_KINDS = ["image", "video", "audio", "stt", "video_understanding", "ocr"];
   let _mediaState = null;
   let _mediaDefaults = null;
   const _mediaCustomDraft = {};
@@ -2173,6 +2174,8 @@ const Settings = (() => {
           Brand.applyBrandName("OpenClacky");
           Brand.clearBrandCache();
           Brand.applyHeaderLogo();
+          const userAccent = (() => { try { return localStorage.getItem("clacky-accent-color"); } catch (_) { return null; } })();
+          _applyAccentColor(userAccent || ACCENT_DEFAULT, { persist: false });
           // Reset Skills panel state (hide Brand Skills tab, switch to My Skills)
           if (typeof Skills !== "undefined" && Skills.resetAfterUnbind) {
             Skills.resetAfterUnbind();
@@ -2203,6 +2206,7 @@ const Settings = (() => {
     _initLangBtns();
     _initFontBtns();
     _initCurrencyBtns();
+    _initAccentColorBtns();
 
     // Re-render model cards when language changes (dynamic HTML, not data-i18n)
     document.addEventListener("langchange", () => {
@@ -2364,6 +2368,34 @@ const Settings = (() => {
     });
   }
 
+  // ── Accent Color ──────────────────────────────────────────────────────
+  const ACCENT_STORAGE_KEY = "clacky-accent-color";
+  const ACCENT_DEFAULT     = "#4f46e5";
+
+  function _applyAccentColor(color, { persist = true } = {}) {
+    const root = document.documentElement;
+    root.style.setProperty("--color-accent-primary",       color);
+    root.style.setProperty("--color-accent-hover",         color);
+    root.style.setProperty("--color-button-primary",       color);
+    root.style.setProperty("--color-button-primary-hover", `color-mix(in srgb, ${color} 82%, #000)`);
+    if (persist) {
+      try { localStorage.setItem(ACCENT_STORAGE_KEY, color); } catch (_) {}
+    }
+    document.querySelectorAll("#accent-color-section .settings-accent-swatch").forEach(btn => {
+      btn.classList.toggle("active", btn.dataset.color === color);
+    });
+  }
+
+  function _initAccentColorBtns() {
+    let saved = null;
+    try { saved = localStorage.getItem(ACCENT_STORAGE_KEY); } catch (_) {}
+    _applyAccentColor(saved || ACCENT_DEFAULT, { persist: !!saved });
+
+    document.querySelectorAll("#accent-color-section .settings-accent-swatch").forEach(btn => {
+      btn.addEventListener("click", () => _applyAccentColor(btn.dataset.color));
+    });
+  }
+
   // ── QR Code Lightbox ───────────────────────────────────────────────────
   // Sets up click-to-enlarge behaviour for the support QR code.
   // Safe to call multiple times — idempotent via a data attribute guard.
@@ -2404,5 +2436,5 @@ const Settings = (() => {
     });
   }
 
-  return { open, init, loadBrand: _loadBrand };
+  return { open, init, loadBrand: _loadBrand, applyAccentColor: _applyAccentColor };
 })();

data/lib/clacky/web/ws-dispatcher.js

@@ -180,7 +180,7 @@ WS.onEvent(ev => {
 
     // ── Session list ───────────────────────────────────────────────────
     case "session_list": {
-      Sessions.setAll(ev.sessions || [], !!ev.has_more, ev.cron_count || 0);
+      Sessions.setAll(ev.sessions || [], !!ev.has_more, ev.cron_count || 0, ev.latest_cron_updated_at || null);
       Sessions.renderList();
 
       // Restore URL hash once on initial connect; ignore subsequent session_list events.
@@ -216,7 +216,7 @@ WS.onEvent(ev => {
       // send it now — after restoreFromHash has settled — so appendMsg won't be wiped.
       const pendingMsg = Sessions.takePendingMessage();
       if (pendingMsg && pendingMsg.session_id === ev.session_id) {
-        Sessions.appendMsg("user", escapeHtml(pendingMsg.content), { time: new Date() });
+        Sessions.appendMsg("user", escapeHtml(pendingMsg.display || pendingMsg.content), { time: new Date() });
         WS.send({ type: "message", session_id: pendingMsg.session_id, content: pendingMsg.content, lang: I18n.lang() });
       }
       break;
@@ -310,6 +310,9 @@ WS.onEvent(ev => {
       if (ev.session_id !== Sessions.activeId) break;
       Sessions.clearProgress();
       Sessions.appendMsg("assistant", ev.content);
+      if (window.Clacky && Clacky.ext) {
+        Clacky.ext.emit("session:assistant-message", { sessionId: ev.session_id, content: ev.content });
+      }
       break;
 
     case "tool_call":
@@ -442,10 +445,15 @@ function renderErrorEvent(ev) {
     const action = ev.top_up_url
       ? ` <a href="${escapeHtml(ev.top_up_url)}" target="_blank" rel="noopener noreferrer">${escapeHtml(I18n.t("error.insufficient_credit.action"))} →</a>`
       : "";
-    Sessions.appendMsg("error", `<span>${body}${action}</span>`);
+    Sessions.appendMsg("error", `<span>${body}${action}</span>${_buildRawDetail(ev.raw_message)}`);
     return;
   }
-  Sessions.appendMsg("error", escapeHtml(ev.message));
+  Sessions.appendMsg("error", escapeHtml(ev.message) + _buildRawDetail(ev.raw_message));
+}
+
+function _buildRawDetail(raw) {
+  if (!raw) return "";
+  return `<details class="error-raw-detail"><summary>${escapeHtml(I18n.t("error.show_detail"))}</summary><pre>${escapeHtml(raw)}</pre></details>`;
 }
 
 window.renderErrorEvent = renderErrorEvent;

data/lib/clacky.rb

@@ -155,20 +155,27 @@ require_relative "clacky/server/api_extension_dispatcher"
 
 module Clacky
   class AgentInterrupted < Exception; end  # Inherit from Exception to bypass rescue StandardError
-  class AgentError < StandardError; end
+  class AgentError < StandardError
+    attr_reader :raw_message
+
+    def initialize(message, raw_message: nil)
+      super(message)
+      @raw_message = raw_message
+    end
+  end
   class BadRequestError < AgentError
     attr_reader :display_message
 
-    def initialize(message, display_message: nil)
-      super(message)
+    def initialize(message, display_message: nil, raw_message: nil)
+      super(message, raw_message: raw_message)
       @display_message = display_message
     end
   end
   class InsufficientCreditError < AgentError
     attr_reader :error_code, :provider_id
 
-    def initialize(message, error_code: nil, provider_id: nil)
-      super(message)
+    def initialize(message, error_code: nil, provider_id: nil, raw_message: nil)
+      super(message, raw_message: raw_message)
       @error_code = error_code
       @provider_id = provider_id
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openclacky
 version: !ruby/object:Gem::Version
-  version: 1.3.4
+  version: 1.3.6
 platform: ruby
 authors:
 - windy
@@ -338,6 +338,7 @@ files:
 - lib/clacky/aes_gcm.rb
 - lib/clacky/agent.rb
 - lib/clacky/agent/cost_tracker.rb
+- lib/clacky/agent/fake_tool_call_detector.rb
 - lib/clacky/agent/hook_manager.rb
 - lib/clacky/agent/llm_caller.rb
 - lib/clacky/agent/memory_updater.rb
@@ -375,6 +376,10 @@ files:
 - lib/clacky/default_agents/coding/webui/.gitkeep
 - lib/clacky/default_agents/general/profile.yml
 - lib/clacky/default_agents/general/system_prompt.md
+- lib/clacky/default_extensions/meeting/handler.rb
+- lib/clacky/default_extensions/meeting/meeting.js
+- lib/clacky/default_extensions/meeting/meta.yml
+- lib/clacky/default_extensions/meeting/skills/meeting-summarizer/SKILL.md
 - lib/clacky/default_parsers/doc_parser.rb
 - lib/clacky/default_parsers/docx_parser.rb
 - lib/clacky/default_parsers/pdf_parser.rb
@@ -399,6 +404,7 @@ files:
 - lib/clacky/default_skills/extend-openclacky/SKILL.md
 - lib/clacky/default_skills/mcp-manager/SKILL.md
 - lib/clacky/default_skills/media-gen/SKILL.md
+- lib/clacky/default_skills/media-gen/scripts/video_seq.sh
 - lib/clacky/default_skills/new/SKILL.md
 - lib/clacky/default_skills/new/scripts/create_rails_project.sh
 - lib/clacky/default_skills/onboard/SKILL.md
@@ -449,6 +455,7 @@ files:
 - lib/clacky/message_format/bedrock.rb
 - lib/clacky/message_format/open_ai.rb
 - lib/clacky/message_history.rb
+- lib/clacky/null_ui_controller.rb
 - lib/clacky/openai_stream_aggregator.rb
 - lib/clacky/patch_loader.rb
 - lib/clacky/plain_ui_controller.rb