synabun 2.1.0 → 2.2.0

package/neural-interface/lib/cli-update-planner.js

@@ -1,7 +1,7 @@
 // ═══════════════════════════════════════════
 // SynaBun — CLI Update Planner
 //
-// Works out HOW each external CLI (Claude Code, Codex, OpenCode, Gemini) was
+// Works out HOW each external CLI (Claude Code, Codex, OpenCode, Antigravity) was
 // installed, and therefore which command actually updates it and which
 // "latest version" it should be compared against.
 //
@@ -19,12 +19,14 @@
 /**
  * npm package name per tool key. OpenCode has none: npm's opencode-ai is
  * OpenCode 1, which SynaBun does not drive, and OpenCode 2 is installed by its
- * own script, Homebrew or WinGet (lib/opencode-protocol.js).
+ * own script, Homebrew or WinGet (lib/opencode-protocol.js). Neither has the
+ * Antigravity CLI (`agy`): Google ships it as a binary, through its own
+ * installer script or the Homebrew cask antigravity-cli, and it updates itself
+ * (`agy update`).
  */
 export const NPM_PKGS = {
   'claude-code': '@anthropic-ai/claude-code',
   'codex': '@openai/codex',
-  'gemini': '@google/gemini-cli',
 };
 
 /**
@@ -35,22 +37,23 @@ export const NPM_PKGS = {
 export const BREW_FALLBACK_TOKENS = {
   'claude-code': 'claude-code',
   'codex': 'codex',
-  'gemini': 'gemini-cli',
+  'antigravity': 'antigravity-cli',
   // OpenCode 2's own tap (its `opencode` formula there is still OpenCode 1).
   'opencode': 'anomalyco/tap/opencode-v2',
 };
 
 /**
  * Whether each tool ships as a Homebrew cask or a formula. This is a property
- * of the package, not of the machine — claude-code and codex exist ONLY as
- * casks, gemini-cli and opencode ONLY as formulae. Needed when a tool is not
+ * of the package, not of the machine — claude-code, codex and antigravity-cli
+ * exist ONLY as casks, opencode ONLY as a formula. Needed when a tool is not
  * installed and there is no path to classify: guessing the wrong flavour
- * produces a command that simply errors ("Cask 'gemini-cli' is unavailable").
+ * produces a command that simply errors ("No available formula with the name
+ * 'antigravity-cli'").
  */
 export const BREW_KINDS = {
   'claude-code': 'cask',
   'codex': 'cask',
-  'gemini': 'formula',
+  'antigravity': 'cask',
   'opencode': 'formula',
 };
 
