@jsonstudio/rcc 0.89.1803 → 0.89.1959

package/docs/daemon-admin-ui.html

@@ -376,6 +376,10 @@
         grid-template-columns: minmax(0, 1fr) minmax(0, 1.6fr);
       }
 
+      .grid.grid-clock {
+        grid-template-columns: minmax(0, 2.2fr) minmax(0, 0.8fr);
+      }
+
       .grid.grid-one {
         grid-template-columns: minmax(0, 1fr);
       }
@@ -465,6 +469,71 @@
         font-weight: 650;
       }
 
+      .table tr.clock-detail-row td {
+        background: rgba(255, 255, 255, 0.01);
+      }
+
+      .clock-group-toggle {
+        all: unset;
+        cursor: pointer;
+        display: block;
+        width: 100%;
+        white-space: normal;
+        line-height: 1.35;
+      }
+
+      .clock-group-summary {
+        margin-top: 4px;
+        font-size: 11px;
+        color: var(--muted);
+        white-space: normal;
+        overflow-wrap: anywhere;
+        line-height: 1.3;
+      }
+
+      .clock-detail-list {
+        display: flex;
+        flex-direction: column;
+        gap: 6px;
+        padding: 4px 0;
+      }
+
+      .clock-detail-item {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        min-width: 0;
+      }
+
+      .clock-detail-item .clock-detail-content {
+        min-width: 0;
+        flex: 1;
+        white-space: normal;
+        overflow-wrap: anywhere;
+        line-height: 1.3;
+      }
+
+      .table.table-clock-merged th:nth-child(1),
+      .table.table-clock-merged td:nth-child(1) {
+        width: 10%;
+      }
+      .table.table-clock-merged th:nth-child(2),
+      .table.table-clock-merged td:nth-child(2) {
+        width: 50%;
+      }
+      .table.table-clock-merged th:nth-child(3),
+      .table.table-clock-merged td:nth-child(3) {
+        width: 14%;
+      }
+      .table.table-clock-merged th:nth-child(4),
+      .table.table-clock-merged td:nth-child(4) {
+        width: 14%;
+      }
+      .table.table-clock-merged th:nth-child(5),
+      .table.table-clock-merged td:nth-child(5) {
+        width: 12%;
+      }
+
       .table tr.provider-row:hover td {
         background: rgba(78, 161, 255, 0.06);
       }
@@ -502,6 +571,19 @@
         justify-content: flex-end;
       }
 
+      .auth-actions {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 6px;
+      }
+
+      .auth-action-btn {
+        padding: 3px 8px;
+        font-size: 11px;
+        border-radius: 8px;
+        white-space: nowrap;
+      }
+
       .truncate {
         white-space: nowrap;
         overflow: hidden;
@@ -585,12 +667,19 @@
 
       .auth-mode-tabs {
         margin: 10px 0;
+        position: relative;
+        z-index: 2;
       }
 
       .auth-mode-tabs .tab {
         min-width: 120px;
       }
 
+      .auth-mode-panels {
+        position: relative;
+        z-index: 2;
+      }
+
       .log {
         white-space: pre-wrap;
         font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono",
@@ -639,6 +728,7 @@
             <div class="pill"><span id="statusDot" class="dot"></span><span id="statusText">connecting…</span></div>
             <div class="pill"><span class="mono" id="serverId">serverId: —</span></div>
             <div class="pill"><span class="mono" id="serverVersion">version: —</span></div>
+            <div class="pill"><span class="mono" id="clockOverviewText">clock: loading…</span></div>
             <button id="restartRuntimeBtn" class="primary">Restart runtime</button>
           </div>
         </header>
@@ -702,6 +792,7 @@
           <button class="tab" data-tab="credentials">Auth Provider Pool</button>
           <button class="tab" data-tab="quota">Quota Pool</button>
           <button class="tab" data-tab="routing">Runtime Routing Pool</button>
+          <button class="tab" data-tab="clock">Clock</button>
         </div>
 
         <section id="panelControl" data-panel="control" style="display:none;">
@@ -794,6 +885,59 @@
           </div>
         </section>
 
+        <section id="panelClock" data-panel="clock" style="display:none;">
+          <div class="grid grid-clock">
+            <div class="card" style="box-shadow: none;">
+              <p class="section-title">Clock tasks (merged)</p>
+              <p class="section-sub">Merged by content + recurrence + tool to reduce repeated rows. Expand a row to inspect per-time details.</p>
+              <div class="row" style="margin-bottom: 10px;">
+                <label for="clockSessionFilterInput">session filter</label>
+                <input id="clockSessionFilterInput" type="text" placeholder="conversation session id (optional)" style="min-width: 320px; flex: 1;" />
+                <button id="refreshClockBtn" class="primary">Refresh</button>
+                <span id="clockHint" class="muted" style="margin-left:auto; font-size:12px;"></span>
+              </div>
+              <div id="clockSummaryPills" class="row" style="margin-bottom: 10px;"></div>
+
+              <p class="section-title" style="margin-top: 8px;">Merged list</p>
+              <div class="table-wrap">
+                <table class="table table-clock-merged">
+                  <thead>
+                    <tr>
+                      <th>status</th>
+                      <th>task (foldable)</th>
+                      <th>next due</th>
+                      <th>time plan</th>
+                      <th>scope</th>
+                    </tr>
+                  </thead>
+                  <tbody id="clockMergedTbody"></tbody>
+                </table>
+              </div>
+            </div>
+
+            <div class="card" style="box-shadow: none;">
+              <p class="section-title">Clock daemon bindings</p>
+              <p class="section-sub">tmux daemon registry and heartbeat state used by clock injection.</p>
+              <div class="table-wrap">
+                <table class="table">
+                  <thead>
+                    <tr>
+                      <th>daemonId</th>
+                      <th>tmuxSession</th>
+                      <th>boundConversations</th>
+                      <th>heartbeat</th>
+                      <th>lastInject</th>
+                      <th>status</th>
+                      <th>lastError</th>
+                    </tr>
+                  </thead>
+                  <tbody id="clockDaemonsTbody"></tbody>
+                </table>
+              </div>
+            </div>
+          </div>
+        </section>
+
         <section id="panelProviders" data-panel="providers">
           <div class="grid grid-wide-left">
             <div class="card" style="box-shadow: none;">
@@ -1105,6 +1249,7 @@
                       <th>status</th>
                       <th>expires</th>
                       <th>secretRef</th>
+                      <th>action</th>
                     </tr>
                   </thead>
                   <tbody id="credentialsTbody"></tbody>
@@ -1202,7 +1347,7 @@
 		                <label for="quotaFilterInput">filter</label>
 		                <input id="quotaFilterInput" type="text" placeholder="providerKey contains…" style="width: 320px;" />
 		                <label><input id="quotaHideOkToggle" type="checkbox" /> hide ok</label>
-		                <label><input id="quotaOnlyRoutedTargetsToggle" type="checkbox" checked /> only routed targets</label>
+		                <label><input id="quotaOnlyRoutedTargetsToggle" type="checkbox" checked disabled /> routed models only</label>
                     <button id="quotaSelectVisibleBtn">Select visible</button>
                     <button id="quotaClearSelectionBtn">Clear selection</button>
                     <label><input id="quotaAutoRefreshToggle" type="checkbox" checked /> auto refresh</label>
@@ -1362,6 +1507,9 @@
               adminAuth: null,
               controlSnapshot: null,
               controlSnapshotUpdatedAt: 0,
+              clockSnapshot: null,
+              clockSnapshotUpdatedAt: 0,
+              clockExpandedGroups: {},
               quotaProviders: [],
               quotaProvidersUpdatedAt: 0,
               quotaProviderMap: null,
@@ -1416,10 +1564,19 @@
         el.style.display = value ? "block" : "none";
         const raw = value || "";
         const max = 12000;
-        const out = raw.length > max ? raw.slice(0, max) + "\n…(truncated)" : raw;
+        const out = raw.length > max ? raw.slice(0, max) + "\n...(truncated)" : raw;
         el.textContent = out;
       }
 
+      function appendLog(id, line) {
+        const el = $(id);
+        if (!el) return;
+        const prev = textOf(el.textContent || "").trim();
+        const nextLine = textOf(line || "").trim();
+        if (!nextLine) return;
+        setLog(id, prev ? (prev + "\n" + nextLine) : nextLine);
+      }
+
       function getApiKey() {
         try {
           return sessionStorage.getItem("routecodex:apikey") || "";
@@ -1460,7 +1617,7 @@
       }
 
       function selectTab(name) {
-        document.querySelectorAll(".tab").forEach((btn) => {
+        document.querySelectorAll(".tab[data-tab]").forEach((btn) => {
           btn.classList.toggle("active", btn.getAttribute("data-tab") === name);
         });
         const panels = [
@@ -1470,7 +1627,8 @@
           { name: "tokens", el: $("panelTokens") },
           { name: "credentials", el: $("panelCredentials") },
           { name: "quota", el: $("panelQuota") },
-          { name: "routing", el: $("panelRouting") }
+          { name: "routing", el: $("panelRouting") },
+          { name: "clock", el: $("panelClock") }
         ];
         for (const p of panels) p.el.style.display = p.name === name ? "block" : "none";
 
@@ -1480,7 +1638,7 @@
       }
 
       function getActiveTab() {
-        const active = document.querySelector(".tab.active");
+        const active = document.querySelector(".tab[data-tab].active");
         const name = active ? active.getAttribute("data-tab") : null;
         return name || "providers";
       }
@@ -1492,7 +1650,8 @@
         tokens: 0,
         credentials: 0,
         quota: 0,
-        routing: 0
+        routing: 0,
+        clock: 0
       };
 
       async function maybeRefreshTab(name) {
@@ -1516,6 +1675,9 @@
             await refreshRuntimes();
             await refreshRoutingSources();
           }
+          else if (key === "clock") {
+            await refreshClockTab();
+          }
         } catch {
           // ignore refresh failures on tab switch
         }
@@ -2100,6 +2262,486 @@
         };
       }
 
