synabun 2.0.10 → 2.2.0

package/neural-interface/public/shared/crash-notice-view.js

@@ -0,0 +1,168 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — the notice after an automatic restart: what it says
+// ═══════════════════════════════════════════
+//
+// When SynaBun's server crashes after it was up, its supervisor starts it again
+// and leaves the new server a record of the crash (lib/server-crash-record.js,
+// GET /api/system/crash-notice). The owner's pages say so until it is dismissed:
+// that the server stopped unexpectedly and was restarted, when and how it ended,
+// and what the restart ended. This module decides the words; ui-crash-notice.js
+// asks the server and draws them.
+//
+// What the restart ends is what the code does when the server process dies and
+// a new one starts, nothing more:
+//   - terminals: the pty host ends with the server and kills its shells
+//     (lib/pty-host/host.js on 'disconnect'); a new host has none of them
+//   - runs: dispatched worker runs and native loops that were running are marked
+//     interrupted at boot (lib/assistant-dispatch.js, lib/native-loop-runtime.js);
+//     Quick Timers, schedule timers set for later and the schedule queue live in
+//     memory; saved schedules keep firing. The program a run had started is not
+//     always ended with the server: on macOS and Linux a CLI whose input is not
+//     the server's (`claude -p`, `codex exec`) ends at its next write to the
+//     server, and on Windows one started through a shell is not in the server's
+//     job: hence "a step already under way may still finish"
+//   - replies: a Claude Code, Codex or Assistant turn in progress is gone, the
+//     conversation stays and the next message resumes it (an OpenCode serve that
+//     outlived the server may be adopted and go on: hence "may have been")
+//   - browser: the sessions SynaBun drove live in memory; their profiles stay
+//   - public address: cloudflared is not started again, a new start gets a new
+//     one. Windows ends it with the server (its job); on macOS and Linux it
+//     outlives a crash, and the new server ends it by its record at start
+//     (server.js sweepLeftoverTunnels). One it could not end is `tunnel:
+//     'unknown'` in the notice, and the notice says the address may still be open
+//
+// No imports and no DOM: `node --test` loads this file as it is
+// (tests/crash-notice-view.test.mjs). CRASH_NOTICE_COPY is the English of every
+// sentence; `crashNotice.*` in i18n/en.json must equal it and i18n/pt-BR.json
+// must have the same keys.
+
+export const CRASH_NOTICE_COPY = Object.freeze({
+  title: 'SynaBun\'s server stopped unexpectedly and was restarted automatically.',
+  whenToday: 'It happened at {time}.',
+  whenEarlier: 'It happened on {date} at {time}.',
+  whenManyToday: 'It happened {count} times, the last at {time}.',
+  whenManyEarlier: 'It happened {count} times, the last on {date} at {time}.',
+  how: 'How it ended: {exit}.',
+  lostTitle: 'What the restart ended',
+  lostTerminals: 'Open terminals were closed.',
+  lostRuns: 'Agent runs and loops that were running were interrupted, though a step already under way may still finish on its own. Timers and queued runs were cleared. Saved schedules keep running.',
+  lostReplies: 'Replies being written in the side panels or the Assistant may have been cut off. The conversations are kept: send again what did not finish.',
+  lostBrowser: 'Browser sessions SynaBun was driving ended. Their saved sign-ins are kept.',
+  lostTunnel: 'The public address, if it was on, is off. Turning it on again gives a new address.',
+  lostTunnelUnknown: 'The public address, if it was on, may still be open: SynaBun could not end the cloudflared that served it. Ending that process, or restarting the computer, closes it.',
+  openLogs: 'Open logs',
+  openLogsFailed: 'The logs folder could not be opened.',
+  dismiss: 'Dismiss',
+  label: 'Server restarted after a crash',
+  exitCode: 'exit code {code}',
+  exitText: '{status}, {kind}',
+  kindNativeCrash: 'native crash',
+  kindOutOfMemory: 'out of memory',
+  kindNodeFatal: 'Node.js fatal error',
+  kindError: 'stopped by an error',
+  kindKilled: 'ended by force',
+  kindInterrupted: 'interrupted',
+});
+
+/** The order the notice lists what the restart ended (the last: lostTunnelUnknown for a notice whose `tunnel` is 'unknown'). */
+export const CRASH_NOTICE_LOST = Object.freeze(['lostTerminals', 'lostRuns', 'lostReplies', 'lostBrowser', 'lostTunnel']);
+
+/** The word for each kind lib/server-exit.js names; a kind without one shows the status alone. */
+export const CRASH_KIND_KEYS = Object.freeze({
+  'native-crash': 'kindNativeCrash',
+  'out-of-memory': 'kindOutOfMemory',
+  'node-fatal': 'kindNodeFatal',
+  error: 'kindError',
+  killed: 'kindKilled',
+  interrupted: 'kindInterrupted',
+});
+
+/** A sentence of CRASH_NOTICE_COPY in English with its {values} filled; an unknown key is itself. */
+export function fillCrashNoticeCopy(key, params = {}) {
+  const text = Object.prototype.hasOwnProperty.call(CRASH_NOTICE_COPY, key) ? CRASH_NOTICE_COPY[key] : key;
+  return text.replace(/\{(\w+)\}/g, (whole, name) => (params[name] != null ? String(params[name]) : whole));
+}
+
+const ID = /^[0-9a-f]{16}$/;
+
+/**
+ * The notice in an answer of GET /api/system/crash-notice (or a `crash-notice:changed`
+ * message: both carry `notice`), checked field by field; null when there is none.
+ * `tunnel: 'unknown'` is there only when the server could not end the crashed
+ * server's cloudflared.
+ */
+export function readCrashNotice(answer) {
+  const notice = answer && typeof answer === 'object' ? answer.notice : null;
+  if (!notice || typeof notice !== 'object' || Array.isArray(notice)) return null;
+  if (typeof notice.id !== 'string' || !ID.test(notice.id)) return null;
+  const at = Number(notice.at);
+  if (!Number.isFinite(at) || at <= 0) return null;
+  const exit = notice.exit && typeof notice.exit === 'object' && !Array.isArray(notice.exit) ? notice.exit : {};
+  return {
+    id: notice.id,
+    at,
+    count: Number.isInteger(notice.count) && notice.count > 0 ? Math.min(notice.count, 999) : 1,
+    exit: {
+      hex: typeof exit.hex === 'string' && /^0x[0-9a-f]{8}$/i.test(exit.hex) ? `0x${exit.hex.slice(2).toUpperCase()}` : '',
+      signal: typeof exit.signal === 'string' && /^SIG[A-Z0-9]{1,10}$/.test(exit.signal) ? exit.signal : '',
+      code: Number.isInteger(exit.code) ? exit.code : null,
+      kind: typeof exit.kind === 'string' && /^[a-z][a-z-]{0,23}$/.test(exit.kind) ? exit.kind : '',
+    },
+    ...(notice.tunnel === 'unknown' ? { tunnel: 'unknown' } : {}),
+  };
+}
+
+/** How it ended in the reader's words ("0xC0000409, native crash"), or '' when the record names nothing. */
+export function crashExitWords(exit, t = fillCrashNoticeCopy) {
+  if (!exit || typeof exit !== 'object') return '';
+  const status = exit.hex || exit.signal || (Number.isInteger(exit.code) ? t('exitCode', { code: exit.code }) : '');
+  if (!status) return '';
+  const key = CRASH_KIND_KEYS[exit.kind];
+  return key ? t('exitText', { status, kind: t(key) }) : status;
+}
+
+/** When it happened, in the reader's locale: { today, date, time } (the date is for another day). */
+export function crashTimeParts(at, { now = Date.now(), locale = undefined } = {}) {
+  const when = new Date(at);
+  if (!Number.isFinite(when.getTime())) return null;
+  const day = new Date(now);
+  const today = when.getFullYear() === day.getFullYear() && when.getMonth() === day.getMonth() && when.getDate() === day.getDate();
+  const format = (fn, options, fallback) => { try { return fn.call(when, locale, options); } catch { return fallback; } };
+  return {
+    today,
+    date: format(Date.prototype.toLocaleDateString, { dateStyle: 'medium' }, when.toISOString().slice(0, 10)),
+    time: format(Date.prototype.toLocaleTimeString, { hour: '2-digit', minute: '2-digit' }, when.toISOString().slice(11, 16)),
+  };
+}
+
+/**
+ * What the notice shows, or null: { id, label, title, when, how, lostTitle, lost[], actions[] }.
+ * `t(key, params)` is a sentence of CRASH_NOTICE_COPY in the page's language; `canOpenLogs`
+ * says whether this page can open the logs folder (the desktop app, or a page on this computer).
+ */
+export function crashNoticeView(notice, { t = fillCrashNoticeCopy, now = Date.now(), locale = undefined, canOpenLogs = false } = {}) {
+  if (!notice || typeof notice !== 'object' || !notice.id) return null;
+  const parts = crashTimeParts(notice.at, { now, locale }) || { today: true, date: '', time: '' };
+  const many = notice.count > 1;
+  const whenKey = `${many ? 'whenMany' : 'when'}${parts.today ? 'Today' : 'Earlier'}`;
+  const exit = crashExitWords(notice.exit, t);
+  return {
+    id: notice.id,
+    label: t('label'),
+    title: t('title'),
+    when: t(whenKey, { count: notice.count, date: parts.date, time: parts.time }),
+    how: exit ? t('how', { exit }) : '',
+    lostTitle: t('lostTitle'),
+    lost: CRASH_NOTICE_LOST.map((key) => t(key === 'lostTunnel' && notice.tunnel === 'unknown' ? 'lostTunnelUnknown' : key)),
+    actions: [
+      ...(canOpenLogs ? [{ id: 'logs', label: t('openLogs') }] : []),
+      { id: 'dismiss', label: t('dismiss') },
+    ],
+  };
+}
+
+/** True for a page served from this computer's loopback address: the only one the logs folder opens for. */
+export function isLoopbackHost(hostname) {
+  const host = String(hostname || '').toLowerCase().replace(/^\[|\]$/g, '');
+  return host === 'localhost' || host === '::1' || /^127(?:\.\d{1,3}){3}$/.test(host);
+}

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

