clay-server 4.0.0-beta.2 → 4.0.0-beta.21

package/lib/public/modules/command-palette.js

@@ -6,6 +6,7 @@ import { showHomeHub, minimizeHomeHub } from './app-home-hub.js';
 import { openHomeConversation } from './home-mate-chat.js';
 import { startSearchClayChat, attachSearchClayChat, detachSearchClayChat, getSearchClayChatSummary } from './search-clay-chat.js';
 import { getWs } from './ws-ref.js';
+import { openProjectLog } from './project-logs.js';
 
 function formatRelativeDate(ts) {
   if (!ts) return "";
@@ -27,6 +28,7 @@ var ctx;
 var paletteEl = null, inputEl = null, resultsEl = null, footerEl = null;
 var activeIndex = -1, items = [], debounceTimer = null, abortCtrl = null;
 var pendingNav = null, cachedHomeData = [], cachedVersion = null;
+var pendingLogNav = null;
 var searchResults = [], searchQuery = "", searchPending = false, chatMode = false;
 
 export function initCommandPalette(value) {
@@ -52,43 +54,62 @@ export function initCommandPalette(value) {
 }
 
 function handleClaySessionLinkClick(event) {
-  var link = event.target.closest(".clayos-session-link");
+  var link = event.target.closest(".clayos-session-link, .clayos-log-link");
   if (!link || link.classList.contains("is-loading")) return;
+  event.preventDefault();
+  event.stopPropagation();
+  if (link.classList.contains("clayos-log-link") && !link.closest(".search-clay-chat, #home-mate-chat")) {
+    openProjectLog(link.dataset.logRef);
+    return;
+  }
   var ws = getWs();
   if (!ws || ws.readyState !== 1) {
     link.classList.add("is-error");
-    link.title = "Reconnect to open this session";
+    link.title = "Reconnect to open this item";
     return;
   }
-  var requestId = "clayos-session-" + Date.now() + "-" + Math.random().toString(36).slice(2, 9);
-  link.dataset.sessionRequest = requestId;
+  var isLog = link.classList.contains("clayos-log-link");
+  var requestId = "clayos-" + (isLog ? "log-" : "session-") + Date.now() + "-" + Math.random().toString(36).slice(2, 9);
+  if (isLog) link.dataset.logRequest = requestId;
+  else link.dataset.sessionRequest = requestId;
   link.classList.remove("is-error");
   link.classList.add("is-loading");
-  ws.send(JSON.stringify({
-    type: "home_clay_session_resolve",
-    requestId: requestId,
-    sessionRef: link.dataset.sessionRef,
-    surface: link.closest(".search-clay-chat") ? "search" : "home",
-  }));
+  var request = { requestId: requestId, surface: link.closest(".search-clay-chat") ? "search" : "home" };
+  if (isLog) {
+    request.type = "home_clay_log_resolve";
+    request.ref = link.dataset.logRef;
+  } else {
+    request.type = "home_clay_session_resolve";
+    request.sessionRef = link.dataset.sessionRef;
+  }
+  ws.send(JSON.stringify(request));
 }
 
 export function handleClaySessionTarget(msg) {
-  if (!msg || msg.type !== "home_clay_session_target") return false;
-  var links = document.querySelectorAll(".clayos-session-link[data-session-request]");
+  if (!msg || (msg.type !== "home_clay_session_target" && msg.type !== "home_clay_log_target")) return false;
+  var isLog = msg.type === "home_clay_log_target";
+  var links = document.querySelectorAll(isLog ? ".clayos-log-link[data-log-request]" : ".clayos-session-link[data-session-request]");
   var link = null;
-  for (var i = 0; i < links.length; i++) if (links[i].dataset.sessionRequest === msg.requestId) link = links[i];
+  for (var i = 0; i < links.length; i++) {
+    if ((isLog ? links[i].dataset.logRequest : links[i].dataset.sessionRequest) === msg.requestId) link = links[i];
+  }
   if (link) {
     link.classList.remove("is-loading");
-    delete link.dataset.sessionRequest;
+    if (isLog) delete link.dataset.logRequest;
+    else delete link.dataset.sessionRequest;
   }
   if (msg.status !== "ready" || !msg.target) {
     if (link) {
       link.classList.add("is-error");
-      link.title = msg.error || "Session not available";
+      link.title = msg.error || "Item not available";
     }
     return true;
   }
   closeCommandPalette();
+  if (isLog) {
+    navigateToLog(msg.target);
+    return true;
+  }
   if (msg.target.isMate && msg.target.mateId && msg.target.homeSessionId) {
     showHomeHub();
     openHomeConversation(msg.target.mateId, msg.target.homeSessionId);
@@ -129,6 +150,11 @@ export function closeCommandPalette() {
 export function setPaletteVersion(version) { cachedVersion = version; }
 
 export function handlePaletteSessionSwitch() {
+  if (pendingLogNav && ctx.currentSlug && ctx.currentSlug() === pendingLogNav.projectSlug) {
+    var logNav = pendingLogNav;
+    pendingLogNav = null;
+    openProjectLog(logNav.ref);
+  }
   if (!pendingNav) return;
   var nav = pendingNav;
   pendingNav = null;
@@ -138,6 +164,17 @@ export function handlePaletteSessionSwitch() {
   }
 }
 
+function navigateToLog(target) {
+  closeCommandPalette();
+  minimizeHomeHub();
+  if (ctx.currentSlug && ctx.currentSlug() === target.projectSlug) {
+    openProjectLog(target.ref);
+  } else {
+    pendingLogNav = { projectSlug: target.projectSlug, ref: target.ref };
+    ctx.switchProject(target.projectSlug);
+  }
+}
+
 function buildDOM() {
   paletteEl = document.createElement("div");
   paletteEl.className = "cmd-palette hidden";

package/lib/public/modules/context-sources.js

@@ -230,10 +230,8 @@ function getActiveSourceRowsHTML() {
 function renderChips() {
   // Update add button — show badge count when sources are active
   var addBtn = document.getElementById("context-sources-add");
-  var labelSpan = addBtn.querySelector(".ctx-label");
   var existingBadge = addBtn.querySelector(".ctx-badge");
   if (activeSourceIds.size > 0) {
-    if (labelSpan) labelSpan.style.display = "none";
     if (!existingBadge) {
       existingBadge = document.createElement("span");
       existingBadge.className = "ctx-badge";
@@ -251,7 +249,6 @@ function renderChips() {
     }
     addBtn.removeAttribute("title");
   } else {
-    if (labelSpan) { labelSpan.style.display = ""; }
     if (existingBadge) existingBadge.remove();
     addBtn.setAttribute("data-tip", "Add context sources");
     addBtn.removeAttribute("data-tip-html");

package/lib/public/modules/git-agent-sessions.js

@@ -0,0 +1,85 @@
+// git-agent-sessions.js — agent handoffs launched from the Git surface.
+//
+// Extracted from git-panel.js so that module stays under the size limit while
+// the Git data path (one status reading, one summary reading, one placard)
+// remains in a single place. This module owns only the "hand this over to a
+// focused agent session" concern, plus the small path/title helpers those
+// prompts and the panel's own file rows share, so neither is defined twice.
+
+import { store } from './store.js';
+import { showToast } from './utils.js';
+import { sendTextMessage } from './input.js';
+import { resolveDefaultVendor, startNewSession } from './sidebar-sessions.js';
+import { getWs } from './ws-ref.js';
+
+export function splitFilePath(filePath) {
+  var slash = filePath.lastIndexOf("/");
+  if (slash === -1) return { name: filePath, dir: "" };
+  return { name: filePath.slice(slash + 1), dir: filePath.slice(0, slash + 1) };
+}
+
+export function compactSessionTitle(title) {
+  var value = String(title || "Agent session").replace(/\s+/g, " ").trim();
+  if (/^Review the current uncommitted changes/i.test(value)) return "File review";
+  if (/^Create a Git commit for the currently staged changes/i.test(value)) return "Commit session";
+  return value;
+}
+
+// Close the Git surface through its own close control, which owns the panel's
+// exit animation and the return to the sessions panel. Going through the
+// existing control keeps one lifecycle rather than a second teardown path.
+export function closeGitSurface() {
+  var gitPanel = document.getElementById("sidebar-panel-git");
+  var closeBtn = document.getElementById("git-panel-close");
+  if (closeBtn && gitPanel && !gitPanel.classList.contains("hidden")) closeBtn.click();
+}
+
+function startFocusedAgentSession(prompt, successMessage, sessionTitle) {
+  if (!store.get('connected')) {
+    showToast("Not connected — agent session was not started.", "warn");
+    return;
+  }
+  var previousSessionId = store.get('activeSessionId');
+  var unsubscribe = null;
+  var sessionReady = false;
+  var timer = setTimeout(function () {
+    if (unsubscribe) unsubscribe();
+    showToast("Agent session could not be started", "warn");
+  }, 10000);
+  unsubscribe = store.subscribe(function (state) {
+    if (sessionReady || !state.activeSessionId || state.activeSessionId === previousSessionId) return;
+    sessionReady = true;
+    clearTimeout(timer);
+    setTimeout(function () {
+      if (unsubscribe) unsubscribe();
+      unsubscribe = null;
+      var newSessionId = store.get('activeSessionId');
+      var ws = getWs();
+      if (sessionTitle && ws && ws.readyState === WebSocket.OPEN && newSessionId) {
+        ws.send(JSON.stringify({ type: "rename_session", id: newSessionId, title: sessionTitle }));
+      }
+      closeGitSurface();
+      if (sendTextMessage(prompt)) showToast(successMessage || "Agent session started");
+    }, 0);
+  });
+  startNewSession(resolveDefaultVendor(), { mode: "gui", forceNew: true });
+}
+
+export function startAgentCommitSession(stagedCount) {
+  if (!stagedCount) return;
+  var prompt = "Create a Git commit for the currently staged changes.\n\n" +
+    "Inspect `git diff --cached` and the repository instructions before committing. " +
+    "Commit exactly the staged changes; do not stage additional files. " +
+    "Write a concise Angular Commit Convention message, use the angular-commit skill, " +
+    "and do not add Co-Authored-By lines. If nothing is staged, explain that and stop.";
+  startFocusedAgentSession(prompt, "Commit session started", "Commit staged changes");
+}
+
+export function startAgentFileReview(filePath) {
+  var prompt = "Review the current uncommitted changes in `" + filePath + "`.\n\n" +
+    "Inspect the Git diff and relevant repository context. Explain the intent of the change, " +
+    "identify correctness or regression risks, and suggest specific improvements. " +
+    "Do not edit files or run Git actions unless I ask in this session.";
+  var parts = splitFilePath(filePath);
+  startFocusedAgentSession(prompt, "File review session started", "Review · " + parts.name);
+}

package/lib/public/modules/git-panel.js

@@ -2,16 +2,41 @@ import { store } from './store.js';
 import { refreshIcons, iconHtml } from './icons.js';
 import { escapeHtml, showToast } from './utils.js';
 import { openWorkingTreeDiff } from './filebrowser.js';
-import { sendTextMessage } from './input.js';
-import { resolveDefaultVendor, startNewSession } from './sidebar-sessions.js';
 import { getWs } from './ws-ref.js';
+import { hideGitPlacard, mergeStatusIntoSummary, renderGitPlacard } from './git-placard.js';
+import {
+  closeGitSurface,
+  compactSessionTitle,
+  splitFilePath,
+  startAgentCommitSession,
+  startAgentFileReview
+} from './git-agent-sessions.js';
 
 var currentStatus = null;
+var currentSummary = null;
 var busy = false;
 var lastError = "";
 var statusBasePath = null;
 var expandedFileActionsPath = null;
 
+// One timer drives both readings so there is never a second poll. The full
+// status runs at the panel's existing cadence only while the panel is open;
+// with the panel closed the placard settles for the cheap summary at a much
+// slower cadence, and neither path ever does diff work.
+var POLL_MS = 2500;
+var SUMMARY_TICKS = 6;
+var summaryTicks = 0;
+
+// A project surface always has a /p/<slug>/ base path. Home and any surface
+// without a project must not issue a repository request at all.
+function hasProjectBasePath() {
+  return String(store.get('basePath') || "").indexOf("/p/") === 0;
+}
+
+function placardMounted() {
+  return !!document.getElementById("git-placard");
+}
+
 function apiPath(path) {
   return store.get('basePath') + "api/git/" + path;
 }
@@ -33,12 +58,6 @@ function shortOrigin(origin) {
     .replace(/\.git$/, "");
 }
 
-function splitFilePath(filePath) {
-  var slash = filePath.lastIndexOf("/");
-  if (slash === -1) return { name: filePath, dir: "" };
-  return { name: filePath.slice(slash + 1), dir: filePath.slice(0, slash + 1) };
-}
-
 function fileStatusLabel(file, staged) {
   if (file.conflicted) return "!";
   if (file.untracked) return "U";
@@ -46,13 +65,6 @@ function fileStatusLabel(file, staged) {
   return code === "." ? "M" : code;
 }
 
-function compactSessionTitle(title) {
-  var value = String(title || "Agent session").replace(/\s+/g, " ").trim();
-  if (/^Review the current uncommitted changes/i.test(value)) return "File review";
-  if (/^Create a Git commit for the currently staged changes/i.test(value)) return "Commit session";
-  return value;
-}
-
 function renderFileMeta(file, directory) {
   var sessions = Array.isArray(file.sessions) ? file.sessions : [];
   var first = sessions.length > 0 ? sessions[0] : null;
@@ -200,19 +212,54 @@ function render() {
   var stagedList = body.querySelector(".git-section-staged .git-file-list");
   if (changesList) changesList.scrollTop = changesScrollTop;
   if (stagedList) stagedList.scrollTop = stagedScrollTop;
-  updateBadge();
+  syncPlacard();
 }
 
-function updateBadge() {
-  var badge = document.getElementById("git-sidebar-count");
-  if (!badge) return;
-  if (!currentStatus || !currentStatus.isRepository) {
-    badge.classList.add("hidden");
+// The placard is a projection of whichever reading is current. A full status
+// supersedes the summary when it exists, so the two never disagree.
+function syncPlacard() {
+  if (!placardMounted()) return;
+  if (currentStatus && currentStatus.isRepository) {
+    currentSummary = mergeStatusIntoSummary(currentStatus, currentSummary);
+  }
+  if (!currentSummary || !currentSummary.isRepository) {
+    hideGitPlacard();
     return;
   }
-  var count = currentStatus.files.length;
-  badge.textContent = count > 99 ? "99+" : String(count);
-  badge.classList.toggle("hidden", count === 0);
+  renderGitPlacard(currentSummary);
+}
+
+// Cheap placard-only reading. Used on sidebar lifecycle (connect, reconnect,
+// project switch) and on the slow tick while the full panel is closed.
+export function refreshGitSummary() {
+  if (busy || !hasProjectBasePath() || !placardMounted()) return Promise.resolve(currentSummary);
+  var basePath = store.get('basePath');
+  return requestJson(basePath + "api/git/summary", { cache: "no-store" }).then(function (summary) {
+    if (store.get('basePath') !== basePath) return currentSummary;
+    currentSummary = summary && summary.isRepository ? summary : null;
+    syncPlacard();
+    return currentSummary;
+  }).catch(function () {
+    // An unavailable or forbidden repository shows nothing rather than an
+    // error placeholder; the full panel still reports errors when opened.
+    if (store.get('basePath') !== basePath) return currentSummary;
+    currentSummary = null;
+    syncPlacard();
+    return null;
+  });
+}
+
+// Project switch and reconnect both land here, so no stale repository ever
+// survives into another project and nothing flashes before detection lands.
+export function resetGitSurface() {
+  currentStatus = null;
+  currentSummary = null;
+  lastError = "";
+  expandedFileActionsPath = null;
+  statusBasePath = store.get('basePath');
+  summaryTicks = 0;
+  hideGitPlacard();
+  render();
 }
 
 export function refreshGitStatus() {
@@ -221,8 +268,10 @@ export function refreshGitStatus() {
   if (statusBasePath !== basePath) {
     statusBasePath = basePath;
     currentStatus = null;
+    currentSummary = null;
     lastError = "";
     expandedFileActionsPath = null;
+    hideGitPlacard();
     render();
   }
   var refreshBtn = document.getElementById("git-panel-refresh");
@@ -309,63 +358,7 @@ function returnToSession(sessionId) {
   var ws = getWs();
   if (!ws || ws.readyState !== WebSocket.OPEN || !sessionId) return;
   ws.send(JSON.stringify({ type: "switch_session", id: sessionId }));
-  var gitBtn = document.getElementById("git-sidebar-btn");
-  var gitPanel = document.getElementById("sidebar-panel-git");
-  if (gitBtn && gitPanel && !gitPanel.classList.contains("hidden")) gitBtn.click();
-}
-
-function startFocusedAgentSession(prompt, successMessage, sessionTitle) {
-  if (!store.get('connected')) {
-    showToast("Not connected — agent session was not started.", "warn");
-    return;
-  }
-  var previousSessionId = store.get('activeSessionId');
-  var unsubscribe = null;
-  var sessionReady = false;
-  var timer = setTimeout(function () {
-    if (unsubscribe) unsubscribe();
-    showToast("Agent session could not be started", "warn");
-  }, 10000);
-  unsubscribe = store.subscribe(function (state) {
-    if (sessionReady || !state.activeSessionId || state.activeSessionId === previousSessionId) return;
-    sessionReady = true;
-    clearTimeout(timer);
-    setTimeout(function () {
-      if (unsubscribe) unsubscribe();
-      unsubscribe = null;
-      var newSessionId = store.get('activeSessionId');
-      var ws = getWs();
-      if (sessionTitle && ws && ws.readyState === WebSocket.OPEN && newSessionId) {
-        ws.send(JSON.stringify({ type: "rename_session", id: newSessionId, title: sessionTitle }));
-      }
-      var gitBtn = document.getElementById("git-sidebar-btn");
-      var gitPanel = document.getElementById("sidebar-panel-git");
-      if (gitBtn && gitPanel && !gitPanel.classList.contains("hidden")) gitBtn.click();
-      if (sendTextMessage(prompt)) showToast(successMessage || "Agent session started");
-    }, 0);
-  });
-  startNewSession(resolveDefaultVendor(), { mode: "gui", forceNew: true });
-}
-
-function startAgentCommitSession() {
-  if (busy || !currentStatus) return;
-  var hasStaged = currentStatus.files.some(function (file) { return file.staged; });
-  if (!hasStaged) return;
-  var prompt = "Create a Git commit for the currently staged changes.\n\n" +
-    "Inspect `git diff --cached` and the repository instructions before committing. " +
-    "Commit exactly the staged changes; do not stage additional files. " +
-    "Write a concise Angular Commit Convention message, use the angular-commit skill, " +
-    "and do not add Co-Authored-By lines. If nothing is staged, explain that and stop.";
-  startFocusedAgentSession(prompt, "Commit session started", "Commit staged changes");
-}
-
-function startAgentFileReview(filePath) {
-  var prompt = "Review the current uncommitted changes in `" + filePath + "`.\n\n" +
-    "Inspect the Git diff and relevant repository context. Explain the intent of the change, " +
-    "identify correctness or regression risks, and suggest specific improvements. " +
-    "Do not edit files or run Git actions unless I ask in this session.";
-  var parts = splitFilePath(filePath);
-  startFocusedAgentSession(prompt, "File review session started", "Review \u00b7 " + parts.name);
+  closeGitSurface();
 }
 
 function toggleFileActions(fileMain) {
@@ -394,10 +387,32 @@ function toggleFileActions(fileMain) {
   }
 }
 
+// Sidebar lifecycle. A project switch resets everything and asks once; a
+// reconnect re-asks without resetting the surface the user is looking at.
+// Entering a Mate DM hides the placard, since that surface has no repository.
+function initGitLifecycle() {
+  statusBasePath = store.get('basePath');
+  store.subscribe(function (state, prev) {
+    if (state.basePath !== prev.basePath || state.currentSlug !== prev.currentSlug) {
+      resetGitSurface();
+      if (!state.dmMode) refreshGitSummary();
+      return;
+    }
+    if (state.dmMode !== prev.dmMode) {
+      if (state.dmMode) hideGitPlacard();
+      else refreshGitSummary();
+      return;
+    }
+    if (state.connected && !prev.connected && !state.dmMode) refreshGitSummary();
+  });
+  if (!store.get('dmMode')) refreshGitSummary();
+}
+
 export function initGitPanel() {
   var body = document.getElementById("git-panel-body");
   var refreshBtn = document.getElementById("git-panel-refresh");
   if (!body || !refreshBtn) return;
+  initGitLifecycle();
   refreshBtn.addEventListener("click", function () { refreshGitStatus(); });
   body.addEventListener("click", function (event) {
     var openDiff = event.target.closest("[data-git-open-diff]");
@@ -427,7 +442,9 @@ export function initGitPanel() {
     }
     var agentCommitButton = event.target.closest("[data-git-agent-commit]");
     if (agentCommitButton) {
-      if (!agentCommitButton.disabled) startAgentCommitSession();
+      if (!agentCommitButton.disabled && !busy && currentStatus) {
+        startAgentCommitSession(currentStatus.files.filter(function (file) { return file.staged; }).length);
+      }
       return;
     }
     var actionButton = event.target.closest("[data-git-action]");
@@ -451,6 +468,16 @@ export function initGitPanel() {
   });
   setInterval(function () {
     var panel = document.getElementById("sidebar-panel-git");
-    if (panel && !panel.classList.contains("hidden") && store.get('connected') && !busy) refreshGitStatus();
-  }, 2500);
+    var panelOpen = !!(panel && !panel.classList.contains("hidden"));
+    if (panelOpen) {
+      summaryTicks = 0;
+      if (store.get('connected') && !busy) refreshGitStatus();
+      return;
+    }
+    summaryTicks++;
+    if (summaryTicks < SUMMARY_TICKS) return;
+    summaryTicks = 0;
+    if (document.hidden || store.get('dmMode') || !store.get('connected') || busy) return;
+    refreshGitSummary();
+  }, POLL_MS);
 }

package/lib/public/modules/git-placard.js

@@ -0,0 +1,161 @@
+// git-placard.js — compact always-visible repository placard.
+//
+// Git is no longer a tool-palette tile. Instead, a real Git repository gets a
+// quiet placard directly under the tool strip in the project sidebar: repo
+// identity, current branch, and a bounded status glance. The placard is a
+// projection, never a second source of truth — git-panel.js owns the fetch and
+// hands data here, so there is exactly one Git request path in the client.
+//
+// The placard renders only server-derived, bounded fields. It never receives or
+// renders a repository path, and it stays hidden entirely until a real
+// repository is confirmed, so a non-Git project, an unavailable worktree, a
+// Home/Mate surface, or a still-pending detection shows nothing at all rather
+// than an empty placeholder.
+
+import { escapeHtml } from './utils.js';
+import { iconHtml, refreshIcons } from './icons.js';
+
+var lastRenderedHtml = "";
+var lastRenderedLabel = "";
+
+function countChangedFiles(files) {
+  var counts = { changed: 0, staged: 0, unstaged: 0, untracked: 0, conflicted: 0 };
+  var list = Array.isArray(files) ? files : [];
+  counts.changed = list.length;
+  for (var i = 0; i < list.length; i++) {
+    var file = list[i];
+    if (file.conflicted) counts.conflicted++;
+    if (file.untracked) counts.untracked++;
+    if (file.staged) counts.staged++;
+    if (file.unstaged && !file.untracked) counts.unstaged++;
+  }
+  return counts;
+}
+
+// Fold a full panel status into the placard shape. The panel status is the
+// fresher, more authoritative reading whenever it is available, so it wins for
+// branch and counts. `remote` is kept from the last server summary because the
+// label is derived server-side; the client never parses a remote URL itself.
+export function mergeStatusIntoSummary(status, previous) {
+  if (!status || !status.isRepository) return null;
+  var base = previous || {};
+  var counts = countChangedFiles(status.files);
+  return {
+    isRepository: true,
+    name: status.name || base.name || null,
+    branch: status.detached ? null : (status.branch || null),
+    detached: !!status.detached,
+    shortOid: status.oid ? String(status.oid).slice(0, 8) : (base.shortOid || null),
+    isWorktree: !!status.isWorktree,
+    hasUpstream: !!status.upstream,
+    ahead: status.ahead || 0,
+    behind: status.behind || 0,
+    changed: counts.changed,
+    staged: counts.staged,
+    unstaged: counts.unstaged,
+    untracked: counts.untracked,
+    conflicted: counts.conflicted,
+    remote: base.remote || null,
+  };
+}
+
+function branchLabel(summary) {
+  if (summary.detached) return summary.shortOid ? "Detached at " + summary.shortOid : "Detached HEAD";
+  return summary.branch || "No commits yet";
+}
+
+function changeLabel(summary) {
+  if (summary.conflicted > 0) {
+    return summary.conflicted + " conflicted";
+  }
+  if (summary.changed > 0) {
+    return summary.changed + " changed";
+  }
+  return "Clean";
+}
+
+// One plain-text sentence for assistive technology. The rendered rows are
+// marked aria-hidden so the group is announced once, in full, rather than as a
+// stream of bare numbers and glyphs.
+export function accessibleLabel(summary) {
+  if (!summary || !summary.isRepository) return "";
+  var parts = ["Repository " + (summary.name || "unknown")];
+  parts.push(summary.detached ? branchLabel(summary) : "branch " + branchLabel(summary));
+  if (summary.isWorktree) parts.push("linked worktree");
+  parts.push(summary.changed > 0 ? changeLabel(summary) + " files" : "working tree clean");
+  if (summary.hasUpstream && summary.ahead > 0) parts.push(summary.ahead + " ahead");
+  if (summary.hasUpstream && summary.behind > 0) parts.push(summary.behind + " behind");
+  if (summary.remote) parts.push("remote " + summary.remote);
+  return parts.join(", ");
+}
+
+function metaHtml(summary) {
+  var html = "";
+  if (summary.isWorktree) html += '<span class="git-placard-badge">Linked worktree</span>';
+  if (summary.detached) html += '<span class="git-placard-badge git-placard-badge-warn">Detached</span>';
+
+  var stateClass = "git-placard-stat";
+  if (summary.conflicted > 0) stateClass += " git-placard-stat-warn";
+  else if (summary.changed > 0) stateClass += " git-placard-stat-active";
+  html += '<span class="' + stateClass + '">' + escapeHtml(changeLabel(summary)) + '</span>';
+
+  if (summary.hasUpstream && summary.ahead > 0) {
+    html += '<span class="git-placard-stat" title="' + summary.ahead + ' to push">' +
+      iconHtml("arrow-up") + summary.ahead + '</span>';
+  }
+  if (summary.hasUpstream && summary.behind > 0) {
+    html += '<span class="git-placard-stat" title="' + summary.behind + ' to pull">' +
+      iconHtml("arrow-down") + summary.behind + '</span>';
+  }
+  return '<div class="git-placard-meta">' + html + '</div>';
+}
+
+function placardHtml(summary) {
+  var html = '<div class="git-placard-identity">' +
+    '<span class="git-placard-glyph">' + iconHtml("git-branch") + '</span>' +
+    '<span class="git-placard-names">' +
+      '<span class="git-placard-repo">' + escapeHtml(summary.name || "Repository") + '</span>' +
+      '<span class="git-placard-branch">' + escapeHtml(branchLabel(summary)) + '</span>' +
+    '</span>' +
+  '</div>';
+  html += metaHtml(summary);
+  if (summary.remote) {
+    html += '<div class="git-placard-remote">' + iconHtml("cloud") +
+      '<span>' + escapeHtml(summary.remote) + '</span></div>';
+  }
+  return html;
+}
+
+export function hideGitPlacard() {
+  var el = document.getElementById("git-placard");
+  var body = document.getElementById("git-placard-body");
+  lastRenderedHtml = "";
+  lastRenderedLabel = "";
+  if (body) body.innerHTML = "";
+  if (el) {
+    el.classList.add("hidden");
+    el.removeAttribute("aria-label");
+  }
+}
+
+export function renderGitPlacard(summary) {
+  var el = document.getElementById("git-placard");
+  var body = document.getElementById("git-placard-body");
+  if (!el || !body) return;
+  if (!summary || !summary.isRepository) {
+    hideGitPlacard();
+    return;
+  }
+  var html = placardHtml(summary);
+  if (html !== lastRenderedHtml) {
+    body.innerHTML = html;
+    lastRenderedHtml = html;
+    refreshIcons();
+  }
+  var label = accessibleLabel(summary);
+  if (label !== lastRenderedLabel) {
+    el.setAttribute("aria-label", label);
+    lastRenderedLabel = label;
+  }
+  el.classList.remove("hidden");
+}