+      async function refreshClockOverview() {
+        const overviewEl = $("clockOverviewText");
+        if (!overviewEl) return;
+        try {
+          const res = await fetch("/daemon/clock/tasks");
+          if (!res || !res.ok) throw new Error(res ? String(res.status) : "request_failed");
+          const data = await res.json().catch(() => ({}));
+          const sessions = data && Array.isArray(data.sessions) ? data.sessions : [];
+          const records = data && Array.isArray(data.records) ? data.records : [];
+          const now = Date.now();
+          let taskCount = 0;
+          let dueCount = 0;
+          for (const session of sessions) {
+            const tasks = session && Array.isArray(session.tasks) ? session.tasks : [];
+            taskCount += tasks.length;
+            for (const task of tasks) {
+              let dueAtMs = Number(task && task.dueAtMs);
+              if (!Number.isFinite(dueAtMs) && task && typeof task.dueAt === "string") {
+                const parsed = Date.parse(task.dueAt);
+                dueAtMs = Number.isFinite(parsed) ? parsed : NaN;
+              }
+              if (Number.isFinite(dueAtMs) && dueAtMs <= now) {
+                dueCount += 1;
+              }
+            }
+          }
+          const onlineCount = records.filter((record) => {
+            const hb = Number(record && record.lastHeartbeatAtMs);
+            return Number.isFinite(hb) && now - hb <= 45_000;
+          }).length;
+          overviewEl.textContent = "clock: tasks " + taskCount + " · due " + dueCount + " · daemon " + onlineCount + "/" + records.length;
+        } catch {
+          overviewEl.textContent = "clock: unavailable";
+        }
+      }
+
+      function clockParseDueAtMs(task) {
+        const rawMs = Number(task && task.dueAtMs);
+        if (Number.isFinite(rawMs)) return Math.floor(rawMs);
+        const rawIso = task && typeof task.dueAt === "string" ? task.dueAt.trim() : "";
+        if (!rawIso) return NaN;
+        const parsed = Date.parse(rawIso);
+        return Number.isFinite(parsed) ? Math.floor(parsed) : NaN;
+      }
+
+      function clockTaskStatusKind(task, now) {
+        const dueAtMs = clockParseDueAtMs(task);
+        if (!Number.isFinite(dueAtMs)) return "warn";
+        const delta = dueAtMs - now;
+        if (delta < -60_000) return "bad";
+        if (delta <= 0) return "warn";
+        return "ok";
+      }
+
+      function clockTaskStatusText(task, now) {
+        const dueAtMs = clockParseDueAtMs(task);
+        if (!Number.isFinite(dueAtMs)) return "invalid";
+        const delta = dueAtMs - now;
+        if (delta < -60_000) return "overdue";
+        if (delta <= 0) return "due";
+        if (delta <= 60_000) return "soon";
+        return "scheduled";
+      }
+
+      function clockRecurrenceText(task) {
+        const rec = task && task.recurrence && typeof task.recurrence === "object" ? task.recurrence : null;
+        if (!rec) return "one-shot";
+        const kind = textOf(rec.kind || "").trim() || "recurring";
+        const maxRuns = Number(rec.maxRuns);
+        const count = Number(task && task.deliveryCount);
+        let base = kind;
+        if (kind === "interval") {
+          const everyMinutes = Number(rec.everyMinutes);
+          if (Number.isFinite(everyMinutes) && everyMinutes > 0) {
+            base += "/" + Math.floor(everyMinutes) + "m";
+          }
+        }
+        if (Number.isFinite(maxRuns) && maxRuns > 0) {
+          const safeCount = Number.isFinite(count) && count > 0 ? Math.floor(count) : 0;
+          base += " " + safeCount + "/" + Math.floor(maxRuns);
+        }
+        return base;
+      }
+
+      function clockNormalizeContent(value) {
+        return textOf(value).trim().replace(/\s+/g, " ");
+      }
+
+      function clockShortLabel(value, head = 8, tail = 4) {
+        const raw = textOf(value).trim();
+        if (!raw) return "—";
+        const maxLen = Math.max(6, head + tail + 1);
+        if (raw.length <= maxLen) return raw;
+        return raw.slice(0, head) + "…" + raw.slice(-tail);
+      }
+
+      function clockSessionPreview(sessionIds, limit = 3) {
+        const ids = Array.isArray(sessionIds) ? sessionIds.filter(Boolean) : [];
+        if (!ids.length) return "—";
+        const shown = ids.slice(0, limit).map((id) => clockShortLabel(id, 6, 3));
+        if (ids.length > limit) {
+          shown.push("+" + String(ids.length - limit));
+        }
+        return shown.join(", ");
+      }
+
+      function clockFormatCompactTs(ms) {
+        if (!Number.isFinite(ms) || ms <= 0) return "—";
+        const d = new Date(ms);
+        if (Number.isNaN(d.getTime())) return "—";
+        const pad = (n) => String(n).padStart(2, "0");
+        return pad(d.getMonth() + 1) + "-" + pad(d.getDate()) + " " + pad(d.getHours()) + ":" + pad(d.getMinutes());
+      }
+
+      function clockReadableTmuxSessionId(value) {
+        const raw = textOf(value).trim();
+        if (!raw) return "—";
+        const managed = /^rcc_([a-zA-Z0-9_-]+)_(\d{13})_([a-f0-9]{4,})$/i.exec(raw);
+        if (!managed) return clockShortLabel(raw, 10, 6);
+        const role = textOf(managed[1]).replace(/_/g, "-");
+        const startedAt = Number(managed[2]);
+        const startedText = clockFormatCompactTs(startedAt);
+        const suffix = textOf(managed[3]).slice(0, 4);
+        return role + "@" + startedText + "#" + suffix;
+      }
+
+      function clockTmuxPreview(values, limit = 2) {
+        const list = Array.isArray(values) ? values.filter((v) => textOf(v).trim() && textOf(v).trim() !== "—") : [];
+        if (!list.length) return "—";
+        const uniq = Array.from(new Set(list));
+        const shown = uniq.slice(0, limit);
+        if (uniq.length > limit) {
+          shown.push("+" + String(uniq.length - limit));
+        }
+        return shown.join(", ");
+      }
+
+      function clockRecurrenceShort(task) {
+        const rec = task && task.recurrence && typeof task.recurrence === "object" ? task.recurrence : null;
+        if (!rec) return "1x";
+        const kind = textOf(rec.kind || "").trim().toLowerCase();
+        const maxRuns = Number(rec.maxRuns);
+        let prefix = "R";
+        if (kind === "daily") prefix = "D";
+        else if (kind === "weekly") prefix = "W";
+        else if (kind === "interval") {
+          const everyMinutes = Number(rec.everyMinutes);
+          prefix = Number.isFinite(everyMinutes) && everyMinutes > 0 ? "I" + String(Math.floor(everyMinutes)) + "m" : "I";
+        }
+        if (Number.isFinite(maxRuns) && maxRuns > 0) {
+          return prefix + "/" + String(Math.floor(maxRuns));
+        }
+        return prefix;
+      }
+
+      function clockBuildGroupKey(task) {
+        const content = clockNormalizeContent(task && task.task);
+        const tool = textOf(task && task.tool).trim();
+        return [content || "(empty)", tool || "tool:none"].join("||");
+      }
+
+      function renderClockTabFromSnapshot() {
+        const snap = UI.clockSnapshot && typeof UI.clockSnapshot === "object" ? UI.clockSnapshot : {};
+        const sessions = Array.isArray(snap.sessions) ? snap.sessions : [];
+        const records = Array.isArray(snap.records) ? snap.records : [];
+
+        const mergedBody = $("clockMergedTbody");
+        const daemonBody = $("clockDaemonsTbody");
+        const summaryBox = $("clockSummaryPills");
+        const hint = $("clockHint");
+
+        if (mergedBody) mergedBody.replaceChildren();
+        if (daemonBody) daemonBody.replaceChildren();
+        if (summaryBox) summaryBox.replaceChildren();
+
+        const now = Date.now();
+        const groups = new Map();
+        const rows = [];
+        const conversationToTmuxSession = new Map();
+        for (const record of records) {
+          const tmuxSession = textOf((record && record.tmuxSessionId) || (record && record.sessionId)).trim();
+          if (!tmuxSession) continue;
+          const conversationIds = Array.isArray(record && record.conversationSessionIds) ? record.conversationSessionIds : [];
+          for (const cid of conversationIds) {
+            const key = textOf(cid).trim();
+            if (!key || conversationToTmuxSession.has(key)) continue;
+            conversationToTmuxSession.set(key, tmuxSession);
+          }
+        }
+        for (const session of sessions) {
+          const sessionId = textOf(session && session.sessionId).trim();
+          const mappedTmuxSessionId = textOf(conversationToTmuxSession.get(sessionId)).trim();
+          const mappedTmuxShort = clockReadableTmuxSessionId(mappedTmuxSessionId);
+          const tasks = session && Array.isArray(session.tasks) ? session.tasks : [];
+          for (const task of tasks) {
+            const key = clockBuildGroupKey(task);
+            const dueMs = clockParseDueAtMs(task);
+            const status = clockTaskStatusText(task, now);
+            const statusKind = clockTaskStatusKind(task, now);
+            const taskId = textOf(task && task.taskId).trim();
+            const recurrence = clockRecurrenceText(task);
+            const tool = textOf(task && task.tool).trim() || "—";
+            const deliveryCount = Number(task && task.deliveryCount);
+            const row = {
+              groupKey: key,
+              sessionId,
+              sessionShort: clockShortLabel(sessionId, 6, 3),
+              tmuxSessionId: mappedTmuxSessionId,
+              tmuxShort: mappedTmuxShort,
+              taskId,
+              taskShort: clockShortLabel(taskId, 6, 4),
+              content: textOf(task && task.task).trim(),
+              dueMs,
+              dueAt: Number.isFinite(dueMs) ? formatEpochWithDelta(dueMs) : "—",
+              dueCompact: Number.isFinite(dueMs) ? formatEpochMs(dueMs) : "—",
+              status,
+              statusKind,
+              recurrence,
+              recurrenceShort: clockRecurrenceShort(task),
+              deliveryCount,
+              tool,
+              toolShort: clockShortLabel(tool, 8, 3)
+            };
+            row.metaShort = row.toolShort + " · " + row.recurrenceShort + (Number.isFinite(row.deliveryCount) ? " · #" + String(Math.max(0, Math.floor(row.deliveryCount))) : "");
+            rows.push(row);
+
+            if (!groups.has(key)) {
+              groups.set(key, {
+                groupKey: key,
+                content: row.content || "(empty)",
+                sessionIds: new Set(),
+                tmuxDisplays: new Set(),
+                taskCount: 0,
+                dueMin: Number.isFinite(dueMs) ? dueMs : NaN,
+                dueMax: Number.isFinite(dueMs) ? dueMs : NaN,
+                dueCount: 0,
+                overdueCount: 0,
+                statusKind: row.statusKind,
+                toolSet: new Set(),
+                recurrenceSet: new Set(),
+                rows: []
+              });
+            }
+            const group = groups.get(key);
+            group.sessionIds.add(sessionId || "—");
+            if (row.tmuxShort && row.tmuxShort !== "—") {
+              group.tmuxDisplays.add(row.tmuxShort);
+            }
+            group.toolSet.add(row.toolShort);
+            group.recurrenceSet.add(row.recurrenceShort);
+            group.taskCount += 1;
+            group.rows.push(row);
+            if (row.status === "due") group.dueCount += 1;
+            if (row.status === "overdue") group.overdueCount += 1;
+            if (Number.isFinite(dueMs)) {
+              if (!Number.isFinite(group.dueMin) || dueMs < group.dueMin) group.dueMin = dueMs;
+              if (!Number.isFinite(group.dueMax) || dueMs > group.dueMax) group.dueMax = dueMs;
+            }
+            if (row.statusKind === "bad") group.statusKind = "bad";
+            else if (row.statusKind === "warn" && group.statusKind !== "bad") group.statusKind = "warn";
+          }
+        }
+
+        const merged = Array.from(groups.values());
+        merged.sort((a, b) => {
+          const aDue = Number.isFinite(a.dueMin) ? a.dueMin : Number.POSITIVE_INFINITY;
+          const bDue = Number.isFinite(b.dueMin) ? b.dueMin : Number.POSITIVE_INFINITY;
+          if (aDue !== bDue) return aDue - bDue;
+          return b.taskCount - a.taskCount;
+        });
+
+        rows.sort((a, b) => {
+          const aDue = Number.isFinite(a.dueMs) ? a.dueMs : Number.POSITIVE_INFINITY;
+          const bDue = Number.isFinite(b.dueMs) ? b.dueMs : Number.POSITIVE_INFINITY;
+          if (aDue !== bDue) return aDue - bDue;
+          return a.sessionId.localeCompare(b.sessionId);
+        });
+
+        if (!UI.clockExpandedGroups || typeof UI.clockExpandedGroups !== "object") {
+          UI.clockExpandedGroups = {};
+        }
+
+        if (summaryBox) {
+          const dueNow = rows.filter((r) => r.status === "due").length;
+          const overdue = rows.filter((r) => r.status === "overdue").length;
+          const recurring = rows.filter((r) => r.recurrence !== "one-shot").length;
+          const onlineDaemon = records.filter((record) => {
+            const hb = Number(record && record.lastHeartbeatAtMs);
+            return Number.isFinite(hb) && now - hb <= 45_000;
+          }).length;
+          const pills = [
+            ["sessions", sessions.length, ""],
+            ["tasks", rows.length, ""],
+            ["merged", merged.length, ""],
+            ["due", dueNow, dueNow ? "warn" : "ok"],
+            ["overdue", overdue, overdue ? "bad" : "ok"],
+            ["recurring", recurring, ""],
+            ["daemon", onlineDaemon + "/" + records.length, onlineDaemon ? "ok" : "warn"]
+          ];
+          for (const [label, value, kind] of pills) {
+            summaryBox.appendChild(pill(label + ": " + value, kind));
+          }
+        }
+
+        if (mergedBody) {
+          if (!merged.length) {
+            mergedBody.appendChild(createInfoRow(5, "No clock tasks."));
+          } else {
+            for (const item of merged) {
+              const isExpanded = !!UI.clockExpandedGroups[item.groupKey];
+              const tr = document.createElement("tr");
+              tr.className = "group-row";
+              const statusText = item.overdueCount > 0
+                ? "overdue " + item.overdueCount
+                : item.dueCount > 0
+                  ? "due " + item.dueCount
+                  : "scheduled";
+              const statusTd = document.createElement("td");
+              statusTd.appendChild(pill(statusText, item.statusKind));
+              tr.appendChild(statusTd);
+
+              const taskTd = document.createElement("td");
+              const toggleBtn = document.createElement("button");
+              toggleBtn.type = "button";
+              toggleBtn.className = "clock-group-toggle mono";
+              toggleBtn.textContent = (isExpanded ? "▾ " : "▸ ") + (item.content || "(empty)");
+              toggleBtn.title = isExpanded ? "collapse" : "expand";
+              toggleBtn.addEventListener("click", () => {
+                UI.clockExpandedGroups[item.groupKey] = !UI.clockExpandedGroups[item.groupKey];
+                renderClockTabFromSnapshot();
+              });
+              taskTd.appendChild(toggleBtn);
+              const groupSummary = document.createElement("div");
+              groupSummary.className = "clock-group-summary mono";
+              const toolPart = Array.from(item.toolSet).slice(0, 2).join(", ") || "—";
+              const recPart = Array.from(item.recurrenceSet).slice(0, 2).join(", ") || "1x";
+              groupSummary.textContent = "tool " + toolPart + " · rec " + recPart;
+              groupSummary.title = groupSummary.textContent;
+              taskTd.appendChild(groupSummary);
+              tr.appendChild(taskTd);
+
+              const nextDueText = Number.isFinite(item.dueMin) ? formatEpochWithDelta(item.dueMin) : "—";
+              tr.appendChild(createCell("td", nextDueText, "mono truncate", { title: true }));
+
+              const sortedDueRows = item.rows
+                .filter((r) => Number.isFinite(r.dueMs))
+                .sort((a, b) => a.dueMs - b.dueMs);
+              let planText = "—";
+              if (sortedDueRows.length) {
+                planText = sortedDueRows.slice(0, 3).map((r) => r.dueCompact).join(" | ");
+                if (sortedDueRows.length > 3) {
+                  planText += " +" + String(sortedDueRows.length - 3);
+                }
+              }
+              tr.appendChild(createCell("td", planText, "mono truncate", { title: true }));
+
+              const sessionList = Array.from(item.sessionIds);
+              const tmuxPreview = clockTmuxPreview(Array.from(item.tmuxDisplays));
+              const scopeText = String(item.taskCount) + " task" + (item.taskCount > 1 ? "s" : "") + " · " + String(sessionList.length) + " session" + (sessionList.length > 1 ? "s" : "") + " · tmux " + tmuxPreview;
+              tr.appendChild(createCell("td", scopeText, "mono truncate", { title: true }));
+              mergedBody.appendChild(tr);
+
+              const detailTr = document.createElement("tr");
+              detailTr.className = "clock-detail-row";
+              if (!isExpanded) detailTr.style.display = "none";
+              const detailTd = document.createElement("td");
+              detailTd.colSpan = 5;
+              if (isExpanded) {
+                const detailList = document.createElement("div");
+                detailList.className = "clock-detail-list";
+                const detailRows = item.rows.slice().sort((a, b) => {
+                  const aDue = Number.isFinite(a.dueMs) ? a.dueMs : Number.POSITIVE_INFINITY;
+                  const bDue = Number.isFinite(b.dueMs) ? b.dueMs : Number.POSITIVE_INFINITY;
+                  if (aDue !== bDue) return aDue - bDue;
+                  return a.sessionId.localeCompare(b.sessionId);
+                });
+                for (const detail of detailRows.slice(0, 40)) {
+                  const line = document.createElement("div");
+                  line.className = "clock-detail-item mono";
+
+                  const timeSpan = document.createElement("span");
+                  timeSpan.textContent = detail.dueCompact;
+                  timeSpan.title = detail.dueAt;
+                  line.appendChild(timeSpan);
+
+                  line.appendChild(pill(detail.status, detail.statusKind));
+
+                  const idSpan = document.createElement("span");
+                  const tmuxPrefix = detail.tmuxShort && detail.tmuxShort !== "—" ? "tmux " + detail.tmuxShort + " · " : "";
+                  idSpan.textContent = tmuxPrefix + "sid " + detail.sessionShort + " · id " + detail.taskShort + " · " + detail.metaShort;
+                  idSpan.title = "tmux " + (detail.tmuxSessionId || "—") + " | session " + detail.sessionId + " | task " + detail.taskId + " | " + detail.tool + " | " + detail.recurrence;
+                  line.appendChild(idSpan);
+
+                  const contentSpan = document.createElement("span");
+                  contentSpan.className = "clock-detail-content";
+                  contentSpan.textContent = detail.content || "(empty)";
+                  contentSpan.title = detail.content || "(empty)";
+                  line.appendChild(contentSpan);
+
+                  detailList.appendChild(line);
+                }
+                if (detailRows.length > 40) {
+                  const more = document.createElement("div");
+                  more.className = "mono muted";
+                  more.textContent = "… " + String(detailRows.length - 40) + " more";
+                  detailList.appendChild(more);
+                }
+                detailTd.appendChild(detailList);
+              }
+              detailTr.appendChild(detailTd);
+              mergedBody.appendChild(detailTr);
+            }
+          }
+        }
+
+        if (daemonBody) {
+          if (!records.length) {
+            daemonBody.appendChild(createInfoRow(7, "No clock daemon bindings."));
+          } else {
+            for (const rec of records) {
+              const tr = document.createElement("tr");
+              const daemonId = textOf(rec && rec.daemonId).trim() || "—";
+              const tmuxSession = textOf((rec && rec.tmuxSessionId) || (rec && rec.sessionId)).trim() || "—";
+              const conversations = Array.isArray(rec && rec.conversationSessionIds) ? rec.conversationSessionIds : [];
+              const hb = Number(rec && rec.lastHeartbeatAtMs);
+              const inject = Number(rec && rec.lastInjectAtMs);
+              const errText = textOf(rec && rec.lastError).trim();
+              const isOnline = Number.isFinite(hb) && now - hb <= 45_000;
+              const statusKind = errText ? "bad" : isOnline ? "ok" : "warn";
+              const statusText = errText ? "error" : isOnline ? "online" : "stale";
+
+              tr.appendChild(createCell("td", daemonId, "mono truncate", { title: true }));
+              const tmuxReadable = clockReadableTmuxSessionId(tmuxSession);
+              const tmuxCell = createCell("td", tmuxReadable, "mono truncate", { title: true });
+              tmuxCell.title = tmuxSession || tmuxReadable;
+              tr.appendChild(tmuxCell);
+              tr.appendChild(createCell("td", String(conversations.length), "mono"));
+              tr.appendChild(createCell("td", Number.isFinite(hb) ? formatEpochWithDelta(hb) : "—", "mono truncate", { title: true }));
+              tr.appendChild(createCell("td", Number.isFinite(inject) ? formatEpochWithDelta(inject) : "—", "mono truncate", { title: true }));
+              const statusTd = document.createElement("td");
+              statusTd.appendChild(pill(statusText, statusKind));
+              tr.appendChild(statusTd);
+              tr.appendChild(createCell("td", errText || "—", "mono truncate", { title: true }));
+              daemonBody.appendChild(tr);
+            }
+          }
+        }
+
+        if (hint) {
+          hint.textContent = "groups " + merged.length + " · tasks " + rows.length + " · updated: " + formatTs(UI.clockSnapshotUpdatedAt);
+        }
+      }
+
+      async function refreshClockTab() {
+        try {
+          const filter = textOf($("clockSessionFilterInput") && $("clockSessionFilterInput").value).trim();
+          const path = filter
+            ? "/daemon/clock/tasks?sessionId=" + encodeURIComponent(filter)
+            : "/daemon/clock/tasks";
+          const data = await apiFetch(path);
+          UI.clockSnapshot = data && typeof data === "object" ? data : {};
+          UI.clockSnapshotUpdatedAt = Date.now();
+          renderClockTabFromSnapshot();
+        } catch (e) {
+          const mergedBody = $("clockMergedTbody");
+          const daemonBody = $("clockDaemonsTbody");
+          if (mergedBody) {
+            mergedBody.replaceChildren();
+            mergedBody.appendChild(createErrorRow(5, e && e.message ? e.message : String(e)));
+          }
+          if (daemonBody) {
+            daemonBody.replaceChildren();
+            daemonBody.appendChild(createInfoRow(7, "No daemon bindings."));
+          }
+          const hint = $("clockHint");
+          if (hint) hint.textContent = "clock snapshot failed";
+          if (e && e.status === 401) notifyUnauthorizedOnce("clock");
+        }
+      }
+
       async function refreshStatus() {
         // /health is public; use it to always show version even before admin login.
         try {
@@ -2121,6 +2763,7 @@
           $("statusDot").classList.add("err");
           $("serverId").textContent = "serverId: —";
         }
+        await refreshClockOverview();
       }
 
       function formatTs(ms) {
@@ -2672,32 +3315,59 @@
             tr.appendChild(createCell("td", c.provider || "", "mono"));
             tr.appendChild(createCell("td", c.alias || "", "mono"));
             const statusTd = document.createElement("td");
-            statusTd.appendChild(pill(c.status || "—", (c.status || "") === "valid" ? "ok" : "warn"));
+            const statusRaw = textOf(c.status || "").trim().toLowerCase();
+            statusTd.appendChild(pill(c.status || "—", statusRaw === "valid" ? "ok" : "warn"));
             const issue = findAuthIssueForProviderAlias(c.provider, c.alias);
             if (issue) {
               statusTd.appendChild(document.createTextNode(" "));
               statusTd.appendChild(pill("verify required", "bad"));
-              if (issue.url) {
-                statusTd.appendChild(document.createTextNode(" "));
-                const a = document.createElement("a");
-                a.href = "#";
-                a.textContent = "open";
-                a.className = "mono";
-                a.addEventListener("click", (ev) => {
-                  ev.preventDefault();
-                  void openAuthIssueInCamoufox(c.provider, c.alias, issue.url);
-                });
-                statusTd.appendChild(a);
-              }
             }
             tr.appendChild(statusTd);
             tr.appendChild(createCell("td", exp, "mono"));
             tr.appendChild(createCell("td", c.secretRef || "—", "mono"));
+
+            const actionTd = document.createElement("td");
+            actionTd.className = "actions-cell";
+            const actions = document.createElement("div");
+            actions.className = "auth-actions";
+            let hasAction = false;
+
+            if (issue && issue.url) {
+              const openVerify = document.createElement("button");
+              openVerify.type = "button";
+              openVerify.className = "auth-action-btn";
+              openVerify.textContent = "Open Verify";
+              openVerify.addEventListener("click", () => {
+                void openAuthIssueInCamoufox(c.provider, c.alias, issue.url);
+              });
+              actions.appendChild(openVerify);
+              hasAction = true;
+            }
+
+            if (textOf(c.kind || "").trim().toLowerCase() === "oauth" && (statusRaw === "expired" || statusRaw === "invalid")) {
+              const recover = document.createElement("button");
+              recover.type = "button";
+              recover.className = "auth-action-btn primary";
+              recover.textContent = "Recover";
+              recover.addEventListener("click", () => {
+                void runCredentialAutoRecovery(c);
+              });
+              actions.appendChild(recover);
+              hasAction = true;
+            }
+
+            if (hasAction) {
+              actionTd.appendChild(actions);
+            } else {
+              actionTd.classList.add("mono");
+              actionTd.textContent = "—";
+            }
+            tr.appendChild(actionTd);
             body.appendChild(tr);
           }
           updateOauthAuthIssueHint();
         } catch (e) {
-          body.appendChild(createErrorRow(6, e && e.message ? e.message : e));
+          body.appendChild(createErrorRow(7, e && e.message ? e.message : e));
           updateOauthAuthIssueHint();
         }
       }