@@ -59,7 +62,7 @@ const SELF_UPDATERS = {
   'claude-code': 'claude update',
   'codex': 'codex update',
   'opencode': 'opencode upgrade',
-  // gemini has no self-updater.
+  'antigravity': 'agy update',
 };
 
 /**
@@ -199,7 +202,7 @@ const TOOL_COMMANDS = {
   'claude-code': 'claude',
   'codex': 'codex',
   'opencode': 'opencode',
-  'gemini': 'gemini',
+  'antigravity': 'agy',
 };
 
 /**
@@ -378,8 +381,11 @@ export function installSourceLabel(source) {
  * (checked 2026-10-17): Anthropic's native installer (code.claude.com/docs/en/setup),
  * OpenAI's standalone installer (learn.chatgpt.com/docs/codex/cli), OpenCode 2's
  * install script (https://opencode.ai/v2/install, the one `opencode upgrade`
- * runs; on Windows, where the script does not run, WinGet). These are the same
- * official sources the Install button runs (lib/cli-install.js).
+ * runs; on Windows, where the script does not run, WinGet), and (checked
+ * 2026-10-30) Google's Antigravity CLI installer
+ * (antigravity.google/docs/getting-started). These are the same official
+ * sources the Install button runs (lib/cli-install.js), which on a Mac with
+ * Homebrew installs the Antigravity CLI's cask instead.
  */
 export function vendorInstallCommand(toolKey, platform = process.platform) {
   const windows = platform === 'win32';
@@ -392,6 +398,10 @@ export function vendorInstallCommand(toolKey, platform = process.platform) {
         : 'curl -fsSL https://chatgpt.com/codex/install.sh | sh';
     case 'opencode':
       return windows ? 'winget install --id Anomaly.OpenCode --exact' : 'curl -fsSL https://opencode.ai/v2/install | bash';
+    case 'antigravity':
+      // Google's installer: it checks the binary against the SHA-512 of Google's release manifest and puts agy in
+      // ~/.local/bin (%LOCALAPPDATA%\agy\bin on Windows). A Homebrew machine is told the cask (buildInstallCommand).
+      return windows ? 'irm https://antigravity.google/cli/install.ps1 | iex' : 'curl -fsSL https://antigravity.google/cli/install.sh | bash';
     default:
       return NPM_PKGS[toolKey] ? `npm install -g ${NPM_PKGS[toolKey]}` : '';
   }
@@ -423,9 +433,9 @@ export function buildInstallCommand(toolKey, installSource = 'unknown', { platfo
       ? `brew install --cask ${token}`
       : `brew install ${token}`;
   }
-  // OpenCode 2 has no npm package: its own installer whatever JavaScript package manager the machine uses.
-  if (toolKey === 'opencode') return vendorInstallCommand(toolKey, platform || process.platform);
-  if (!npmPkg) return '';
+  // OpenCode 2 and the Antigravity CLI have no npm package: their vendor's installer whatever JavaScript package
+  // manager the machine uses.
+  if (!npmPkg) return vendorInstallCommand(toolKey, platform || process.platform);
   switch (installSource) {
     case 'bun':   return `bun add -g ${npmPkg}`;
     case 'pnpm':  return `pnpm add -g ${npmPkg}`;

package/neural-interface/lib/codex-rollout-reader.js

@@ -0,0 +1,52 @@
+// ── A Codex rollout, read once for the preview and the history fallback ──
+// The early preview (server.js sendEarlyCodexRolloutPreview) used to readFileSync the
+// whole rollout JSONL before Codex's app-server started, for every thread a tab
+// bootstrapped, and the history fallback read it again right after. This reads it as
+// a stream (the event loop and the app-server's start are not held up) and keeps the
+// parsed items of the last few files by path, size and time, so the fallback that
+// follows reuses them while the file is unchanged.
+
+import { createReadStream, statSync } from 'node:fs';
+import { jsonlLines } from './jsonl-lines.js';
+
+export function createRolloutReader({
+  open = (path) => createReadStream(path, { encoding: 'utf-8' }),
+  stat = statSync,
+  maxEntries = 4,
+} = {}) {
+  const kept = new Map(); // path → { size, mtimeMs, items }
+  const running = new Map(); // `${path}|${size}|${mtimeMs}` → promise of items
+  const stats = { reads: 0, reused: 0 };
+
+  /** The items `parse(lines)` makes of the file at `path` (an async iterable of its lines). */
+  async function items(path, parse) {
+    if (!path) return [];
+    let st;
+    try { st = stat(path); } catch { return []; }
+    const hit = kept.get(path);
+    if (hit && hit.size === st.size && hit.mtimeMs === st.mtimeMs) {
+      stats.reused++;
+      kept.delete(path); kept.set(path, hit);
+      return hit.items;
+    }
+    const key = `${path}|${st.size}|${st.mtimeMs}`;
+    if (running.has(key)) { stats.reused++; return running.get(key); }
+    const job = (async () => {
+      stats.reads++;
+      const stream = open(path);
+      try {
+        const out = await parse(jsonlLines(stream));
+        kept.delete(path);
+        kept.set(path, { size: st.size, mtimeMs: st.mtimeMs, items: out });
+        while (kept.size > maxEntries) kept.delete(kept.keys().next().value);
+        return out;
+      } finally {
+        stream.destroy?.();
+      }
+    })();
+    running.set(key, job);
+    try { return await job; } finally { running.delete(key); }
+  }
+
+  return { items, forget: (path) => kept.delete(path), get stats() { return { ...stats }; }, get size() { return kept.size; } };
+}

package/neural-interface/lib/codex-worker-app-server.js

@@ -27,7 +27,12 @@ export function codexWorkerConfigOverrides(config) {
 }
 
 export class CodexWorkerAppServer {
-  constructor({ codexPathOverride, env, config = {}, configArgs = [], apiKey, signal, onProcess = () => {} }) {
+  constructor({ codexPathOverride, env, config = {}, configArgs = [], apiKey, signal, onProcess = () => {}, onRequest = null, permissionPolicy = 'auto' }) {
+    this.onRequest = onRequest;
+    this.approvalPolicy = permissionPolicy === 'ask' ? 'untrusted' : 'never';
+    this.requestAbort = new AbortController();
+    this.incoming = new Map();
+    this.requestAbort.signal.addEventListener('abort', () => { for (const pending of this.incoming.values()) pending.abort(); this.incoming.clear(); }, { once: true });
     this.pending = new Map();
     this.seq = 0;
     this.listener = null;
@@ -52,9 +57,21 @@ export class CodexWorkerAppServer {
           this.pending.delete(msg.id); clearTimeout(p.timer);
           msg.error ? p.reject(new Error(msg.error.message || 'Codex RPC failed')) : p.resolve(msg.result);
         } else if (msg.id != null) {
-          // Workers have approvalPolicy never. Never grant an unexpected request.
-          this.write({ id: msg.id, error: { code: -32601, message: 'Unattended worker does not accept interactive requests' } });
-        } else this.listener?.(msg);
+          const controller = new AbortController();
+          this.incoming.set(msg.id, controller);
+          Promise.resolve().then(() => {
+            if (!this.onRequest) throw new Error('Worker has no interactive request handler');
+            return this.onRequest(msg, controller.signal);
+          }).then((reply) => {
+            if (!this.failure && !controller.signal.aborted) this.write({ id: msg.id, ...reply });
+          }, (error) => {
+            if (!this.failure && !controller.signal.aborted) this.write({ id: msg.id, error: { code: -32000, message: error.message } });
+          }).finally(() => this.incoming.delete(msg.id));
+        } else {
+          if (msg.method === 'serverRequest/resolved') this.incoming.get(msg.params?.requestId)?.abort();
+          if (msg.method === 'turn/completed') { for (const pending of this.incoming.values()) pending.abort(); this.incoming.clear(); }
+          this.listener?.(msg);
+        }
       }
     });
     // Drain stderr without exposing credentials/config to the worker transcript.
@@ -76,6 +93,7 @@ export class CodexWorkerAppServer {
   write(value) { if (!this.proc.stdin.destroyed) this.proc.stdin.write(JSON.stringify(value) + '\n'); }
   fail(error) {
     this.failure = error;
+    this.requestAbort.abort();
     for (const p of this.pending.values()) { clearTimeout(p.timer); p.reject(error); }
     this.pending.clear();
     this.listener?.({ method: 'synabun/exit', error });
@@ -99,7 +117,7 @@ export class CodexWorkerAppServer {
     const ready = this.ready.then(async () => {
       const reply = await this.rpc(id ? 'thread/resume' : 'thread/start', {
         ...(id ? { threadId: id } : {}), cwd: options.workingDirectory,
-        model: options.model || null, approvalPolicy: 'never', sandbox: options.sandboxMode,
+        model: options.model || null, approvalPolicy: owner.approvalPolicy, sandbox: options.sandboxMode,
         config: { web_search: options.webSearchMode || 'disabled', sandbox_workspace_write: { network_access: !!options.networkAccessEnabled, writable_roots: options.additionalDirectories || [] } },
       });
       const actual = reply?.thread?.id;
@@ -141,7 +159,7 @@ export class CodexWorkerAppServer {
         signal?.addEventListener('abort', abort, { once: true });
         try {
           if (signal?.aborted) throw Object.assign(new Error('Codex turn aborted'), { name: 'AbortError' });
-          const reply = await owner.rpc('turn/start', { threadId: id, input: [{ type: 'text', text: String(prompt), text_elements: [] }], approvalPolicy: 'never', sandboxPolicy, effort: options.modelReasoningEffort || null, ...(outputSchema ? { outputSchema } : {}) });
+          const reply = await owner.rpc('turn/start', { threadId: id, input: [{ type: 'text', text: String(prompt), text_elements: [] }], approvalPolicy: owner.approvalPolicy, sandboxPolicy, effort: options.modelReasoningEffort || null, ...(outputSchema ? { outputSchema } : {}) });
           turnId = reply?.turn?.id;
           if (signal?.aborted) abort();
         } catch (error) { owner.listener = null; signal?.removeEventListener('abort', abort); throw error; }
@@ -159,6 +177,7 @@ export class CodexWorkerAppServer {
     };
   }
   async dispose() {
+    this.requestAbort.abort();
     this.startupSignal?.removeEventListener('abort', this.cancelStartup);
     if (this.proc.exitCode !== null || this.proc.signalCode) return;
     if (process.platform === 'win32') {

package/neural-interface/lib/editor-git-api.js

@@ -18,13 +18,12 @@
 // not an error. Dependencies are injected: the router is tested without server.js.
 
 import { Router } from 'express';
-import { execFile } from 'node:child_process';
 import { statSync } from 'node:fs';
 import { dirname, isAbsolute, relative, sep } from 'node:path';
 import { PathConfineError } from './path-confine.js';
 import { MAX_FILE_BYTES, canonicalInside } from './confined-fs.js';
 import { useFileRoot } from './editor-files-api.js';
-import { gitRead } from './git-read.js';
+import { gitStatusRunner } from './git-status-runner.js';
 
 /** What this route adds to the editor (GET /api/editor/capabilities). */
 export const EDITOR_GIT_CAPABILITIES = Object.freeze(['git-head']);
@@ -32,9 +31,6 @@ export const GIT_TIMEOUT_MS = 5000;
 
 const UTF8_BOM = [0xEF, 0xBB, 0xBF];
 const BINARY_PROBE_BYTES = 8192;
-// Variables that would point git at another repository than the one the file is in.
-const REDIRECTING = ['GIT_DIR', 'GIT_WORK_TREE', 'GIT_INDEX_FILE', 'GIT_NAMESPACE', 'GIT_COMMON_DIR', 'GIT_OBJECT_DIRECTORY', 'GIT_ALTERNATE_OBJECT_DIRECTORIES', 'GIT_CEILING_DIRECTORIES'];
-
 /**
  * Run git for a read and collect what it prints. Never throws. The arguments are the command's own: what keeps a
  * read from starting a program of the repository's is added here (lib/git-read.js).
@@ -42,21 +38,8 @@ const REDIRECTING = ['GIT_DIR', 'GIT_WORK_TREE', 'GIT_INDEX_FILE', 'GIT_NAMESPAC
  * @param {{ cwd: string, maxBuffer: number, timeoutMs?: number, binary?: string, env?: object }} o
  * @returns {Promise<{ ok: boolean, stdout: Buffer, tooLarge: boolean }>} `tooLarge`: it printed more than `maxBuffer` bytes
  */
-export function runGit(args, { cwd, maxBuffer, timeoutMs = GIT_TIMEOUT_MS, binary = 'git', env = process.env } = {}) {
-  const clean = { ...env };
-  for (const name of REDIRECTING) delete clean[name];
-  const failed = { ok: false, stdout: Buffer.alloc(0), tooLarge: false };
-  return gitRead(cwd, args, { binary, env: clean }).then((read) => new Promise((done) => {
-    try {
-      execFile(binary, read.args, { cwd, maxBuffer, timeout: timeoutMs, encoding: 'buffer', windowsHide: true, env: read.env, shell: false }, (error, stdout) => {
-        const out = Buffer.isBuffer(stdout) ? stdout : Buffer.alloc(0);
-        if (!error) done({ ok: true, stdout: out, tooLarge: false });
-        else done({ ok: false, stdout: out, tooLarge: error.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER' });
-      });
-    } catch {
-      done(failed);
-    }
-  })).catch(() => failed);
+export function runGit(args, options = {}) {
+  return gitStatusRunner.run(args, { timeoutMs: GIT_TIMEOUT_MS, ...options });
 }
 
 /**

package/neural-interface/lib/exec-loop-command.js

@@ -13,9 +13,12 @@ function codexConfigString(value) {
   return JSON.stringify(String(value));
 }
 
+/** The reasoning levels `agy --effort` accepts (agy --help). */
+const ANTIGRAVITY_EFFORTS = new Set(['low', 'medium', 'high', 'xhigh', 'max']);
+
 /**
  * Split the configurable CLI command into an executable and fixed arguments.
- * Settings intentionally supports prefixes such as `wsl -d Ubuntu gemini`.
+ * Settings intentionally supports prefixes such as `wsl -d Ubuntu agy`.
  * An existing path wins before tokenization so unquoted executable paths with
  * spaces keep working; quoted paths are handled by the tokenizer.
  */
@@ -107,8 +110,12 @@ export function buildExecInvocation({
       args.push('-');
       break;
     }
-    case 'gemini':
+    case 'antigravity':
+      // Print mode with the task on stdin (the wrapper redirects it), unattended like every exec loop: Antigravity
+      // asks before edits and commands, and there is nobody to answer in a terminal that runs a loop.
+      args.push('--output-format', 'text', '--dangerously-skip-permissions');
       if (model) args.push('--model', String(model));
+      if (effort && ANTIGRAVITY_EFFORTS.has(String(effort))) args.push('--effort', String(effort));
       break;
     case 'opencode':
       // A private server for this run (`--standalone`; without it the CLI uses

package/neural-interface/lib/file-explorer-api.js

@@ -74,6 +74,7 @@ import { PathConfineError, isInside } from './path-confine.js';
 import { canonicalInside, openConfinedStream, removeConfinedEntry } from './confined-fs.js';
 import { matchFileRoots, useFileRoot } from './editor-files-api.js';
 import { runGit } from './editor-git-api.js';
+import { gitStatusRunner, projectStatus, createIgnoredPrefixes, watchRelative, MAX_IGNORE_FOLDERS } from './git-status-runner.js';
 import { TrashUnavailable, createRevealer, createTrash, renameExclusive } from './file-explorer-system.js';
 import { isAllowedWebSocketOrigin } from './http-guards.js';
 import { createTreeWatcher, watchStrategy } from './file-explorer-watch.js';
@@ -89,8 +90,6 @@ export const MAX_UPLOAD_BYTES = 512 * 1024 * 1024;
 export const MAX_RAW_BYTES = 30 * 1024 * 1024;
 export const MAX_BATCH = 500;
 export const MAX_WATCH_SESSIONS = 16;
-const GIT_MAX_BUFFER = 64 * 1024 * 1024;
-const GIT_STATUS_TIMEOUT_MS = 15000;
 const STAT_PARALLEL = 64;
 const COPY_CHUNK_BYTES = 1024 * 1024;
 const O_NOFOLLOW = constants.O_NOFOLLOW || 0;
@@ -273,7 +272,7 @@ async function mapLimit(items, limit, work) {
  * @returns {import('express').Router & { close: () => void, sessions: () => number }}
  */
 export function createFileExplorerRouter({
-  fileRoots, guard = null, origins = {}, git = runGit, trash = createTrash(), revealer = createRevealer(),
+  fileRoots, guard = null, origins = {}, git = runGit, statusRunner = gitStatusRunner, trash = createTrash(), revealer = createRevealer(),
   platform = process.platform, watch = watchStrategy(), watchImpl = undefined, watchClock = {}, io = {}, log = (line) => console.warn(line),
   maxUploadBytes = MAX_UPLOAD_BYTES, listingCap = LISTING_CAP,
 } = {}) {
@@ -292,8 +291,7 @@ export function createFileExplorerRouter({
   // The folders only: a single file the editor is allowed by name is not something the explorer manages.
   const roots = () => ({ dirs: (fileRoots()?.dirs || []).filter(Boolean), files: [] });
   const sessions = new Map();   // watch id → { watcher, root, real, res, written: Map<real dir, written dir> }
-  const gitKnown = new Map();   // canonical project folder → { dirs: string[], files: Set<string> } git ignores
-  const gitFlights = new Map(); // canonical project folder → the status being read
+  const gitKnown = new Map();   // bounded visible-folder listings and ignore prefixes, independent of status revisions
 
   function answer(res, error) {
     const done = error?.midway || {};
@@ -438,6 +436,8 @@ export function createFileExplorerRouter({
       dirents.sort((a, b) => (a.isDirectory() !== b.isDirectory() ? (a.isDirectory() ? -1 : 1) : compareNames(a.name, b.name)));
       dirents = dirents.slice(0, listingCap);
     }
+    const ignoreResult = await ignoredEntries(dir.real, dir.real, dirents, requestSignal(res), true);
+    const ignored = new Set(ignoreResult || []);
     const realBase = realpathSync(dir.base);
     const items = await mapLimit(dirents, STAT_PARALLEL, async (entry) => {
       const full = join(dir.real, entry.name);
@@ -455,46 +455,67 @@ export function createFileExplorerRouter({
       try { const st = await lstat(full); return { name: entry.name, type: 'file', size: st.size, mtime: st.mtimeMs }; }
       catch { return { name: entry.name, type: 'file' }; }
     });
+    for (const item of items) {
+      if (ignored.has(item.name) || ignored.has(item.name + '/')) item.ignored = true;
+      else if (ignoreResult === null) item.ignored = null; // still being checked, not known-normal
+    }
     items.sort((a, b) => (a.type !== b.type ? (a.type === 'dir' ? -1 : 1) : compareNames(a.name, b.name)));
     res.json({ ok: true, path: dir.written, items, total, truncated });
   }));
 
   // ── The git state of a project ──
-  async function readGit(real) {
-    const top = await git(['rev-parse', '--show-toplevel'], { cwd: real, maxBuffer: 1024 * 1024 });
-    if (!top.ok) return { isGit: false };
-    let repo = top.stdout.toString('utf8').trim();
-    try { repo = realpathSync(repo); } catch { /* as git printed it */ }
-    const below = slashes(relative(repo, real));
-    if (below.startsWith('..')) return { isGit: false };
-    const prefix = below ? `${below}/` : '';
-    let branch = '';
-    const named = await git(['symbolic-ref', '--short', '-q', 'HEAD'], { cwd: real, maxBuffer: 1024 * 1024 });
-    if (named.ok) branch = named.stdout.toString('utf8').trim();
-    if (!branch) {
-      const short = await git(['rev-parse', '--short', 'HEAD'], { cwd: real, maxBuffer: 1024 * 1024 });
-      if (short.ok) branch = short.stdout.toString('utf8').trim();
+  function requestSignal(res) {
+    const controller = new AbortController();
+    res.once('close', () => controller.abort());
+    return controller.signal;
+  }
+  function ignoreData(real) {
+    let known = gitKnown.get(real);
+    if (!known) {
+      if (gitKnown.size >= 64) gitKnown.delete(gitKnown.keys().next().value);
+      gitKnown.set(real, known = { folders: new Map(), prefixes: createIgnoredPrefixes(platform), at: Date.now() });
     }
-    const status = await git(['status', '--porcelain=v1', '-z', '--ignored', '--untracked-files=normal'], { cwd: real, maxBuffer: GIT_MAX_BUFFER, timeoutMs: GIT_STATUS_TIMEOUT_MS });
-    if (!status.ok) return { isGit: true, branch, changes: {}, ignored: [], partial: true };
-    const { changes, ignored } = parseGitStatus(status.stdout.toString('utf8'), prefix);
-    gitKnown.set(real, { dirs: ignored.filter((path) => path.endsWith('/')), files: new Set(ignored.filter((path) => !path.endsWith('/'))) });
-    return { isGit: true, branch, changes, ignored };
+    if (Date.now() - known.at >= 30000) { known.prefixes.clear(); known.folders.clear(); known.at = Date.now(); }
+    return known;
+  }
+  async function ignoredEntries(real, folder, dirents, signal, cacheOnly = false) {
+    const known = ignoreData(real);
+    const rel = slashes(relative(real, folder));
+    const paths = dirents ? dirents.map(e => `${rel ? rel + '/' : ''}${e.name}${e.isDirectory() ? '/' : ''}`) : known.folders.get(folder)?.paths;
+    if (!paths) return null;
+    const ignored = await statusRunner.ignored(real, paths, { signal, cacheOnly });
+    if (known.folders.size >= MAX_IGNORE_FOLDERS && !known.folders.has(folder)) known.folders.delete(known.folders.keys().next().value);
+    known.folders.set(folder, { paths });
+    for (const path of ignored || []) known.prefixes.add(path);
+    return ignored;
+  }
+  async function readGit(real, signal) {
+    const result = projectStatus(await statusRunner.read(real, { signal }), real);
+    if (!result.isGit && result.ok) return { isGit: false };
+    const dirs = new Set([real]);
+    for (const session of sessions.values()) if (session.real === real) for (const folder of session.written.keys()) dirs.add(folder);
+    const known = ignoreData(real), ignored = [];
+    let ignoreUnknown = false;
+    for (const folder of dirs) {
+      try {
+        // Reuse the folder's entry names between listings/TTL; a tracked edit
+        // does not need readdir + check-ignore in every expanded folder.
+        const entries = known.folders.has(folder) ? null : (await readdir(folder, { withFileTypes: true })).slice(0, listingCap);
+        const checked = await ignoredEntries(real, folder, entries, signal);
+        if (checked === null) ignoreUnknown = true;
+        else ignored.push(...checked);
+      } catch { ignoreUnknown = true; }
+    }
+    const changes = Object.fromEntries((result.changes || []).map(c => [c.path, c.status]));
+    return { isGit: result.isGit, branch: result.branch, changes, ignored: [...new Set(ignored)], ignoreUnknown,
+      ...(!result.ok || result.partial ? { partial: true, stale: !!result.stale, scanState: result.timedOut ? 'timed-out' : 'failed' } : {}) };
   }
   router.get('/git', route(async (req, res) => {
     const dir = folderOf(req.query.root);
-    // Two windows that ask at once share one run of git.
-    let flight = gitFlights.get(dir.real);
-    if (!flight) {
-      flight = readGit(dir.real).finally(() => gitFlights.delete(dir.real));
-      gitFlights.set(dir.real, flight);
-    }
-    res.json({ ok: true, root: dir.written, ...(await flight) });
+    if (req.query.refresh === '1') statusRunner.invalidate(dir.real, { refresh: true });
+    res.json({ ok: true, root: dir.written, ...(await readGit(dir.real, requestSignal(res))) });
   }));
-  const ignoredByGit = (real) => (path) => {
-    const known = gitKnown.get(real);
-    return !!known && (known.files.has(path) || known.dirs.some((dir) => path.startsWith(dir) || `${path}/` === dir));
-  };
+  const ignoredByGit = real => path => ignoreData(real).prefixes.has(watchRelative(real, path, platform));
 
   // ── Entries by name ──
   router.get('/search', route(async (req, res) => {
@@ -505,8 +526,9 @@ export function createFileExplorerRouter({
     const words = query.split(/\s+/);
     const byPath = query.includes('/');
     // What git ignores as a whole folder (node_modules, build output) is not walked; without git, the usual two.
-    const known = gitKnown.get(dir.real) || (await readGit(dir.real).catch(() => null), gitKnown.get(dir.real));
-    const skipped = (rel, name) => name === '.git' || (known ? known.dirs.includes(`${rel}/`) : name === 'node_modules');
+    const signal = requestSignal(res);
+    const known = gitKnown.get(dir.real);
+    const skipped = (rel, name) => name === '.git' || (known ? known.prefixes.has(rel) : name === 'node_modules');
     const items = [];
     const queue = [''];
     const started = Date.now();
@@ -515,8 +537,15 @@ export function createFileExplorerRouter({
       const rel = queue[at];
       let dirents;
       try { dirents = await readdir(rel ? join(dir.real, rel) : dir.real, { withFileTypes: true }); } catch { continue; }
+      if (dirents.length > listingCap) { dirents = dirents.slice(0, listingCap); partial = true; }
+      const checked = await ignoredEntries(dir.real, rel ? join(dir.real, rel) : dir.real, dirents, signal);
+      // Unknown ignore policy must not send name search into an enormous cache.
+      if (checked === null) { partial = true; break; }
+      const ignored = new Set(checked);
+      if (signal.aborted) break;
       dirents.sort((a, b) => compareNames(a.name, b.name));
       for (const entry of dirents) {
+        if (ignored.has(`${rel ? rel + '/' : ''}${entry.name}${entry.isDirectory() ? '/' : ''}`)) continue;
         if (++visited > SEARCH_MAX_VISITED || Date.now() - started > SEARCH_BUDGET_MS) { partial = true; break walk; }
         const path = rel ? `${rel}/${entry.name}` : entry.name;
         const isDir = entry.isDirectory();
@@ -547,7 +576,12 @@ export function createFileExplorerRouter({
       ...(watchImpl ? { watch: watchImpl } : {}),
       ...watchClock,
       ignoresGit: ignoredByGit(dir.real),
-      onChange: ({ dirs, git: gitChanged }) => send('change', { dirs: dirs.map((real) => session.written.get(real)).filter(Boolean), git: gitChanged }),
+      onChange: ({ dirs, git: gitChanged, ignores }) => {
+        if (gitChanged || ignores) statusRunner.invalidate(dir.real, { ignores });
+        if (ignores) gitKnown.delete(dir.real);
+        else { const known = gitKnown.get(dir.real); for (const folder of dirs) known?.folders.delete(folder); }
+        send('change', { dirs: dirs.map((real) => session.written.get(real)).filter(Boolean), git: gitChanged });
+      },
       onError: () => send('resync', {}),
       // A stream is not a watch that works: what is really watched is said, and said again when it changes.
       onState: (state) => send('state', state),
@@ -557,7 +591,7 @@ export function createFileExplorerRouter({
     const beat = setInterval(() => { try { res.write(': still here\n\n'); } catch { /* closing */ } }, 25000);
     beat.unref?.();
     // The response's end is the page leaving (a request's own `close` only says its body was read).
-    res.on('close', () => { clearInterval(beat); session.watcher.close(); sessions.delete(id); });
+    res.on('close', () => { clearInterval(beat); session.watcher.close(); sessions.delete(id); if (![...sessions.values()].some(s => s.real === dir.real)) statusRunner.release(dir.real); });
   }));
 
   router.post('/watch/:id', route(async (req, res) => {
@@ -1033,7 +1067,7 @@ export function createFileExplorerRouter({
   router.use((req, res) => res.status(404).json({ ok: false, code: 'bad-request', error: 'Unknown explorer route.' }));
 
   /** Release every watch (the server is going down). */
-  router.close = () => { for (const session of sessions.values()) { session.watcher.close(); try { session.res.end(); } catch { /* gone */ } } sessions.clear(); };
+  router.close = () => { for (const session of sessions.values()) { session.watcher.close(); statusRunner.release(session.real); try { session.res.end(); } catch { /* gone */ } } sessions.clear(); };
   router.sessions = () => sessions.size;
   return router;
 }

package/neural-interface/lib/file-explorer-watch.js

@@ -26,7 +26,7 @@
 // that is not there, whatever folders the page shows meanwhile.
 
 import { existsSync, watch as fsWatch } from 'node:fs';
-import { dirname, join, relative, sep } from 'node:path';
+import { dirname, isAbsolute, join, relative, sep } from 'node:path';
 
 export const MAX_WATCHED_DIRS = 600;
 /** A watch that failed is tried again after this long, then after twice that, and so on. */
@@ -80,6 +80,7 @@ export function createTreeWatcher({
   let said = null;                     // the `live` that was last reported
   const pending = new Set();
   let pendingGit = false;
+  let pendingIgnores = false;
   let timer = null;
   let firstAt = 0;
 
@@ -88,9 +89,10 @@ export function createTreeWatcher({
   function flush() {
     timer = null;
     if (closed || (!pending.size && !pendingGit)) return;
-    const change = { dirs: [...pending], git: pendingGit };
+    const change = { dirs: [...pending], git: pendingGit, ...(pendingIgnores ? { ignores: true } : {}) };
     pending.clear();
     pendingGit = false;
+    pendingIgnores = false;
     try { onChange(change); } catch { /* a listener's failure is not the watcher's */ }
   }
 
@@ -107,7 +109,11 @@ export function createTreeWatcher({
   // One change, by its path below the root ('' is the root itself).
   function note(rel) {
     if (closed) return;
-    const path = slashed(rel || '');
+    // Native watchers can report an absolute path, or no filename at all.
+    // Missing names conservatively dirty status, never all ignore data.
+    const path = slashed(isAbsolute(rel || '') ? relative(root, rel) : rel || '');
+    if (path === '..' || path.startsWith('../')) return;
+    if (path === '.git/info/exclude' || path === '.git/config' || path === '.git/config.worktree' || path === '.gitignore' || path.endsWith('/.gitignore')) { pendingIgnores = true; pendingGit = true; }
     if (path === '.git' || path.startsWith('.git/')) {
       const inside = path.slice(5);
       if (GIT_STATE_FILES.test(inside) || inside.startsWith('refs/')) pendingGit = true;