openclacky 1.5.6 → 1.5.7

data/lib/clacky/web/index.html

@@ -156,14 +156,14 @@
           </div>
         </div>
 
-        <!-- Cron view header (hidden by default, shown when viewing cron sessions) -->
-        <div id="cron-view-header" class="sidebar-divider" style="display:none">
-          <button id="btn-cron-back" class="btn-icon-sm" title="Back" aria-label="Back to session list">
+        <!-- Folded group sub-view header (hidden by default; title filled by Sessions) -->
+        <div id="group-view-header" class="sidebar-divider" style="display:none">
+          <button id="btn-group-back" class="btn-icon-sm" title="Back" aria-label="Back to session list">
             <svg width="14" height="14" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
               <path d="M10 3L5 8l5 5" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"/>
             </svg>
           </button>
-          <span data-i18n="sessions.cronGroup">Scheduled Tasks</span>
+          <span data-group-title></span>
           <span></span><!-- spacer -->
         </div>
 
@@ -1079,10 +1079,12 @@
               <div class="settings-network-url">
                 <label class="settings-network-url-label" for="settings-search-provider" data-i18n="settings.search.provider">Provider</label>
                 <div class="settings-network-url-row">
-                  <select id="settings-search-provider" class="field-input">
+                  <select id="settings-search-provider" class="field-select">
                     <option value="" data-i18n="settings.search.builtin">Built-in (DuckDuckGo / Bing)</option>
                   </select>
+                  <button type="button" id="btn-save-search" class="btn-settings-action" data-i18n="settings.search.save">Save</button>
                 </div>
+                <div id="settings-search-status" class="model-test-result"></div>
               </div>
               <div class="settings-network-url" id="search-key-wrap" style="display:none">
                 <label class="settings-network-url-label" for="settings-search-key" data-i18n="settings.search.key">API Key</label>
@@ -1091,12 +1093,6 @@
                   <button type="button" id="btn-test-search" class="btn-settings-action" data-i18n="settings.search.test">Test</button>
                 </div>
               </div>
-              <div class="settings-network-url">
-                <div class="settings-network-url-row">
-                  <button type="button" id="btn-save-search" class="btn-settings-action" data-i18n="settings.search.save">Save</button>
-                </div>
-                <div id="settings-search-status" class="model-test-result"></div>
-              </div>
               <p class="settings-network-desc" data-i18n="settings.search.custom">Add your own provider by dropping a script into ~/.clacky/searchers/ — see tavily.rb for the interface.</p>
             </div>
           </section>

data/lib/clacky/web/projects.js