@@ -2727,6 +3397,7 @@
       async function authorizeOauth(mode = "manual") {
         const safeMode = mode === "auto" ? "auto" : "manual";
         setLog("credentialOpLog", "");
+        appendLog("credentialOpLog", `[${safeMode}] start authorize request ...`);
         const provider = $("oauthProviderSelect").value;
         const alias = ($("oauthAuthAliasInput").value || "default").trim() || "default";
         updateOauthAuthIssueHint();
@@ -2762,6 +3433,167 @@
         }
       }
 
+      function setOauthContext(providerRaw, aliasRaw) {
+        const provider = textOf(providerRaw || "").trim().toLowerCase();
+        const alias = textOf(aliasRaw || "default").trim() || "default";
+        const providerSelect = $("oauthProviderSelect");
+        if (providerSelect) {
+          const optionExists = Array.from(providerSelect.options || []).some((opt) => textOf(opt.value).trim().toLowerCase() === provider);
+          if (optionExists) {
+            providerSelect.value = provider;
+          }
+        }
+        const aliasInput = $("oauthAuthAliasInput");
+        if (aliasInput) {
+          aliasInput.value = alias;
+        }
+        updateOauthAuthIssueHint();
+      }
+
+      async function openManualAuthFallback(providerRaw, aliasRaw, reason) {
+        const provider = textOf(providerRaw || "").trim().toLowerCase();
+        const alias = textOf(aliasRaw || "default").trim() || "default";
+        selectTab("credentials");
+        setOauthMode("manual");
+        setOauthContext(provider, alias);
+        if (reason) {
+          appendLog("credentialOpLog", reason);
+        }
+
+        appendLog("credentialOpLog", "[step3] 自动启动 Manual Auth（headful）…");
+        try {
+          await apiFetch("/config/settings", {
+            method: "PUT",
+            body: JSON.stringify({ oauthBrowser: "camoufox" })
+          });
+        } catch (e) {
+          appendLog("credentialOpLog", "[step3] set oauthBrowser=camoufox failed: " + (e && e.message ? e.message : String(e)));
+        }
+
+        try {
+          const out = await apiFetch("/daemon/oauth/authorize", {
+            method: "POST",
+            body: JSON.stringify({
+              provider,
+              alias,
+              mode: "manual",
+              openBrowser: true,
+              forceReauthorize: true,
+              headful: true
+            })
+          });
+          appendLog("credentialOpLog", "[step3] manual auth started: tokenFile=" + textOf(out && out.tokenFile ? out.tokenFile : "—"));
+          appendLog("credentialOpLog", "[manual] 已尝试弹出认证窗口；若未自动完成，请在弹出的 portal 完成登录。");
+          toast("Manual auth started: " + provider + "." + alias, "ok");
+          return true;
+        } catch (e) {
+          appendLog("credentialOpLog", "[step3] manual auth auto-start failed: " + (e && e.message ? e.message : String(e)));
+          appendLog("credentialOpLog", "[manual] 请点击 Start Manual Auth 重试。");
+        }
+
+        try {
+          const btn = $("oauthAuthorizeManualBtn");
+          if (btn && typeof btn.scrollIntoView === "function") {
+            btn.scrollIntoView({ behavior: "smooth", block: "center" });
+          }
+          if (btn && typeof btn.focus === "function") {
+            btn.focus();
+          }
+        } catch {
+          // ignore focus/scroll failures
+        }
+        return false;
+      }
+
+      async function runCredentialAutoRecovery(cred) {
+        const id = textOf(cred && cred.id ? cred.id : "").trim();
+        const provider = textOf(cred && cred.provider ? cred.provider : "").trim().toLowerCase();
+        const alias = textOf(cred && cred.alias ? cred.alias : "default").trim() || "default";
+        if (!id || !provider) {
+          setLog("credentialOpLog", "[recover] missing credential id/provider");
+          return;
+        }
+
+        selectTab("credentials");
+        setOauthContext(provider, alias);
+        setLog("credentialOpLog", "[recover] " + provider + "." + alias + " (id=" + id + ")");
+
+        let refreshOk = false;
+        appendLog("credentialOpLog", "[step1] 尝试 refresh token …");
+        try {
+          const out = await apiFetch("/daemon/credentials/" + encodeURIComponent(id) + "/refresh", {
+            method: "POST"
+          });
+          appendLog(
+            "credentialOpLog",
+            "[step1] refresh result: status=" + textOf(out && out.status ? out.status : "—") + " refreshed=" + (out && out.refreshed === true ? "yes" : "no")
+          );
+          await refreshCredentials();
+          const latest = findCredentialForSelection(provider, alias);
+          const latestStatus = textOf(latest && latest.status ? latest.status : "").trim().toLowerCase();
+          const exp = Number(latest && latest.expiresInSec != null ? latest.expiresInSec : NaN);
+          if (latestStatus === "valid" && (!Number.isFinite(exp) || exp > 0)) {
+            refreshOk = true;
+            appendLog("credentialOpLog", "[done] refresh 后已恢复有效 token。");
+            toast("OAuth refreshed: " + provider + "." + alias, "ok");
+          }
+        } catch (e) {
+          appendLog("credentialOpLog", "[step1] refresh failed: " + (e && e.message ? e.message : String(e)));
+        }
+        if (refreshOk) {
+          return;
+        }
+
+        appendLog("credentialOpLog", "[step2] refresh 未恢复，启动 Camoufox auto oauth …");
+        try {
+          await apiFetch("/config/settings", {
+            method: "PUT",
+            body: JSON.stringify({ oauthBrowser: "camoufox" })
+          });
+        } catch (e) {
+          appendLog("credentialOpLog", "[step2] set oauthBrowser=camoufox failed: " + (e && e.message ? e.message : String(e)));
+        }
+
+        try {
+          const out = await apiFetch("/daemon/oauth/authorize", {
+            method: "POST",
+            body: JSON.stringify({
+              provider,
+              alias,
+              mode: "auto",
+              openBrowser: true,
+              forceReauthorize: false,
+              headful: false
+            })
+          });
+          appendLog("credentialOpLog", "[step2] auto oauth ok: tokenFile=" + textOf(out && out.tokenFile ? out.tokenFile : "—"));
+          await refreshCredentials();
+          if (provider === "antigravity") {
+            try {
+              await refreshQuota();
+              await refreshCredentials();
+            } catch {
+              // ignore quota refresh errors in recovery path
+            }
+          }
+          const latest = findCredentialForSelection(provider, alias);
+          const latestStatus = textOf(latest && latest.status ? latest.status : "").trim().toLowerCase();
+          if (latestStatus === "valid") {
+            appendLog("credentialOpLog", "[done] auto oauth 后 token 已恢复有效。");
+            toast("OAuth recovered: " + provider + "." + alias, "ok");
+            return;
+          }
+          appendLog("credentialOpLog", "[step2] auto oauth 执行完成，但状态仍非 valid。");
+        } catch (e) {
+          appendLog("credentialOpLog", "[step2] auto oauth failed: " + (e && e.message ? e.message : String(e)));
+        }
+
+        const manualStarted = await openManualAuthFallback(provider, alias, "[step3] 自动恢复失败，切换到手动认证。");
+        if (!manualStarted) {
+          toast("Auto recovery failed, switched to manual auth (" + provider + "." + alias + ").");
+        }
+      }
+
       const routingEditorState = {
 	        value: {},
 	        dirty: false
@@ -2873,29 +3705,69 @@
 	        return false;
 	      }
 
