clay-server 4.0.0-beta.1 → 4.0.0-beta.11

package/lib/public/modules/scheduler.js

@@ -125,8 +125,8 @@ export function initScheduler(_ctx) {
 function ensurePanel() {
   if (panel) return;
 
-  var appEl = document.getElementById("app");
-  if (!appEl) return;
+  var hostEl = document.getElementById("main-area");
+  if (!hostEl) return;
 
   panel = document.createElement("div");
   panel.id = "scheduler-panel";
@@ -256,7 +256,7 @@ function ensurePanel() {
   bodyRow.appendChild(content);
   panel.appendChild(bodyRow);
 
-  appEl.appendChild(panel);
+  hostEl.appendChild(panel);
 
   // --- Close button (in top bar) ---
   panel.querySelector("#scheduler-panel-close").addEventListener("click", function () {
@@ -383,6 +383,8 @@ function openScheduler() {
 
   var sidebarBtn = document.getElementById("scheduler-btn");
   if (sidebarBtn) sidebarBtn.classList.add("active");
+  var homeBtn = document.getElementById("home-scheduler-btn");
+  if (homeBtn) homeBtn.classList.add("active");
 
   // Persist scheduler state in URL hash
   if (location.hash !== "#scheduler") {
@@ -423,6 +425,8 @@ export function closeScheduler() {
   // Un-mark sidebar button
   var sidebarBtn = document.getElementById("scheduler-btn");
   if (sidebarBtn) sidebarBtn.classList.remove("active");
+  var homeBtn = document.getElementById("home-scheduler-btn");
+  if (homeBtn) homeBtn.classList.remove("active");
 
   // Remove scheduler hash from URL
   if (location.hash === "#scheduler") {
@@ -1470,6 +1474,16 @@ export function openSchedulerToTab(tab) {
   }
 }
 
+export function openHomeScheduler() {
+  if (!ctx) return;
+  ctx.requireClayRalph(function () {
+    showAllProjects = true;
+    openSchedulerToTab("calendar");
+    renderSidebar();
+    render();
+  });
+}
+
 export function isSchedulerOpen() {
   return panelOpen;
 }

package/lib/public/modules/sidebar-mobile.js

@@ -887,8 +887,7 @@ function renderSheetMateProfile(listEl) {
   var actions = [
     { icon: "book-open", label: "Knowledge", btnId: "mate-knowledge-btn", countId: "mate-knowledge-count" },
     { icon: "sticky-note", label: "Sticky Notes", btnId: "sticky-notes-sidebar-btn", countId: "sticky-notes-sidebar-count" },
-    { icon: "puzzle", label: "Skills", btnId: "mate-skills-btn" },
-    { icon: "calendar", label: "Scheduled Tasks", btnId: "mate-scheduler-btn" }
+    { icon: "puzzle", label: "Skills", btnId: "mate-skills-btn" }
   ];
 
   for (var i = 0; i < actions.length; i++) {
@@ -1005,12 +1004,11 @@ function renderSheetTools(listEl) {
     { icon: "brain", label: "Memory", action: "mate-memory" },
     { icon: "book-open", label: "Knowledge", action: "mate-knowledge" },
     { icon: "sticky-note", label: "Sticky Notes", action: "mate-sticky" },
-    { icon: "puzzle", label: "Skills", action: "mate-skills" },
-    { icon: "calendar-clock", label: "Scheduled Tasks", action: "mate-scheduler" }
+    { icon: "puzzle", label: "Skills", action: "mate-skills" }
   ] : [
     { icon: "folder-tree", label: "Files", action: "files" },
     { icon: "square-terminal", label: "Terminal", action: "terminal" },
-    { icon: "calendar-clock", label: "Scheduled Tasks", action: "scheduler" }
+    { icon: "notebook-tabs", label: "Logs", action: "project-logs" }
   ];
 
   for (var i = 0; i < items.length; i++) {
@@ -1025,8 +1023,8 @@ function renderSheetTools(listEl) {
           setTimeout(function () { openMobileSheet("files"); }, 250);
         } else if (item.action === "terminal") {
           openTerminal();
-        } else if (item.action === "scheduler") {
-          targetId = "scheduler-btn";
+        } else if (item.action === "project-logs") {
+          targetId = "project-logs-btn";
         } else if (item.action === "mate-knowledge") {
           setTimeout(function () { openMobileSheet("mate-knowledge"); }, 250);
           return;
@@ -1036,8 +1034,6 @@ function renderSheetTools(listEl) {
           targetId = "mate-skills-btn";
         } else if (item.action === "mate-memory") {
           targetId = "mate-memory-btn";
-        } else if (item.action === "mate-scheduler") {
-          targetId = "mate-scheduler-btn";
         } else if (item.action === "mate-debate") {
           targetId = "mate-debate-btn";
         }

package/lib/public/modules/sidebar-sessions.js

@@ -1376,8 +1376,29 @@ function renderSplitGroupItem(group, members) {
 
 // --- Main session list ---
 
+// Fingerprint of the last completed render: the whole session payload plus the
+// two store values this render also reads. Nothing is cherry-picked, so the
+// guard can only skip a frame that is byte-identical to what is already on
+// screen. A re-render triggered by other state (sessions === null) always
+// runs and resets the fingerprint afterwards.
+var lastRenderFingerprint = null;
+
+function sessionRenderFingerprint(sessions) {
+  try {
+    return JSON.stringify([sessions, store.get('splitGroups') || [], store.get('splitPanes') || null]);
+  } catch (e) {
+    return null;
+  }
+}
+
 export function renderSessionList(sessions) {
-  if (sessions) cachedSessions = sessions;
+  if (sessions) {
+    // A reconnect and a streaming turn both re-send this list unchanged;
+    // rebuilding the sidebar for an identical frame is what made it flicker.
+    var incoming = sessionRenderFingerprint(sessions);
+    if (incoming !== null && incoming === lastRenderFingerprint) return;
+    cachedSessions = sessions;
+  }
 
   // If mobile chat sheet is open, refresh it
   if (refreshMobileChatSheet) refreshMobileChatSheet();
@@ -1516,6 +1537,9 @@ export function renderSessionList(sessions) {
   refreshIcons();
   if (updatePageTitle) updatePageTitle();
   syncHeaderSearchUi();
+  // Recorded from the sessions actually rendered, so a null-argument re-render
+  // driven by other state refreshes the fingerprint rather than stranding it.
+  lastRenderFingerprint = sessionRenderFingerprint(cachedSessions);
 }
 
 // --- Search results ---

package/lib/public/modules/sidebar.js

@@ -1,4 +1,4 @@
-import { closeArchive } from './sticky-notes.js';
+import { closeNotesBrowser } from './sticky-notes-browser.js';
 import { closeScheduler } from './scheduler.js';
 import { initSidebarSessions } from './sidebar-sessions.js';
 import { focusFileTree } from './filebrowser.js';
@@ -23,7 +23,7 @@ export function syncResizeHandles() {
 }
 
 export function dismissOverlayPanels() {
-  closeArchive();
+  closeNotesBrowser();
   closeScheduler();
 }
 
@@ -119,7 +119,10 @@ export function initSidebar(_ctx) {
 
   // --- Panel switch (sessions / files / projects) ---
   var fileBrowserBtn = ctx.$("file-browser-btn");
-  var gitBtn = ctx.$("git-sidebar-btn");
+  // Git has no tool-palette tile. The repository placard's More control is
+  // the entry point into the same panel, with the same lifecycle.
+  var gitPlacard = ctx.$("git-placard");
+  var gitPlacardMore = ctx.$("git-placard-more");
   var projectsPanel = ctx.$("sidebar-panel-projects");
   var sessionsPanel = ctx.$("sidebar-panel-sessions");
   var filesPanel = ctx.$("sidebar-panel-files");
@@ -216,14 +219,23 @@ export function initSidebar(_ctx) {
       });
     });
   }
-  if (gitBtn) {
-    gitBtn.addEventListener("click", function () {
+  if (gitPlacardMore) {
+    gitPlacardMore.addEventListener("click", function () {
       if (gitPanel && !gitPanel.classList.contains("hidden")) {
         hideGitPanel(function () { showSessionsPanel(); });
       }
       else showGitPanel();
     });
   }
+  if (gitPlacard && gitPlacardMore) {
+    // Clicking the block itself is a pointer convenience only; it forwards to
+    // the More control so every listener bound there runs exactly once, and
+    // the keyboard path stays the single focusable button.
+    gitPlacard.addEventListener("click", function (event) {
+      if (event.target.closest("#git-placard-more")) return;
+      gitPlacardMore.click();
+    });
+  }
   if (gitPanelClose) {
     gitPanelClose.addEventListener("click", function () {
       hideGitPanel(function () { showSessionsPanel(); });

package/lib/public/modules/split-view.js

@@ -11,6 +11,7 @@ import { groupedSessionIds, findSplitGroup } from './split-group-helpers.js';
 import { showConfirm } from './app-misc.js';
 import { syncPairChrome } from './split-pair-ui.js';
 import { presentMarkdownEdit } from './filebrowser.js';
+import { autoStartLoginIfNeeded } from './vendor-login.js';
 
 var host = null;
 var nativeApp = null;
@@ -276,6 +277,12 @@ function handlePaneMessage(event) {
     if (present) presentMarkdownEdit(present);
     return;
   }
+  // Both panes can report auth_required for their own sessions. The shell runs
+  // one login flow for the project; repeat events are no-ops there.
+  if (msg.type === "clay-pane-auth-required") {
+    if (msg.message) autoStartLoginIfNeeded(msg.message);
+    return;
+  }
   if (msg.type !== "clay-pane-context") return;
   var frames = host.querySelectorAll(".split-pane-frame");
   for (var i = 0; i < frames.length; i++) {

package/lib/public/modules/sticky-notes-browser.js

@@ -0,0 +1,324 @@
+// Sticky Notes browser: the bounded right workbench window over the board.
+//
+// This is the index/viewer surface, not the floating cards. The cards stay on
+// the canvas over the conversation; this pane lists them, splits them into Open
+// and Closed, and is where a note is completed or brought back.
+//
+// Completion here is Close, never delete. A closed note leaves the active
+// canvas and moves to the Closed tab, where it stays readable and reversible.
+// There is deliberately no destructive control on this surface at all.
+
+import { store } from './store.js';
+import { iconHtml, refreshIcons } from './icons.js';
+import { renderMiniMarkdown, getTitle } from './sticky-note-markdown.js';
+import { send } from './sticky-notes-shared.js';
+import { listNoteData, focusNoteOnCanvas, hideNotes, showNotes } from './sticky-notes.js';
+
+var panel = null;
+var gridEl = null;
+var tabsEl = null;
+
+// Registered by app.js so this module never imports the other right-pane tools
+// and cannot form an import cycle with them.
+var exclusiveClosers = [];
+
+export function registerExclusiveClosers(fns) {
+  exclusiveClosers = (fns || []).filter(function (fn) { return typeof fn === "function"; });
+}
+
+function closeOtherRightTools() {
+  for (var i = 0; i < exclusiveClosers.length; i++) {
+    try { exclusiveClosers[i](); } catch (e) { /* a missing tool must not block opening */ }
+  }
+}
+
+function isClosed(data) {
+  if (!data) return false;
+  if (data.state === "closed") return true;
+  if (data.state === "open") return false;
+  // Legacy notes predate the state field; `hidden` was the old spelling.
+  return data.hidden === true;
+}
+
+export function openNotes(all) {
+  return (all || []).filter(function (data) { return !isClosed(data); });
+}
+
+export function closedNotes(all) {
+  return (all || []).filter(isClosed);
+}
+
+function currentTab() {
+  return store.get('notesBrowserTab') === "closed" ? "closed" : "open";
+}
+
+// --- Panel ---------------------------------------------------------------
+
+function ensurePanel() {
+  if (panel) return;
+  var panels = document.getElementById("main-panels");
+  if (!panels) return;
+  panel = document.createElement("section");
+  panel.id = "notes-browser";
+  panel.className = "notes-browser hidden";
+  panel.setAttribute("aria-label", "Sticky Notes");
+  panel.innerHTML =
+    '<header class="notes-browser-topbar">' +
+      '<span class="notes-browser-title">' + iconHtml("sticky-note") + 'Sticky Notes</span>' +
+      '<span class="notes-browser-subtitle">Open items on the board, and what has been closed</span>' +
+      '<div class="notes-browser-window-actions" aria-label="Sticky Notes window controls">' +
+        '<button id="notes-browser-wide" class="notes-browser-icon-btn" type="button" title="Widen panel" aria-label="Widen Sticky Notes panel" aria-pressed="false">' + iconHtml("chevrons-left-right") + '</button>' +
+        '<button id="notes-browser-fullscreen" class="notes-browser-icon-btn" type="button" title="Toggle fullscreen" aria-label="Toggle Sticky Notes fullscreen" aria-pressed="false">' + iconHtml("maximize-2") + '</button>' +
+        '<button id="notes-browser-close" class="notes-browser-icon-btn" type="button" title="Close Sticky Notes" aria-label="Close Sticky Notes">' + iconHtml("x") + '</button>' +
+      '</div>' +
+    '</header>' +
+    '<div id="notes-browser-tabs" class="notes-browser-tabs" role="tablist" aria-label="Sticky Notes state"></div>' +
+    '<div id="notes-browser-grid" class="notes-browser-grid" role="list"></div>';
+  panels.appendChild(panel);
+
+  gridEl = panel.querySelector("#notes-browser-grid");
+  tabsEl = panel.querySelector("#notes-browser-tabs");
+
+  panel.querySelector("#notes-browser-close").addEventListener("click", closeNotesBrowser);
+  panel.querySelector("#notes-browser-wide").addEventListener("click", function () {
+    applyWindowState(!store.get('notesBrowserWide'), store.get('notesBrowserFullscreen'));
+  });
+  panel.querySelector("#notes-browser-fullscreen").addEventListener("click", function () {
+    applyWindowState(store.get('notesBrowserWide'), !store.get('notesBrowserFullscreen'));
+  });
+  refreshIcons();
+}
+
+// Width and fullscreen are transient view state, so they live in the store.
+// `panel-fullscreen` is the shared class the document viewer, terminal, and
+// Logs already use, so the geometry is the established one.
+function applyWindowState(wide, fullscreen) {
+  store.set({ notesBrowserWide: !!wide, notesBrowserFullscreen: !!fullscreen });
+  if (!panel) return;
+  panel.classList.toggle("notes-browser-wide", !!wide && !fullscreen);
+  panel.classList.toggle("panel-fullscreen", !!fullscreen);
+  var wideBtn = panel.querySelector("#notes-browser-wide");
+  var fullBtn = panel.querySelector("#notes-browser-fullscreen");
+  if (wideBtn) {
+    wideBtn.setAttribute("aria-pressed", wide ? "true" : "false");
+    wideBtn.disabled = !!fullscreen;
+  }
+  if (fullBtn) fullBtn.setAttribute("aria-pressed", fullscreen ? "true" : "false");
+}
+
+// --- Tabs ----------------------------------------------------------------
+
+function renderTabs(openCount, closedCount) {
+  if (!tabsEl) return;
+  var active = currentTab();
+  tabsEl.innerHTML = "";
+  var specs = [
+    { key: "open", label: "Open", count: openCount },
+    { key: "closed", label: "Closed", count: closedCount },
+  ];
+  for (var i = 0; i < specs.length; i++) {
+    (function (spec) {
+      var tab = document.createElement("button");
+      tab.type = "button";
+      tab.className = "notes-browser-tab" + (spec.key === active ? " active" : "");
+      tab.setAttribute("role", "tab");
+      tab.setAttribute("aria-selected", spec.key === active ? "true" : "false");
+      tab.tabIndex = spec.key === active ? 0 : -1;
+      tab.dataset.tab = spec.key;
+      tab.innerHTML = '<span>' + spec.label + '</span><span class="notes-browser-tab-count">' + spec.count + '</span>';
+      tab.addEventListener("click", function () { selectTab(spec.key); });
+      tab.addEventListener("keydown", function (e) {
+        if (e.key !== "ArrowLeft" && e.key !== "ArrowRight") return;
+        e.preventDefault();
+        selectTab(spec.key === "open" ? "closed" : "open");
+        var next = tabsEl.querySelector('.notes-browser-tab.active');
+        if (next) next.focus();
+      });
+      tabsEl.appendChild(tab);
+    })(specs[i]);
+  }
+}
+
+function selectTab(key) {
+  store.set({ notesBrowserTab: key === "closed" ? "closed" : "open" });
+  renderNotesBrowser();
+}
+
+// --- Cards ---------------------------------------------------------------
+
+function closedMeta(data) {
+  var parts = [];
+  if (data.closedAt) {
+    var when = new Date(data.closedAt);
+    if (!isNaN(when.getTime())) parts.push("Closed " + when.toLocaleDateString());
+  } else {
+    parts.push("Closed");
+  }
+  var by = data.closedBy;
+  if (by && by.type === "user" && by.displayName) parts.push("by " + by.displayName);
+  else if (by && by.type === "session") parts.push("by an agent session");
+  return parts.join(" · ");
+}
+
+function buildCard(data) {
+  var card = document.createElement("article");
+  var closed = isClosed(data);
+  card.className = "notes-browser-card" + (closed ? " closed" : "");
+  card.setAttribute("role", "listitem");
+  card.dataset.color = data.color || "purple";
+  card.dataset.noteId = data.id;
+
+  var header = document.createElement("div");
+  header.className = "notes-browser-card-header";
+
+  var title = document.createElement("h3");
+  title.className = "notes-browser-card-title";
+  title.textContent = getTitle(data.text) || "Untitled";
+  header.appendChild(title);
+
+  // Exactly one lifecycle action per card, and it is never destructive.
+  var action = document.createElement("button");
+  action.type = "button";
+  action.className = "notes-browser-card-action";
+  if (closed) {
+    action.innerHTML = iconHtml("rotate-ccw") + "<span>Reopen</span>";
+    action.title = "Reopen this note and return it to the board";
+    action.setAttribute("aria-label", "Reopen note: " + title.textContent);
+    action.addEventListener("click", function (e) {
+      e.stopPropagation();
+      send({ type: "note_reopen", id: data.id });
+    });
+  } else {
+    action.innerHTML = iconHtml("check") + "<span>Close</span>";
+    action.title = "Close this note; it stays on record and can be reopened";
+    action.setAttribute("aria-label", "Close note: " + title.textContent);
+    action.addEventListener("click", function (e) {
+      e.stopPropagation();
+      send({ type: "note_close", id: data.id });
+    });
+  }
+  header.appendChild(action);
+  card.appendChild(header);
+
+  var body = document.createElement("div");
+  body.className = "notes-browser-card-body";
+  var bodyLines = (data.text || "").split("\n").slice(1).join("\n").trim();
+  if (bodyLines) {
+    body.innerHTML = renderMiniMarkdown("_\n" + bodyLines).replace('<div class="sn-title">_</div>', "");
+  }
+  card.appendChild(body);
+
+  if (closed) {
+    var meta = document.createElement("p");
+    meta.className = "notes-browser-card-meta";
+    meta.textContent = closedMeta(data);
+    card.appendChild(meta);
+  }
+
+  var strip = document.createElement("div");
+  strip.className = "notes-browser-card-color";
+  card.appendChild(strip);
+
+  // An open note can be jumped to on the canvas. A closed note has no card on
+  // the canvas, so reopening is the only way back and the body is read-only.
+  if (!closed) {
+    card.tabIndex = 0;
+    card.addEventListener("click", function () { focusNoteOnCanvas(data.id); });
+    card.addEventListener("keydown", function (e) {
+      if (e.key !== "Enter" && e.key !== " ") return;
+      e.preventDefault();
+      focusNoteOnCanvas(data.id);
+    });
+  }
+  return card;
+}
+
+function emptyState(tab) {
+  var empty = document.createElement("div");
+  empty.className = "notes-browser-empty";
+  if (tab === "closed") {
+    empty.innerHTML = iconHtml("check") +
+      "<p>Nothing closed yet</p>" +
+      "<p class=\"notes-browser-empty-sub\">Closing a note takes it off the board without deleting it. Anything you close shows up here and can be reopened.</p>";
+  } else {
+    empty.innerHTML = iconHtml("sticky-note") +
+      "<p>Keep what matters across sessions</p>" +
+      "<p class=\"notes-browser-empty-sub\">Use sticky notes for checklists, goals, handoffs, and durable project knowledge. You and every Clay agent can find them in future sessions.</p>";
+  }
+  return empty;
+}
+
+export function renderNotesBrowser() {
+  if (!gridEl) return;
+  var all = listNoteData();
+  var open = openNotes(all);
+  var closed = closedNotes(all);
+  renderTabs(open.length, closed.length);
+
+  var tab = currentTab();
+  var shown = tab === "closed" ? closed : open;
+  // Newest first. The id is timestamp-prefixed, so it orders by creation.
+  shown = shown.slice().sort(function (a, b) {
+    var left = String(a.id || "");
+    var right = String(b.id || "");
+    return left < right ? 1 : left > right ? -1 : 0;
+  });
+
+  gridEl.innerHTML = "";
+  if (shown.length === 0) {
+    gridEl.appendChild(emptyState(tab));
+    refreshIcons();
+    return;
+  }
+  for (var i = 0; i < shown.length; i++) gridEl.appendChild(buildCard(shown[i]));
+  refreshIcons();
+}
+
+// --- Lifecycle -----------------------------------------------------------
+
+// The conversation, composer, and title bar stay mounted and visible: the
+// browser opens beside them in the single right workbench slot.
+export function openNotesBrowser() {
+  ensurePanel();
+  if (!panel) return;
+  closeOtherRightTools();
+  // The floating canvas would otherwise sit on top of the pane.
+  hideNotes();
+  panel.classList.remove("hidden");
+  applyWindowState(store.get('notesBrowserWide'), false);
+  store.set({ notesBrowserOpen: true });
+  var sidebarBtn = document.getElementById("sticky-notes-sidebar-btn");
+  if (sidebarBtn) sidebarBtn.classList.add("active");
+  renderNotesBrowser();
+}
+
+export function closeNotesBrowser() {
+  if (!store.get('notesBrowserOpen')) return;
+  if (panel) panel.classList.add("hidden");
+  // Fullscreen is always dropped on close so the next open is a bounded pane.
+  applyWindowState(store.get('notesBrowserWide'), false);
+  store.set({ notesBrowserOpen: false });
+  var sidebarBtn = document.getElementById("sticky-notes-sidebar-btn");
+  if (sidebarBtn) sidebarBtn.classList.remove("active");
+  // The canvas comes back so the open notes are reachable again.
+  showNotes();
+}
+
+export function isNotesBrowserOpen() {
+  return !!store.get('notesBrowserOpen');
+}
+
+export function initNotesBrowser() {
+  document.addEventListener("keydown", function (e) {
+    if (e.key !== "Escape") return;
+    if (!store.get('notesBrowserOpen')) return;
+    closeNotesBrowser();
+  });
+  store.subscribe(function (state, previous) {
+    if (state.currentSlug === previous.currentSlug) return;
+    // A different project starts from a closed, bounded, Open-tab pane.
+    closeNotesBrowser();
+    applyWindowState(false, false);
+    store.set({ notesBrowserTab: "open" });
+  });
+}