@@ -287,6 +287,8 @@ const Projects = (() => {
           });
           const data = await res.json();
           if (res.ok && data.session) {
+            Sessions.add(data.session);
+            renderSection();
             Sessions.select(data.session.id);
           }
         } catch (err) {
@@ -540,6 +542,7 @@ const Projects = (() => {
     };
 
     addItem("projects.menu.edit", "Edit", false, () => promptEdit(projectId));
+    addItem("projects.menu.deleteSessions", "Delete Sessions", false, () => promptDeleteSessions(projectId));
     addItem("projects.menu.delete", "Delete",  true,  () => promptDelete(projectId));
 
     // Position near anchor
@@ -1079,6 +1082,29 @@ const Projects = (() => {
     }
   }
 
+  /** Confirm and delete all sessions in a project (keeps the project itself). */
+  async function promptDeleteSessions(id) {
+    const project = find(id);
+    if (!project) return;
+
+    const confirmed = await Modal.confirm(
+      I18n.t("projects.deleteSessions.confirm", { name: project.name })
+    );
+    if (!confirmed) return;
+
+    try {
+      const res  = await fetch(`/api/projects/${id}/sessions`, { method: "DELETE" });
+      const data = await res.json();
+      if (!res.ok) throw new Error(data.error || "Failed to delete sessions");
+
+      Sessions.removeByProjectId(id);
+      Sessions.renderList();
+      renderSection();
+    } catch (err) {
+      console.error("[Projects] delete sessions error:", err);
+    }
+  }
+
   /** Confirm and delete a project. */
   async function promptDelete(id) {
     const project = find(id);

data/lib/clacky/web/sessions.js

@@ -39,19 +39,50 @@ const Sessions = (() => {
   // { nameIds: Set<id>, contentIds: Set<id>, contentLoaded: bool }
   let   _searchSplit       = null;
   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
-  // all cron sessions can be loaded even when they're sparse across the mixed
-  // outer pages. Cron rows fetched here are pushed into the shared `_sessions`
-  // array (with dedup), so WS updates / patch / remove keep working unchanged;
-  // we only track a separate cursor + hasMore/loading flags for the sub-view.
-  let   _cronBefore        = null;   // cursor: oldest cron created_at loaded into the sub-view
-  let   _cronHasMore       = false;  // are there older cron sessions to load?
-  let   _cronLoadingMore   = false;
+  // ── Folded sidebar groups (cron / ext) ───────────────────────────────────
+  // Sessions whose `source` matches a folded group are pulled out of the main
+  // sidebar list and represented by a single virtual entry that opens a
+  // sub-view. Each group paginates *independently* of the outer list so that
+  // "Load more" inside a sub-view never advances the outer list's cursor, and
+  // so all of a group's sessions can be loaded even when they're sparse across
+  // the mixed outer pages. Rows fetched here are pushed into the shared
+  // `_sessions` array (with dedup), so WS updates / patch / remove keep working
+  // unchanged; only the cursor + hasMore/loading flags are per-group.
+  //
+  // Sessions assigned to a project never count toward a group — they render in
+  // the project section instead.
+  const GROUP_SOURCES = ["cron", "ext"];
+  const _groups = new Map(GROUP_SOURCES.map(source => [source, {
+    count: 0,               // total sessions in this group (server-side, unpaginated)
+    latestUpdatedAt: null,  // newest activity — decides the virtual entry's sort position
+    before: null,           // cursor: oldest activity time loaded into the sub-view
+    hasMore: false,
+    loadingMore: false,
+  }]));
+  let   _groupView         = null;   // source of the group sub-view we're in, or null
+  const SOURCE_BADGE_KEYS = {
+    cron:    "sessions.badge.cron",
+    ext:     "sessions.badge.ext",
+    channel: "sessions.badge.channel",
+    setup:   "sessions.badge.setup",
+  };
+  const GROUP_ICONS = { cron: "📋", ext: "🧩" };
+
+  // Group a session belongs to, or null when it renders in the main list.
+  // Project-assigned sessions always render in the project section.
+  const _groupOf = s => (s && !s.project_id && _groups.get(s.source)) || null;
+
+  // Merge server-reported group stats (REST/WS `groups` payload) into local state.
+  function _applyGroupStats(stats) {
+    if (!stats) return;
+    _groups.forEach((g, source) => {
+      const s = stats[source];
+      if (!s) return;
+      if (s.count != null) g.count = s.count;
+      if (s.latest_updated_at) g.latestUpdatedAt = s.latest_updated_at;
+    });
+  }
+
   let   _pendingRunTaskId  = null;  // session_id waiting to send "run_task" after subscribe
   let   _pendingMessage    = null;  // { session_id, content } — slash command to send after subscribe
   // Buffer for tool_stdout lines that arrive before history has finished rendering.
@@ -1358,6 +1389,17 @@ const Sessions = (() => {
     // historyCtx = { group: DOMElement|null, lastItem: DOMElement|null }
     if (!historyCtx) historyCtx = { group: null, lastItem: null };
 
+    // Custom extension events replayed from history. The host draws nothing;
+    // forwarding them to the ext bus lets an extension panel rebuild the state
+    // it had built from the live events before the reload.
+    if (typeof ev.type === "string" && ev.type.startsWith("ext.")) {
+      if (window.Clacky && Clacky.ext) {
+        const sid = ev.session_id;
+        Clacky.ext.emit(ev.type, { sessionId: sid, ...ev, replayed: true });
+      }
+      return;
+    }
+
     switch (ev.type) {
       case "history_user_message": {
         // Collapse any open tool group from the previous round
@@ -2126,13 +2168,13 @@ const Sessions = (() => {
   }
 
   // Build the unified load-more button.
-  function _makeLoadMoreBtn(cron = false) {
+  function _makeLoadMoreBtn(groupSource = null) {
     const btn = document.createElement("button");
     btn.className   = "btn-load-more-sessions";
-    const loading   = cron ? _cronLoadingMore : _loadingMore;
+    const loading   = groupSource ? _groups.get(groupSource).loadingMore : _loadingMore;
     btn.disabled    = loading;
     btn.textContent = loading ? I18n.t("sessions.loadingMore") : I18n.t("sessions.loadMore");
-    btn.onclick = () => cron ? Sessions.loadMoreCron() : Sessions.loadMore();
+    btn.onclick = () => groupSource ? Sessions.loadMoreGroup(groupSource) : Sessions.loadMore();
     return btn;
   }
 
@@ -2205,10 +2247,7 @@ const Sessions = (() => {
     // because source is "how the session was created" and coding is "what
     // agent runs inside". Using a muted badge for coding avoids drawing
     // attention away from the running-state dot, which is more important.
-    const badgeKey = s.source === "cron"    ? "sessions.badge.cron"
-                   : s.source === "channel" ? "sessions.badge.channel"
-                   : s.source === "setup"   ? "sessions.badge.setup"
-                   : null;
+    const badgeKey = SOURCE_BADGE_KEYS[s.source] || null;
     const badgeHtml = badgeKey
       ? `<span class="session-badge session-badge--${s.source}">${I18n.t(badgeKey)}</span>`
       : "";
@@ -2285,52 +2324,56 @@ const Sessions = (() => {
     container.appendChild(el);
   }
 
-  // ── Cron group entry (renders the folded "Scheduled Tasks" entry) ─────
+  // ── Folded group entry (e.g. "Scheduled Tasks" / "Extensions") ────────
   // `hasRunning` mirrors a normal session's status dot: show the green
-  // (running) dot only when any folded cron session is currently running,
-  // and render no dot at all when the group is idle.
-  function _renderCronGroupItem(container, count, hasRunning = false) {
+  // (running) dot only when any folded session in the group is currently
+  // running, and render no dot at all when the group is idle.
+  function _renderGroupItem(container, source, count, hasRunning = false) {
     const el = document.createElement("div");
-    el.className = "session-item cron-group-item";
+    el.className = `session-item group-item group-item--${source}`;
     const dotHtml = hasRunning ? `<span class="session-dot dot-running"></span>` : "";
     el.innerHTML = `
       <div class="session-body">
         <div class="session-name">
           ${dotHtml}
-          <span class="session-name__text">📋 ${I18n.t("sessions.cronGroup")} (${count})</span>
+          <span class="session-name__text">${GROUP_ICONS[source]} ${I18n.t(`sessions.group.${source}`)} (${count})</span>
         </div>
-        <div class="session-meta">${I18n.t("sessions.cronGroupMeta", { n: count })}</div>
+        <div class="session-meta">${I18n.t("sessions.groupMeta", { n: count })}</div>
       </div>
     `;
     el.onclick = () => {
-      _cronView = true;
+      _groupView = source;
       Sessions.renderList();
-      // Method A: always (re-)load the freshest first page of cron sessions
-      // on entering the sub-view. Independent cursor — never touches the
-      // outer list's pagination.
-      Sessions.loadMoreCron({ reset: true });
+      // Always (re-)load the freshest first page on entering the sub-view.
+      // Independent cursor — never touches the outer list's pagination.
+      Sessions.loadMoreGroup(source, { reset: true });
     };
     container.appendChild(el);
   }
 
   // ── Chat-section header visibility ────────────────────────────────────
-  function _updateChatHeader(isCronView) {
+  function _updateChatHeader(groupSource) {
     const chatSection   = document.getElementById("chat-section");
     if (!chatSection) return;
 
     const normalHeader  = chatSection.querySelector(":scope > .sidebar-divider:first-of-type");
-    const cronHeader    = document.getElementById("cron-view-header");
+    const groupHeader   = document.getElementById("group-view-header");
 
-    if (isCronView) {
+    if (groupSource) {
       if (normalHeader) normalHeader.style.display = "none";
-      if (cronHeader)   cronHeader.style.display   = "";
+      if (groupHeader) {
+        groupHeader.style.display = "";
+        const title = groupHeader.querySelector("[data-group-title]");
+        if (title) title.textContent = `${GROUP_ICONS[groupSource]} ${I18n.t(`sessions.group.${groupSource}`)}`;
+      }
     } else {
       if (normalHeader) normalHeader.style.display = "";
-      if (cronHeader)   cronHeader.style.display   = "none";
+      if (groupHeader)  groupHeader.style.display  = "none";
     }
   }
 
 
+
   // ── Public API ─────────────────────────────────────────────────────────
   return {
     get all()        { return _sessions; },
@@ -2400,10 +2443,10 @@ const Sessions = (() => {
       // Re-render session list (badges/labels) when the user switches language
       document.addEventListener("langchange", () => Sessions.renderList());
 
-      // Cron view back button
-      document.getElementById("btn-cron-back")
+      // Group sub-view back button
+      document.getElementById("btn-group-back")
         .addEventListener("click", () => {
-          _cronView = false;
+          _groupView = null;
           Sessions.renderList();
         });
 
@@ -2453,19 +2496,20 @@ const Sessions = (() => {
     // ── List management ───────────────────────────────────────────────────
 
     /** Populate list from initial session_list WS event (connect only). */
-    setAll(list, hasMore = false, cronCount = 0, latestCronUpdatedAt = null) {
+    setAll(list, hasMore = false, groups = {}) {
       _sessions.length = 0;
       _sessions.push(...list);
-      _hasMore              = !!hasMore;
-      _cronCount            = cronCount;
-      _latestCronUpdatedAt  = latestCronUpdatedAt || null;
+      _hasMore = !!hasMore;
+      _groups.forEach(g => { g.count = 0; g.latestUpdatedAt = null; });
+      _applyGroupStats(groups);
     },
 
     /** Insert a newly created session into the local list. */
     add(session) {
       if (!_sessions.find(s => s.id === session.id)) {
         _sessions.push(session);
-        if (session.source === "cron") _cronCount++;
+        const g = _groupOf(session);
+        if (g) g.count++;
       }
     },
 
@@ -2500,26 +2544,34 @@ const Sessions = (() => {
      *  prepend it so the sidebar shows it immediately. */
     patch(id, fields) {
       const s = _sessions.find(s => s.id === id);
+      const extra = _extraSessions.find(e => e.id === id);
+      const before = s || extra;
+      const wasGroup = _groupOf(before);
+
       if (s) {
         Object.assign(s, fields);
       } else {
         // _extraSessions keeps the session findable without inserting it into
         // _sessions, which would pollute the loadMore cursor (sessions outside
         // the current page must not affect the pagination boundary).
-        const extra = _extraSessions.find(e => e.id === id);
         if (extra) {
           Object.assign(extra, fields);
         } else {
           _extraSessions.push({ id, ...fields });
         }
       }
-      // Keep _latestCronUpdatedAt current when a cron session is patched/added.
-      const updated = _sessions.find(s => s.id === id)
-                   || _extraSessions.find(e => e.id === id);
-      if (updated?.source === "cron") {
+
+      const updated = s || _extraSessions.find(e => e.id === id);
+      const isGroup = _groupOf(updated);
+      if (wasGroup !== isGroup) {
+        if (wasGroup) wasGroup.count = Math.max(0, wasGroup.count - 1);
+        if (isGroup)  isGroup.count++;
+      }
+
+      if (isGroup) {
         const t = updated.updated_at || updated.created_at;
-        if (t && (!_latestCronUpdatedAt || t > _latestCronUpdatedAt)) {
-          _latestCronUpdatedAt = t;
+        if (t && (!isGroup.latestUpdatedAt || t > isGroup.latestUpdatedAt)) {
+          isGroup.latestUpdatedAt = t;
         }
       }
     },
@@ -2528,7 +2580,8 @@ const Sessions = (() => {
     remove(id) {
       const idx = _sessions.findIndex(s => s.id === id);
       if (idx !== -1) {
-        if (_sessions[idx].source === "cron") _cronCount = Math.max(0, _cronCount - 1);
+        const g = _groupOf(_sessions[idx]);
+        if (g) g.count = Math.max(0, g.count - 1);
         _sessions.splice(idx, 1);
       }
       // Clean up per-session progress state (timer + DOM + logical state)
@@ -2571,17 +2624,17 @@ const Sessions = (() => {
       Sessions.renderList();
 
       try {
-        // 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.
+        // Cursor: oldest activity time of non-pinned, non-grouped sessions.
+        // Grouped sessions are excluded from the normal list pagination and
+        // have their own independent cursor in each sub-view.
         const oldest = _sessions.reduce((min, s) => {
-          if (s.pinned || s.source === "cron") return min;
+          if (s.pinned || _groupOf(s)) 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: "10", exclude_type: "cron" });
+        const params = new URLSearchParams({ limit: "10", exclude_type: GROUP_SOURCES.join(",") });
         if (oldest)          params.set("before", oldest);
         if (_filter.q)       params.set("q",    _filter.q);
         if (_filter.date)    params.set("date", _filter.date);
@@ -2594,9 +2647,8 @@ 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 ?? _cronCount;
-        if (data.latest_cron_updated_at) _latestCronUpdatedAt = data.latest_cron_updated_at;
+        _hasMore = !!data.has_more;
+        _applyGroupStats(data.groups);
       } catch (e) {
         console.error("loadMore error:", e);
       } finally {
@@ -2607,25 +2659,26 @@ const Sessions = (() => {
       }
     },
 
-    /** Cron sub-view pagination — independent cursor, does NOT touch the outer
-     *  list's `_hasMore` / `loadMore` cursor. Fetches the next page of cron
-     *  sessions (type=cron) and pushes them into the shared `_sessions` array
-     *  (deduped), so WS patch/remove/add keep working unchanged. Only the
-     *  sub-view's own cursor + flags advance. Pass `reset:true` to start over
-     *  from the newest cron page (used on entering the sub-view). */
-    async loadMoreCron({ reset = false } = {}) {
-      if (_cronLoadingMore) return;
-      if (!reset && !_cronHasMore) return;
-      _cronLoadingMore = true;
-      if (reset) { _cronBefore = null; _cronHasMore = false; }
+    /** Group sub-view pagination — independent cursor, does NOT touch the outer
+     *  list's `_hasMore` / `loadMore` cursor. Fetches the next page of the
+     *  group's sessions (type=<source>) and pushes them into the shared
+     *  `_sessions` array (deduped), so WS patch/remove/add keep working
+     *  unchanged. Only the sub-view's own cursor + flags advance. Pass
+     *  `reset:true` to start over from the newest page (used on entering it). */
+    async loadMoreGroup(source, { reset = false } = {}) {
+      const group = _groups.get(source);
+      if (!group || group.loadingMore) return;
+      if (!reset && !group.hasMore) return;
+      group.loadingMore = true;
+      if (reset) { group.before = null; group.hasMore = false; }
 
       const sidebarList = document.getElementById("sidebar-list");
       const savedScrollTop = sidebarList ? sidebarList.scrollTop : 0;
       Sessions.renderList();
 
       try {
-        const params = new URLSearchParams({ limit: "10", type: "cron" });
-        if (_cronBefore) params.set("before", _cronBefore);
+        const params = new URLSearchParams({ limit: "10", type: source });
+        if (group.before) params.set("before", group.before);
 
         const res  = await fetch(`/api/sessions?${params}`);
         if (!res.ok) return;
@@ -2635,7 +2688,7 @@ const Sessions = (() => {
         rows.forEach(s => {
           if (!_sessions.find(x => x.id === s.id)) _sessions.push(s);
         });
-        // Advance cursor to the oldest cron activity time in THIS batch
+        // Advance cursor to the oldest activity time in THIS batch
         // (exclude pinned — backend returns all pinned on the first page,
         // bypassing pagination, so their time must not drag the cursor back).
         const oldest = rows.reduce((min, s) => {
@@ -2644,13 +2697,13 @@ const Sessions = (() => {
           if (!t) return min;
           return (!min || t < min) ? t : min;
         }, null);
-        if (oldest) _cronBefore = oldest;
-        _cronHasMore = !!data.has_more;
-        if (data.cron_count != null) _cronCount = data.cron_count;
+        if (oldest) group.before = oldest;
+        group.hasMore = !!data.has_more;
+        _applyGroupStats(data.groups);
       } catch (e) {
-        console.error("loadMoreCron error:", e);
+        console.error("loadMoreGroup error:", e);
       } finally {
-        _cronLoadingMore = false;
+        group.loadingMore = false;
         Sessions.renderList();
         if (sidebarList) sidebarList.scrollTop = savedScrollTop;
       }
@@ -2995,59 +3048,56 @@ const Sessions = (() => {
         .filter(s => !s.project_id)
         .sort(byPinnedAndTime);
 
-      // ── Split cron vs non-cron for folding ───────────────────────────
-      const isCronView      = _cronView;
-      const cronSessions    = visible.filter(s => s.source === "cron");
-
-      // Update chat-section header based on view mode
-      _updateChatHeader(isCronView);
+      // ── Fold grouped sources (cron / ext) out of the main list ────────
+      _updateChatHeader(_groupView);
 
       const list = $("session-list");
       list.innerHTML = "";
 
-      if (isCronView) {
+      if (_groupView) {
         // We never call the outer loadMore() here, so the outer list's cursor
         // is left untouched. While the first page is in flight and nothing is
         // loaded yet, show a loading placeholder instead of the empty state.
-        if (cronSessions.length === 0 && _cronLoadingMore) {
-          list.innerHTML = `<div class="session-empty">${I18n.t("sessions.cronLoading")}</div>`;
+        const rows = visible.filter(s => s.source === _groupView);
+        if (rows.length === 0 && _groups.get(_groupView).loadingMore) {
+          list.innerHTML = `<div class="session-empty">${I18n.t("sessions.groupLoading")}</div>`;
           return;
         }
-        cronSessions.forEach(s => _renderSessionItem(list, s));
-      } else if (_cronCount > 0) {
-        // 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;
-
-        nonCron.forEach(s => {
-          if (!cronEntryRendered && !s.pinned && _latestCronUpdatedAt) {
-            const t = s.updated_at || s.created_at;
-            if (!t || t < _latestCronUpdatedAt) {
-              _renderCronGroupItem(list, _cronCount, cronHasRunning);
-              cronEntryRendered = true;
-            }
-          }
+        rows.forEach(s => _renderSessionItem(list, s));
+      } else {
+        // Each non-empty group gets one virtual entry, positioned by its latest
+        // activity: walk the ungrouped rows newest-first and flush any entry
+        // that is newer than the row about to be rendered.
+        const pending = GROUP_SOURCES
+          .filter(source => _groups.get(source).count > 0)
+          .sort((a, b) => (_groups.get(b).latestUpdatedAt || "").localeCompare(_groups.get(a).latestUpdatedAt || ""));
+
+        const shouldFlush = (source, s) => {
+          const latest = _groups.get(source).latestUpdatedAt;
+          if (!latest || s.pinned) return false;
+          const t = s.updated_at || s.created_at;
+          return !t || t < latest;
+        };
+        const renderGroup = source => {
+          const hasRunning = _sessions.some(s => s.source === source && !s.project_id && s.status === "running");
+          _renderGroupItem(list, source, _groups.get(source).count, hasRunning);
+        };
+
+        visible.filter(s => !_groups.has(s.source)).forEach(s => {
+          while (pending.length && shouldFlush(pending[0], s)) renderGroup(pending.shift());
           _renderSessionItem(list, s);
         });
-        // Only append at the bottom when all pages are exhausted; otherwise
-        // the entry would show prematurely on the first page even though
-        // its time position is several pages deeper.
-        if (!cronEntryRendered && !_hasMore) {
-          _renderCronGroupItem(list, _cronCount, cronHasRunning);
-        }
-      } else {
-        // Normal list view, no cron sessions
-        visible.forEach(s => _renderSessionItem(list, s));
+        // Only append leftovers at the bottom when all pages are exhausted;
+        // otherwise an entry would show prematurely on the first page even
+        // though its time position is several pages deeper.
+        if (!_hasMore) pending.forEach(renderGroup);
       }
       if (list.children.length === 0) {
         list.innerHTML = `<div class="session-empty">${I18n.t("sessions.empty")}</div>`;
       }
 
-      if (isCronView) {
-        if (_cronHasMore) list.appendChild(_makeLoadMoreBtn(true));
+      if (_groupView) {
+        if (_groups.get(_groupView).hasMore) list.appendChild(_makeLoadMoreBtn(_groupView));
       } else if (_hasMore) {
         list.appendChild(_makeLoadMoreBtn());
       }
@@ -4190,8 +4240,8 @@ const Sessions = (() => {
       const sid = _activeId;
       const todos = (sid && Sessions._sessionTodos[sid]) || [];
 
-      // No active session or no todos → hide.
-      if (!sid || todos.length === 0) {
+      // No active session, no todos, or single todo → hide.
+      if (!sid || todos.length <= 1) {
         panel.style.display = "none";
         panel.innerHTML = "";
         return;

data/lib/clacky/web/settings.js

@@ -1403,6 +1403,7 @@ const Settings = (() => {
       const res  = await fetch("/api/config/search");
       const data = await res.json();
       if (data.ok) {
+        while (select.options.length > 1) select.remove(1);
         (data.available || []).forEach((name) => {
           const opt = document.createElement("option");
           opt.value = name;