-	      function resolveTargetToProviderKeys(target) {
-	        const raw = textOf(target).trim();
-	        if (!raw) return [];
-	        const list = Array.isArray(UI.quotaProviders) ? UI.quotaProviders : [];
-	        const keys = list.map((p) => textOf(p && p.providerKey ? p.providerKey : "")).filter(Boolean);
-	        const known = new Set(keys);
-	        if (known.has(raw)) return [raw];
-	        const dot = raw.indexOf(".");
-	        if (dot <= 0) return [];
-	        const providerId = raw.slice(0, dot);
-	        const modelId = raw.slice(dot + 1);
-	        if (!providerId || !modelId) return [];
-	        const prefix = `${providerId}.`;
-	        const suffix = `.${modelId}`;
-	        const out = [];
-	        for (const k of keys) {
-	          if (k.startsWith(prefix) && k.endsWith(suffix)) out.push(k);
-	        }
-	        out.sort((a, b) => a.localeCompare(b));
-	        return out;
-	      }
+	      function resolveTargetToProviderKeys(target, providersOverride) {
+        const raw = textOf(target).trim();
+        if (!raw) return [];
+        const list = Array.isArray(providersOverride)
+          ? providersOverride
+          : (Array.isArray(UI.quotaProviders) ? UI.quotaProviders : []);
+        const keys = list.map((p) => textOf(p && p.providerKey ? p.providerKey : "")).filter(Boolean);
+        const known = new Set(keys);
+        if (!known.size) return [];
+        if (known.has(raw)) return [raw];
+
+        const candidates = new Set();
+        const bracketMatch = raw.match(/^([^.[\]]+)\[([^\]]+)\]\.(.+)$/);
+        if (bracketMatch) {
+          const providerId = textOf(bracketMatch[1]).trim();
+          const authAlias = textOf(bracketMatch[2]).trim();
+          const modelId = textOf(bracketMatch[3]).trim();
+          if (providerId && authAlias && modelId) {
+            candidates.add(providerId + "." + authAlias + "." + modelId);
+          }
+        }
+
+        const dotted = raw.split(".").filter(Boolean);
+        if (dotted.length >= 3) {
+          const providerId = dotted[0];
+          const modelId = dotted.slice(2).join(".");
+          if (providerId && modelId) {
+            candidates.add(raw);
+            candidates.add(providerId + "." + modelId);
+          }
+        } else if (dotted.length === 2) {
+          candidates.add(raw);
+        }
+
+        for (const c of candidates) {
+          if (known.has(c)) return [c];
+        }
+
+        const out = [];
+        const addByProviderModel = (providerId, modelId) => {
+          if (!providerId || !modelId) return;
+          const prefix = providerId + ".";
+          const suffix = "." + modelId;
+          for (const k of keys) {
+            if (k.startsWith(prefix) && k.endsWith(suffix)) out.push(k);
+          }
+        };
 
