synabun 2.1.0 → 2.2.1

package/neural-interface/public/shared/context-menu-model.js

@@ -90,6 +90,7 @@ export const OPEN_ENTRIES = [
   { id: 'open-claude-panel', key: 'claudePanel', action: 'toggle-claude-panel', active: 'topright-claude-panel-btn', appIcon: 'menu-terminal-claude', icon: 'panel' },
   { id: 'open-codex-panel', key: 'codexPanel', press: 'topright-codex-panel-btn', active: 'topright-codex-panel-btn', appIcon: 'menu-terminal-codex', icon: 'panel' },
   { id: 'open-opencode-panel', key: 'opencodePanel', press: 'topright-opencode-panel-btn', active: 'topright-opencode-panel-btn', appIcon: 'menu-terminal-opencode', icon: 'panel' },
+  { id: 'open-antigravity-panel', key: 'antigravityPanel', press: 'topright-antigravity-panel-btn', active: 'topright-antigravity-panel-btn', appIcon: 'menu-terminal-antigravity', icon: 'panel' },
   null,
   { id: 'open-terminal', key: 'terminal', event: ['terminal:open', { profile: 'shell' }], perm: 'terminal', appIcon: 'menu-terminal-shell', icon: 'terminal' },
   { id: 'open-claude-terminal', key: 'claudeTerminal', action: 'launch-claude', perm: 'terminal', icon: 'terminal' },

package/neural-interface/public/shared/cp/cp-permissions.js

@@ -16,6 +16,16 @@ import {
 const ICON_CHECK = '<svg viewBox="0 0 16 16" width="11" height="11" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M3 8.5l3.5 3.5 6.5-7"/></svg>';
 const ICON_X = '<svg viewBox="0 0 16 16" width="11" height="11" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"><line x1="4" y1="4" x2="12" y2="12"/><line x1="12" y1="4" x2="4" y2="12"/></svg>';
 
+// A waiting card's spinning border (.cp-spin-ring in ui-claude-panel.js): a box the compositor turns
+// under the ring's mask while the card is .active-perm. The card's first child.
+function spinRing() {
+  const ring = document.createElement('span');
+  ring.className = 'cp-spin-ring';
+  ring.setAttribute('aria-hidden', 'true');
+  ring.appendChild(document.createElement('i'));
+  return ring;
+}
+
 // Modes, rule suggestions and the prompt's context are decided in
 // cp-permission-model.js (DOM-free, tested); this file renders them.
 export const PERMISSION_MODES = ALL_PERMISSION_MODES;
@@ -100,6 +110,7 @@ export function renderPermissionCard(tab, requestId, req, hooks) {
   const card = document.createElement('div');
   card.className = 'perm-card active-perm cp-perm-card';
   card.dataset.requestId = requestId;
+  card.appendChild(spinRing());
   if (ctx.toolUseId) card.dataset.toolUseId = ctx.toolUseId;
 
   const hdr = document.createElement('div');
@@ -283,6 +294,7 @@ export function renderElicitationCard(tab, requestId, req, hooks) {
   const card = document.createElement('div');
   card.className = 'perm-card active-perm cp-perm-card cp-elicit-card';
   card.dataset.requestId = requestId;
+  card.appendChild(spinRing());
   if (req.elicitation_id) card.dataset.elicitationId = req.elicitation_id;
 
   const hdr = document.createElement('div');

package/neural-interface/public/shared/cp/cp-restore.js

@@ -6,6 +6,7 @@
 
 import { normalizeSession } from './cp-session-model.js';
 import { TOOL_POLICIES, BYPASS_MODE } from './cp-permission-model.js';
+import { applyTaskTool } from './cp-tool-results.js';
 
 const ACCOUNT_ID = /^[A-Za-z0-9_-]{1,64}$/;
 const PERMISSION_MODES = new Set(['default', 'acceptEdits', 'plan', 'bypassPermissions', 'dontAsk', 'auto']);
@@ -222,3 +223,164 @@ export function pagerState(dataset, labelText = '') {
   if (!Number.isInteger(start) || !Number.isInteger(total) || start <= 0 || total <= start) return null;
   return { start, total };
 }
+
+/**
+ * Split a history page into `{ head, tail }` so the visible tail (~40 rows) can
+ * paint and scroll immediately while earlier rows prepend in chunked tasks.
+ * Never splits an `assistant` `tool_use` from its matching `tool_result`.
+ */
+export function splitHistoryTail(messages, tailSize = 40) {
+  const list = Array.isArray(messages) ? messages : [];
+  const cap = Math.max(1, Number(tailSize) || 40);
+  if (list.length <= Math.ceil(cap * 1.5)) return { head: [], tail: list };
+  let cut = list.length - cap;
+  const indexOfToolUse = new Map();
+  for (let i = 0; i < list.length; i++) {
+    const m = list[i];
+    if (m?.role === 'assistant' && Array.isArray(m.tools)) {
+      for (const t of m.tools) if (t?.id) indexOfToolUse.set(String(t.id), i);
+    }
+  }
+  for (let i = cut; i < list.length; i++) {
+    const m = list[i];
+    if (m?.role === 'tool_result' && m.toolUseId) {
+      const ownerIdx = indexOfToolUse.get(String(m.toolUseId));
+      if (ownerIdx !== undefined && ownerIdx < cut) cut = ownerIdx;
+    }
+  }
+  while (cut > 0 && list[cut]?.role === 'tool_result') cut--;
+  if (cut <= 0) return { head: [], tail: list };
+  return { head: list.slice(0, cut), tail: list.slice(cut) };
+}
+
+/**
+ * Chronologically replay TaskCreate / TaskUpdate / TaskList results from a
+ * history page so tail-first DOM rendering still preserves exact todo order.
+ */
+export function replayTodosFromMessages(messages, initialTodos = []) {
+  const list = Array.isArray(messages) ? messages : [];
+  const calls = new Map();
+  for (const m of list) {
+    if (m?.role === 'assistant' && Array.isArray(m.tools)) {
+      for (const t of m.tools) {
+        if (t?.id && (t.name === 'TaskCreate' || t.name === 'TaskUpdate' || t.name === 'TaskList')) {
+          calls.set(String(t.id), t);
+        }
+      }
+    }
+  }
+  if (!calls.size) return null;
+  let todos = Array.isArray(initialTodos) ? initialTodos : [];
+  let changed = false;
+  for (const m of list) {
+    if (m?.role !== 'tool_result' || m.isError || !m.toolUseId) continue;
+    const call = calls.get(String(m.toolUseId));
+    if (!call) continue;
+    const next = applyTaskTool(todos, call.name, call.input || {}, m.structured);
+    if (next) {
+      todos = next;
+      changed = true;
+    }
+  }
+  return changed ? todos : null;
+}
+
+// ── One transcript container, several history loads ──
+// A container can be asked for its history more than once while a load is still
+// running (a restored tab shown while its reattach says "resynced", an in-tab
+// session switch). Loads of one container run one after the other, and only the
+// newest asked for renders; rows a rebuild put in are marked so the next one
+// takes them out instead of appending a second copy after them. Rows that came
+// live stay, after the history.
+
+/** The property a history row carries: the load (ticket) that rendered it. */
+export const HISTORY_ROW = '_cpHistoryRow';
+
+export function markHistoryRows(nodes, ticket) {
+  for (const n of nodes || []) if (n && typeof n === 'object') n[HISTORY_ROW] = ticket;
+}
+
+/** Rows an earlier rebuild (finished, aborted, or a snapshot put back) left in the container. */
+export function earlierHistoryRows(children, ticket) {
+  return [...(children || [])].filter((n) => n && n[HISTORY_ROW] != null && n[HISTORY_ROW] !== ticket);
+}
+
+/** Rows that came live: no history mark and not the empty-state placeholder. */
+export function liveRows(children) {
+  return [...(children || [])].filter((n) => n && n[HISTORY_ROW] == null && !n.classList?.contains?.('cp-empty'));
+}
+
+/**
+ * Starts a load of `$msgs`: it waits for the one running there and is skipped when
+ * a newer load was asked for meanwhile. `run(isStale)` does the work; `isStale()`
+ * is true as soon as a newer load was asked for (the running one stops at its next
+ * yield). Returns the promise of this load.
+ */
+export function queueHistoryLoad(container, run) {
+  const ticket = (container._historyTicket || 0) + 1;
+  container._historyTicket = ticket;
+  const isStale = () => container._historyTicket !== ticket;
+  const prev = container._historyChain || Promise.resolve();
+  const job = prev.catch(() => {}).then(() => (isStale() ? undefined : run(isStale, ticket)));
+  container._historyChain = job;
+  return job;
+}
+
+// Messages that put rows in a transcript. One of these for a restored tab whose
+// history is still deferred loads that history first; while any history load of
+// the tab runs, they wait in the tab's buffer, so the history always comes first.
+const TRANSCRIPT_MESSAGES = new Set(['event', 'turn_started', 'stderr', 'done', 'aborted', 'error']);
+
+/** 'load' (start the deferred history, then hold the message), 'hold', or 'pass'. */
+export function historyGate(tab, msg, bypass = false) {
+  if (!tab || bypass) return 'pass';
+  const deferred = !!tab._historyDeferred && tab._historyDeferred === tab.sessionId && !tab.automationRunId;
+  if (deferred && TRANSCRIPT_MESSAGES.has(msg?.type)) return 'load';
+  if (tab._historyHold > 0) return 'hold';
+  return 'pass';
+}
+
+/**
+ * A live tool result whose card a running replay has not rendered yet (it sits in
+ * a head chunk still to come) is kept here and applied when the card is built.
+ */
+export function holdPendingResult(tab, ev) {
+  if (!tab || !ev?.tool_use_id || !(tab._historyRendering > 0) || tab._replayRow) return false;
+  if (!(tab._pendingResults instanceof Map)) tab._pendingResults = new Map();
+  tab._pendingResults.set(String(ev.tool_use_id), ev);
+  return true;
+}
+
+export function takePendingResult(tab, toolUseId) {
+  const map = tab?._pendingResults;
+  if (!(map instanceof Map) || !toolUseId) return null;
+  const ev = map.get(String(toolUseId)) || null;
+  if (ev) map.delete(String(toolUseId));
+  return ev;
+}
+
+/** Whether a task tool's result may change the todo list now (a replayed one is in the precomputed list). */
+export function taskResultAppliesTodos(tab, ev) {
+  if (!tab || tab._agentScope || ev?.is_error) return false;
+  return !(tab._skipReplayTodos && tab._replayRow);
+}
+
+/**
+ * Renders `rows` with `render(row)` (which appends to `container`), marks the
+ * nodes it added as load `ticket`'s and moves them before `before` (a live row,
+ * or the first row of the tail already shown), so rows already on screen are
+ * never moved or rebuilt: the browser's scroll anchoring keeps a reader who
+ * scrolled up where they were while older rows go in above. `skip` holds nodes
+ * that are never taken as added (the live rows). Returns the added nodes.
+ */
+export function renderHistoryRowsInto(container, rows, render, { before = null, ticket = null, skip = null } = {}) {
+  const marker = container.lastElementChild;
+  for (const row of rows || []) render(row);
+  const added = [];
+  for (let n = marker ? marker.nextElementSibling : container.firstElementChild; n; n = n.nextElementSibling) {
+    if (!skip || !skip.has(n)) added.push(n);
+  }
+  markHistoryRows(added, ticket);
+  if (before && before.parentNode === container) for (const n of added) container.insertBefore(n, before);
+  return added;
+}

package/neural-interface/public/shared/cp/cp-tool-cards.js

@@ -3,6 +3,7 @@
 // puts that on the card. Live tool results and replayed history take the same
 // path, so a reopened session looks like the live one did.
 
+import { taskResultAppliesTodos } from './cp-restore.js';
 import { cpCtx } from './cp-ctx.js';
 import { escapeHtml } from './cp-markdown.js';
 import {
@@ -212,11 +213,12 @@ export function applyStructuredResult(tab, card, ev) {
     body.appendChild(stats);
   }
   // The task tools keep the list the todo dock shows (root conversation only).
-  if (!tab._agentScope && !ev.is_error) {
+  // A replayed result is already in the list the replay computed; a live one is applied over it.
+  if (taskResultAppliesTodos(tab, ev)) {
     const next = applyTaskTool(tab.todos, name, input, ev.tool_use_result);
     if (next) {
       tab.todos = next;
-      try { cpCtx.renderTodoWidget(tab); } catch {}
+      if (!tab._replaying) { try { cpCtx.renderTodoWidget(tab); } catch {} }
     }
   }
   return { view, content: view.content };
@@ -285,7 +287,12 @@ export function buildHistoryPlanCard(block) {
 
 /** A replayed result for one of the two cards above. True when it was one of them. */
 export function fillHistoryCard($msgs, row) {
-  const card = $msgs.querySelector(`.cp-history-card[data-tool-id="${CSS.escape(String(row.toolUseId || ''))}"]`);
+  const id = String(row.toolUseId || '');
+  let card = null;
+  // A replay indexes the cards it builds (no selector scan per result); a card it did not build is looked up.
+  const indexed = $msgs?._replayCards instanceof Map ? $msgs._replayCards.get(id) : null;
+  if (indexed) card = indexed.classList?.contains('cp-history-card') ? indexed : null;
+  else card = $msgs.querySelector(`.cp-history-card[data-tool-id="${CSS.escape(id)}"]`);
   if (!card) return false;
   if (card.classList.contains('cp-ask-history')) {
     const rows = askAnswerRows(card._toolInput, row.structured, row.isError ? '' : (row.text || ''));

package/neural-interface/public/shared/desktop-bridge.js

@@ -48,3 +48,20 @@ export function desktopWindow(win = globalThis.window) {
   if (!facts || facts.style !== 'overlay' || !['darwin', 'win32', 'linux'].includes(facts.platform)) return null;
   return api;
 }
+
+/** True on Windows (desktop bridge platform `'win32'`, or Windows browser/window navigator). */
+export function isWindowsPlatform(win = globalThis.window) {
+  const platform = desktopBridge(win)?.platform;
+  if (typeof platform === 'string' && platform) return platform === 'win32';
+  try {
+    const nav = win?.navigator ?? globalThis.navigator;
+    if (!nav || typeof nav !== 'object') return false;
+    const uaPlatform = nav.userAgentData?.platform;
+    if (typeof uaPlatform === 'string' && uaPlatform) return /^win/i.test(uaPlatform);
+    if (typeof nav.platform === 'string' && nav.platform) return /^win/i.test(nav.platform);
+    if (typeof nav.userAgent === 'string' && nav.userAgent) return /\bwindows\b/i.test(nav.userAgent);
+  } catch {
+    return false;
+  }
+  return false;
+}

package/neural-interface/public/shared/desktop-titlebar-view.js

@@ -197,3 +197,15 @@ export function drawnUnderBar(style, barLevel) {
   const level = Number.isFinite(z) ? (positioned ? z : Math.max(z, 0)) : 0;
   return level < barLevel;
 }
+
+/**
+ * True for a body-level overlay that never receives pointer events on itself or any child (such as `.ui-tooltip` or
+ * `#synabun-desktop-drag-strip`), so its hover/move mutations can never cover the bar's drag region.
+ */
+export function isPassiveOverlay(node) {
+  if (!node || typeof node !== 'object') return false;
+  if (node.id === 'synabun-desktop-drag-strip') return true;
+  if (typeof node.classList?.contains === 'function' && node.classList.contains('ui-tooltip')) return true;
+  const cls = typeof node.className === 'string' ? node.className : '';
+  return /(?:^|\s)ui-tooltip(?:\s|$)/.test(cls);
+}

package/neural-interface/public/shared/desktop-titlebar.js

@@ -27,7 +27,7 @@
 
 import { desktopWindow } from './desktop-bridge.js';
 import { colorSender, textTone } from './desktop-titlebar-page.js';
-import { barCovered, changedClasses, drawnUnderBar, fallbackTitlebarArea, overlayColorsFor, stackLevel, styleChange, titleBarActive } from './desktop-titlebar-view.js';
+import { barCovered, changedClasses, drawnUnderBar, fallbackTitlebarArea, isPassiveOverlay, overlayColorsFor, stackLevel, styleChange, titleBarActive } from './desktop-titlebar-view.js';
 import { t } from './i18n.js';
 
 const MENU_ICON = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M4 7h16"/><path d="M4 12h16"/><path d="M4 17h16"/></svg>';
@@ -52,6 +52,7 @@ export function initDesktopTitleBar({ doc = document, view = window } = {}) {
   const facts = api.titleBar;
   const html = doc.documentElement;
   html.classList.add('desktop-titlebar', `desktop-titlebar--${facts.platform}`);
+  if (facts.platform === 'win32') html.classList.add('platform-win32');
   const wco = view.navigator?.windowControlsOverlay || null;
   let state = { maximized: false, fullScreen: false, focused: true };
   const send = colorSender(api, doc);
@@ -168,14 +169,22 @@ export function initDesktopTitleBar({ doc = document, view = window } = {}) {
     return null;
   };
   const hasElement = (nodes) => { for (const node of nodes || []) if (node?.nodeType === 1) return true; return false; };
+  const onlyPassiveElements = (nodes) => {
+    for (const node of nodes || []) if (node?.nodeType === 1 && !isPassiveOverlay(node)) return false;
+    return true;
+  };
   // Each change → [IGNORE | SOON | NOW, whether the bar has to be measured].
   const QUIET = [IGNORE, false];
   const childListChange = (record) => {
     if (!hasElement(record.addedNodes) && !hasElement(record.removedNodes)) return QUIET; // text
     const target = record.target;
-    if (target === body) { judgeAgain(); return [NOW, true]; } // an overlay's root; a sibling selector may match anew
+    if (target === body) {
+      if (onlyPassiveElements(record.addedNodes) && onlyPassiveElements(record.removedNodes)) return QUIET;
+      judgeAgain();
+      return [NOW, true]; // an overlay's root; a sibling selector may match anew
+    }
     const part = partOf(target);
-    if (!part || part === bar) return QUIET; // off the page, or what the bar holds: that counts as the bar
+    if (!part || part === bar || isPassiveOverlay(part)) return QUIET; // off the page, passive tooltip, or inside the bar
     toJudge.add(part);
     if (target === part) return [NOW, true]; // an overlay's root got or lost a child (:empty, :has() can show it)
     return [SOON, !underBar.has(part)];
@@ -189,7 +198,7 @@ export function initDesktopTitleBar({ doc = document, view = window } = {}) {
       return [NOW, true];
     }
     const part = partOf(target);
-    if (!part) return QUIET;
+    if (!part || isPassiveOverlay(part)) return QUIET;
     if (part === bar) return target === bar ? [NOW, true] : QUIET;
     toJudge.add(part);
     // Shown, hidden or restacked: on the next frame; only moved, sized or repainted: at the throttled pace. Inside a

package/neural-interface/public/shared/desktop-update-view.js

@@ -87,6 +87,7 @@ export const DESKTOP_COPY = Object.freeze({
     'claude-panel': 'a Claude Code panel reply',
     'codex-panel': 'a Codex panel reply',
     'opencode-panel': 'an OpenCode panel reply',
+    'antigravity-panel': 'an Antigravity panel reply',
     'claude-cli': 'a Claude Code session in use',
     loop: 'a loop',
     schedule: 'a schedule',

package/neural-interface/public/shared/explorer/fx-api.js

@@ -96,15 +96,15 @@ export function createExplorerApi({ fetchImpl = (...args) => fetch(...args), Eve
     return old.ok ? fromLegacySearch(old) : old;
   }
 
-  async function git(root) {
+  async function git(root, signal, refresh = false) {
     await capabilities();
-    if (caps.explorer) return request(`/api/explorer/git?root=${encodeURIComponent(root)}`);
-    const old = await request(`/api/git/status?path=${encodeURIComponent(root)}`);
+    if (caps.explorer) return request(`/api/explorer/git?root=${encodeURIComponent(root)}${refresh ? '&refresh=1' : ''}`, { signal });
+    const old = await request(`/api/git/status?path=${encodeURIComponent(root)}${refresh ? '&refresh=1' : ''}`, { signal });
     if (!old.ok) return old;
     if (!old.isGit) return { ok: true, isGit: false };
     const changes = {};
     for (const change of old.changes || []) if (change?.path) changes[change.path] = change.status;
-    return { ok: true, isGit: true, branch: old.branch || '', changes, ignored: [], legacy: true };
+    return { ok: true, isGit: true, branch: old.branch || '', changes, ignored: [], legacy: true, ...(old.partial ? { partial: true, scanState: old.scanState } : {}) };
   }
 
   async function create(parent, name, type) {

package/neural-interface/public/shared/explorer/fx-links.js

@@ -110,13 +110,13 @@ export function createEditorLink({ openFile, save, tabs, repoint, subscribe, onC
 
 // ── The agents ──
 
-export const SEND_TARGETS = Object.freeze(['claude', 'codex', 'opencode', 'assistant']);
-const TARGET_NAMES = { claude: 'Claude Code', codex: 'Codex', opencode: 'OpenCode' };
+export const SEND_TARGETS = Object.freeze(['claude', 'codex', 'opencode', 'antigravity', 'assistant']);
+const TARGET_NAMES = { claude: 'Claude Code', codex: 'Codex', opencode: 'OpenCode', antigravity: 'Antigravity' };
 
 /**
  * @param {object} o
  * @param {object} o.deps what each panel offers: `sendToFocusedSession(kind, data)`, `claude(path)`, `codex(path)`,
- *   `opencode(path)`, `assistant(path)`, and `lastActive()` (the panel used last)
+ *   `opencode(path)`, `antigravity(path)`, `assistant(path)`, and `lastActive()` (the panel used last)
  * @param {(key: string, params?: object) => string} o.t
  */
 export function createSender({ deps, t }) {

package/neural-interface/public/shared/explorer/fx-logic.js

@@ -56,7 +56,7 @@ export function sameListing(a, b) {
   if (!a || !b || a.length !== b.length) return false;
   for (let i = 0; i < a.length; i++) {
     const x = a[i]; const y = b[i];
-    if (x.name !== y.name || x.type !== y.type || x.size !== y.size || x.mtime !== y.mtime || !!x.link !== !!y.link || !!x.outside !== !!y.outside || !!x.broken !== !!y.broken) return false;
+    if (x.name !== y.name || x.type !== y.type || x.size !== y.size || x.mtime !== y.mtime || !!x.link !== !!y.link || !!x.outside !== !!y.outside || !!x.broken !== !!y.broken || !!x.ignored !== !!y.ignored || (x.ignored === null) !== (y.ignored === null)) return false;
   }
   return true;
 }

package/neural-interface/public/shared/explorer/fx-main.js

@@ -48,7 +48,9 @@ const EXPAND_LEVEL_MAX = 200;
  * @param {object} host.send what each side panel offers for a path (fx-links.js createSender)
  * @param {(name: string) => object} host.fileIcon @param {string} host.folderSvg
  * @param {{ all: { hex: string, key: string }[], of: (path: string) => string | undefined, set: Function, move: Function }} host.colors
- * @param {(git: { isGit: boolean, branch: string, count: number }) => void} host.onGit
+ * @param {(git: { isGit: boolean, branch: string, count: number, scanState?: 'ready' | 'scanning' | 'timed-out' | 'failed',
+ *   shown?: boolean, loud?: boolean }) => void} host.onGit `shown`: a result of this project is already on screen;
+ *   `loud`: the scan is the project's first or one the owner asked for (Refresh), not a background one.
  * @param {() => void} host.addProject
  * @param {typeof fetch} [host.fetchImpl]
  */
@@ -77,7 +79,10 @@ export function createExplorer(host) {
   let watcher = null;
   let saidLimited = false;      // this project was told once that not everything on disk is followed
   let loaded = Promise.resolve();
-  let gitTimer = 0; let gitBusy = false; let gitAgain = false; let lastGitAt = 0;
+  let gitTimer = 0; let gitRequest = null; let gitRefresh = false; let gitAgain = false; let lastGitAt = 0;
+  // gitShown: a result of this project is on screen. gitLoud: the owner asked (Refresh), so a slow scan may say so.
+  // gitSettled: the last state a scan ended in, put back when a scan that said 'scanning' is called off.
+  let gitShown = false; let gitLoud = false; let gitSettled = 'ready';
   let diskTimer = 0; let lastDiskAt = 0; const diskDue = new Set();
   let filterTimer = 0; let searchAbort = null;
   let persistTimer = 0; let lastFocusRefresh = 0;
@@ -114,18 +119,20 @@ export function createExplorer(host) {
     const ed = editor.state();
     const status = item.missing ? 'deleted' : S.git.statusOf(below, isDir);
     const tone = item.missing ? 'deleted' : S.git.toneOf(below, isDir);
-    const ignored = S.git.isIgnored(below);
+    const ignored = !!item.ignored || S.git.isIgnored(below);
+    const ignoreUnknown = item.ignored === null && !ignored;
     const open = !isDir && ed.open.has(path);
     const dirty = !isDir && ed.dirty.has(path);
     const cut = !!S.clipboard && S.clipboard.mode === 'cut' && S.clipboard.paths.some((held) => isWithin(held, path));
     const words = [];
     if (status) words.push(t(`fileExplorer.git.${status}`)); else if (tone) words.push(t('fileExplorer.git.contains'));
     if (ignored) words.push(t('fileExplorer.git.ignored'));
+    else if (ignoreUnknown) words.push(t('fileExplorer.git.ignoreUnknown'));
     if (dirty) words.push(t('fileExplorer.row.unsaved')); else if (open) words.push(t('fileExplorer.row.open'));
     if (item.outside) words.push(t('fileExplorer.row.linkOutside')); else if (item.broken) words.push(t('fileExplorer.row.linkBroken')); else if (item.link) words.push(t('fileExplorer.row.link'));
     if (cut) words.push(t('fileExplorer.row.cut'));
     return {
-      tone, letter: status ? GIT_MARKS[status].letter : '', ignored, open, dirty, cut, words,
+      tone, letter: status ? GIT_MARKS[status].letter : '', ignored, ignoreUnknown, open, dirty, cut, words,
       active: !isDir && ed.active === path,
       missing: !!item.missing,
       faint: !!item.outside || !!item.broken,
@@ -296,24 +303,46 @@ export function createExplorer(host) {
 
   // ── Git ──
 
+  function cancelGit() {
+    clearTimeout(gitTimer);
+    gitRequest?.controller.abort();
+    gitRequest = null; gitAgain = false; gitRefresh = false; gitLoud = false;
+  }
   async function loadGit() {
-    if (!S.root) return;
-    if (gitBusy) { gitAgain = true; return; }
-    gitBusy = true;
+    if (!S.root || !S.visible) return;
+    if (gitRequest?.root === S.root) { gitAgain = true; return; }
+    gitRequest?.controller.abort();
+    const request = { root: S.root, controller: new AbortController() };
+    gitRequest = request;
     const mine = epoch;
-    const got = await api.git(S.root);
-    gitBusy = false;
+    const refresh = gitRefresh; gitRefresh = false;
+    // A background scan (the watcher, focus, the popover) never puts words in the header while a result is shown:
+    // only the first scan of a project, or one the owner asked for, is loud.
+    const loud = gitLoud || !gitShown; gitLoud = false;
+    let said = '';
+    const say = (scanState) => { said = scanState; host.onGit({ ...gitState(scanState), loud }); };
+    const slow = setTimeout(() => { if (gitRequest === request && mine === epoch) say('scanning'); }, 1500);
+    const got = await api.git(request.root, request.controller.signal, refresh);
+    clearTimeout(slow);
+    if (gitRequest !== request) return;
+    gitRequest = null;
     if (mine === epoch && got.ok) {
-      S.git = gitIndex(got);
-      host.onGit({ isGit: S.git.isGit, branch: S.git.branch, count: S.git.count });
+      if (!got.partial || !S.git.isGit) S.git = gitIndex(got);
+      gitShown = true;
+      say(gitSettled = got.scanState || 'ready');
       if (S.changedOnly) { buildView(); tree.render(); } else tree.refreshRows();
       updateCount();
-    }
+    } else if (mine === epoch && got.code !== 'aborted') say(gitSettled = 'failed');
+    else if (mine === epoch && said === 'scanning') say(gitSettled);
     if (gitAgain) { gitAgain = false; queueGit(); }
   }
+  function gitState(scanState) {
+    return { isGit: S.git.isGit, branch: S.git.branch, count: S.git.count, scanState, shown: gitShown };
+  }
   // Soon after the last sign of a change, and never more often than once in a while: a file that is written
   // without pause (a log, a database) does not make git run without pause.
   function queueGit() {
+    if (!S.root || !S.visible) return;
     clearTimeout(gitTimer);
     gitTimer = setTimeout(() => { lastGitAt = Date.now(); loadGit(); }, Math.max(GIT_DELAY_MS, lastGitAt + GIT_MIN_INTERVAL_MS - Date.now()));
   }
@@ -654,7 +683,7 @@ export function createExplorer(host) {
       case 'sortBy': return [back(), ...SORTS.map((mode) => ({ id: `sort:${mode}`, label: t(`fileExplorer.menu.sort.${mode}`), checked: S.sort === mode }))];
       case 'expandAll': expandLevel(); break;
       case 'collapseAll': collapseAll(); break;
-      case 'refresh': refreshAll(); break;
+      case 'refresh': gitRefresh = true; gitLoud = true; refreshAll(); break;
       default:
     }
     return undefined;
@@ -739,7 +768,7 @@ export function createExplorer(host) {
     });
     on('fe-collapse-all', collapseAll);
     // Refresh also asks what the server has: one that was restarted since the page loaded is found out here.
-    on('fe-refresh', async () => { await host.readServer?.(); await api.capabilities(); syncToolbar(); await refreshAll(); if (!watcher) startWatch(); });
+    on('fe-refresh', async () => { gitRefresh = true; gitLoud = true; await host.readServer?.(); await api.capabilities(); syncToolbar(); await refreshAll(); if (!watcher) startWatch(); });
     on('fe-more', (event) => { const box = event.currentTarget.getBoundingClientRect(); openMenu({ y: box.top + box.height / 2, keyboard: event.detail === 0 }); });
     on('fe-filter-clear', () => { clearFilter(); filterInput.focus(); });
     filterInput.addEventListener('input', () => setFilter(filterInput.value));
@@ -773,11 +802,13 @@ export function createExplorer(host) {
   function setProject(project) {
     persist();
     epoch++;
+    cancelGit();
     stopWatch();
     saidLimited = false;
     closeFlyout({ refocus: false });
     searchAbort?.abort();
     clearTimeout(gitTimer);
+    gitShown = false; gitSettled = 'ready';
     S.dirs = new Map(); S.git = gitIndex(null); S.view = null; S.viewOpen = new Set(); S.viewClosed = new Set();
     S.search = null; S.filter = ''; S.clipboard = null;
     reads.clear();
@@ -824,7 +855,7 @@ export function createExplorer(host) {
   /** The panel is shown or hidden: the disk is followed only while it is shown. */
   function setVisible(visible) {
     S.visible = !!visible;
-    if (S.visible) { if (S.root) { startWatch(); if (S.dirs.size) refreshAll(); } } else { persist(); stopWatch(); closeFlyout({ refocus: false }); }
+    if (S.visible) { if (S.root) { startWatch(); if (S.dirs.size) refreshAll(); } } else { persist(); cancelGit(); host.onGit(gitState(gitSettled)); stopWatch(); closeFlyout({ refocus: false }); }
   }
 
   /** Show a file of the project in the tree: its folders open, its row is selected and marked. */
@@ -850,7 +881,8 @@ export function createExplorer(host) {
     setProject,
     setVisible,
     reveal,
-    refresh: refreshAll,
+    /** Read the disk and git again. `quiet`: nobody asked for it in so many words (the git popover opened). */
+    refresh: ({ quiet = false } = {}) => { gitRefresh = true; if (!quiet) gitLoud = true; return refreshAll(); },
     collapseAll,
     /** The icons changed: every row is drawn again. */
     redraw() { if (S.root) { const now = tree.selection(); const top = tree.scrollTop(); tree.setRoot(S.root); tree.render(); tree.select(now.selected, { focus: now.focus, quiet: true, scroll: false }); tree.setScrollTop(top); } },

package/neural-interface/public/shared/explorer/fx-tree.js

@@ -161,6 +161,7 @@ export function createTree({ el, mac, icons, hooks }) {
     node.classList.toggle('fe-node--selected', selected.has(path));
     node.classList.toggle('fe-node--focus', focus === path);
     node.classList.toggle('fe-node--ignored', !!info.ignored);
+    node.dataset.ignoreState = info.ignoreUnknown ? 'unknown' : info.ignored ? 'ignored' : 'known';
     node.classList.toggle('fe-node--cut', !!info.cut);
     node.classList.toggle('fe-node--open', !!info.open);
     node.classList.toggle('fe-node--active', !!info.active);

package/neural-interface/public/shared/greeting/greeting-card.js

@@ -2,8 +2,8 @@
 // SynaBun — Greeting: the card every surface mounts
 // ═══════════════════════════════════════════
 //
-// One renderer for the greeting: the Assistant and the Claude Code, Codex and
-// OpenCode panels mount it inside the empty state they already have, Settings
+// One renderer for the greeting: the Assistant and the Claude Code, Codex,
+// OpenCode and Antigravity panels mount it inside the empty state they already have, Settings
 // shows the same card as its preview. greeting-view.js decides the words; this
 // file asks the server (`POST /api/greeting/open`) and draws.
 //

package/neural-interface/public/shared/greeting/greeting-view.js

@@ -41,6 +41,7 @@ export const GREETING_COPY = Object.freeze({
   'agent.claude-code': 'Claude Code',
   'agent.codex': 'Codex',
   'agent.opencode': 'OpenCode',
+  'agent.antigravity': 'Antigravity',
   open: 'Open memory',
   'source.writer': 'Written ahead by {model}',
   'source.fallback': 'Put together from the records, no model',