@@ -76,6 +76,10 @@ export const DESKTOP_COPY = Object.freeze({
     metaReadyOff: 'Ready to install',
     metaCountdown: 'Restarting to install it',
     metaPostponed: 'Postponed: installs on quit or later',
+    // The button at the top right while a downloaded update waits for a restart, as Discord's green one.
+    restartButton: 'Restart to update',
+    restartTooltip: 'SynaBun v{latest} is ready: restart to update',
+    restartSoon: 'Restarting soon',
   }),
   // What an update waits for (the app's server names it, GET /api/system/activity).
   busy: Object.freeze({
@@ -83,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',
@@ -422,6 +427,22 @@ export function desktopUpdateTooltip(state, { t = fillDesktopCopy } = {}) {
   return t('update.tooltip', params);
 }
 
+/**
+ * The top right button while a downloaded update waits for a restart into it, or null: { label, tooltip, asked }.
+ * Only an update this copy installs by restarting (not one to move to Applications or to install by hand). After
+ * Restart to update, while something still runs, it says that the restart is coming (`asked`).
+ */
+export function desktopRestartButton(state, { t = fillDesktopCopy } = {}) {
+  const s = readDesktopUpdateState(state);
+  if (desktopUpdateStep(s) !== 'downloaded' || s.install !== 'restart' || s.manualFile) return null;
+  const asked = s.auto?.now === true;
+  return {
+    label: t(asked ? 'update.restartSoon' : 'update.restartButton'),
+    tooltip: t('update.restartTooltip', { latest: s.latest || '', current: s.current }),
+    asked,
+  };
+}
+
 /**
  * The notice at the bottom right, or null:
  *   countdown  SynaBun is idle and restarts into the update: the seconds left, and Later

package/neural-interface/public/shared/editor/editor-panel-logic.js

@@ -80,9 +80,9 @@ export function matchesExpectedMarkdown(content, expected) {
   return String(content).replace(/\r\n/g, '\n') === expected.replace(/\r\n/g, '\n');
 }
 
-/** Whether a path is the user's OpenCode configuration file. */
+/** Whether a path is the user's OpenCode configuration file (OpenCode 2's opencode.json or opencode.jsonc). */
 export function isOpencodeConfigPath(path) {
-  return String(path || '').replace(/\\/g, '/').endsWith('/.config/opencode/config.json');
+  return /\/\.config\/opencode\/opencode\.jsonc?$/.test(String(path || '').replace(/\\/g, '/'));
 }
 
 const OUTSIDE_ROOTS = 'Path outside registered project roots';

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',