-	      function getQuotaStateByProviderKey(providerKey) {
+        if (bracketMatch) {
+          addByProviderModel(textOf(bracketMatch[1]).trim(), textOf(bracketMatch[3]).trim());
+        }
+
+        if (dotted.length >= 2) {
+          addByProviderModel(dotted[0], dotted.slice(1).join("."));
+          if (dotted.length >= 3) {
+            addByProviderModel(dotted[0], dotted.slice(2).join("."));
+          }
+        }
+
+        return Array.from(new Set(out)).sort((a, b) => a.localeCompare(b));
+      }
+
+      function getQuotaStateByProviderKey(providerKey) {
 	        const map = UI.quotaProviderMap instanceof Map ? UI.quotaProviderMap : null;
 	        if (map && map.has(providerKey)) return map.get(providerKey);
 	        const list = Array.isArray(UI.quotaProviders) ? UI.quotaProviders : [];
@@ -3378,31 +4250,13 @@
       function resolveRoutedProviderKeys(routingTargets, providers) {
         const targets = routingTargets instanceof Set ? Array.from(routingTargets) : [];
         const list = Array.isArray(providers) ? providers : [];
-        const keys = [];
-        for (const p of list) {
-          const k = textOf(p && p.providerKey ? p.providerKey : "");
-          if (k) keys.push(k);
-        }
-        const known = new Set(keys);
         const resolved = new Set();
-        if (!targets.length || !known.size) return resolved;
+        if (!targets.length || !list.length) return resolved;
 
         for (const t of targets) {
-          const target = textOf(t);
-          if (!target) continue;
-          if (known.has(target)) {
-            resolved.add(target);
-            continue;
-          }
-          const dot = target.indexOf(".");
-          if (dot <= 0) continue;
-          const providerId = target.slice(0, dot);
-          const modelId = target.slice(dot + 1);
-          if (!providerId || !modelId) continue;
-          const prefix = `${providerId}.`;
-          const suffix = `.${modelId}`;
-          for (const k of known) {
-            if (k.startsWith(prefix) && k.endsWith(suffix)) resolved.add(k);
+          const mapped = resolveTargetToProviderKeys(t, list);
+          for (const key of mapped) {
+            if (key) resolved.add(key);
           }
         }
         return resolved;
@@ -3557,16 +4411,16 @@
 
 	        const filter = textOf($("quotaFilterInput").value || "").trim().toLowerCase();
 	        const hideOk = Boolean($("quotaHideOkToggle").checked);
-	        const onlyRoutedTargets = Boolean($("quotaOnlyRoutedTargetsToggle").checked);
-        const routedProviderKeys = onlyRoutedTargets ? resolveRoutedProviderKeys(UI.routingTargets, UI.quotaProviders) : null;
+        const routedProviderKeys = resolveRoutedProviderKeys(UI.routingTargets, UI.quotaProviders);
 
         const list = Array.isArray(UI.quotaProviders) ? UI.quotaProviders : [];
         const next = list
           .filter((q) => {
-            const key = textOf(q && q.providerKey ? q.providerKey : "").toLowerCase();
+            const keyRaw = textOf(q && q.providerKey ? q.providerKey : "");
+            const key = keyRaw.toLowerCase();
             if (filter && !key.includes(filter)) return false;
             if (hideOk && q && q.inPool === true) return false;
-            if (routedProviderKeys && !routedProviderKeys.has(textOf(q && q.providerKey ? q.providerKey : ""))) return false;
+            if (!routedProviderKeys.has(keyRaw)) return false;
             return true;
           })
           .slice();
@@ -4063,7 +4917,7 @@
             body.appendChild(tr);
           }
         } catch (e) {
-          body.appendChild(createErrorRow(6, e && e.message ? e.message : e));
+          body.appendChild(createErrorRow(7, e && e.message ? e.message : e));
         }
       }
 
@@ -4173,7 +5027,7 @@
       }
 
       // Bind events
-      document.querySelectorAll(".tab").forEach((btn) => {
+      document.querySelectorAll(".tab[data-tab]").forEach((btn) => {
         btn.addEventListener("click", () => selectTab(btn.getAttribute("data-tab")));
       });
 
@@ -4309,6 +5163,14 @@
           .catch(() => {});
       });
 
+      $("refreshClockBtn").addEventListener("click", refreshClockTab);
+      $("clockSessionFilterInput").addEventListener("keydown", (ev) => {
+        if (ev && ev.key === "Enter") {
+          ev.preventDefault();
+          void refreshClockTab();
+        }
+      });
+
       $("restartRuntimeBtn").addEventListener("click", async () => {
         setLog("providerOpLog", "");
         if (!confirm("Reload config from disk and rebuild runtime now?")) return;
@@ -4455,10 +5317,22 @@
 
       $("refreshCredentialsBtn").addEventListener("click", refreshCredentials);
       $("saveOauthBrowserBtn").addEventListener("click", saveSettings);
-      $("oauthModeManualBtn").addEventListener("click", () => setOauthMode("manual"));
-      $("oauthModeAutoBtn").addEventListener("click", () => setOauthMode("auto"));
-      $("oauthAuthorizeManualBtn").addEventListener("click", () => void authorizeOauth("manual"));
-      $("oauthAuthorizeAutoBtn").addEventListener("click", () => void authorizeOauth("auto"));
+      $("oauthModeManualBtn").addEventListener("click", () => {
+        setOauthMode("manual");
+        appendLog("credentialOpLog", "[ui] switched to manual mode");
+      });
+      $("oauthModeAutoBtn").addEventListener("click", () => {
+        setOauthMode("auto");
+        appendLog("credentialOpLog", "[ui] switched to auto mode");
+      });
+      $("oauthAuthorizeManualBtn").addEventListener("click", () => {
+        appendLog("credentialOpLog", "[ui] click Start Manual Auth");
+        void authorizeOauth("manual");
+      });
+      $("oauthAuthorizeAutoBtn").addEventListener("click", () => {
+        appendLog("credentialOpLog", "[ui] click Run Auto Auth");
+        void authorizeOauth("auto");
+      });
       $("oauthVerifyOpenBtn").addEventListener("click", () => void openSelectedVerifyUrl());
       $("oauthVerifyCopyBtn").addEventListener("click", () => void copySelectedVerifyUrl());
       $("oauthVerifyRecheckBtn").addEventListener("click", async () => {