synabun 2.0.10 → 2.2.0

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;

package/neural-interface/lib/git-bash/install.js

@@ -11,7 +11,10 @@
 //                   redirect too), stopped at the pinned size, compared with
 //                   the pinned SHA-256 (cloudflared/install.js downloadPinned).
 //                   A file that does not match is removed: nothing of it is
-//                   ever unpacked
+//                   ever unpacked. An installed app carries the release file
+//                   itself (<resources>\git-archive): it is copied into the
+//                   work folder and checked the same way (copyPinned), never
+//                   unpacked from where it lies
 //   extractArchive  the .tar.bz2 read by this application itself (bzip2.js,
 //                   then the tar reader below), never by a tar program: what a
 //                   Windows 10 tar.exe can read differs from build to build.
@@ -34,8 +37,10 @@
 // Only node: modules and this application's own files here (see pins.js).
 
 import { createHash, randomBytes } from 'node:crypto';
+import { pipeline } from 'node:stream/promises';
+import { Transform } from 'node:stream';
 import {
-  closeSync, constants, copyFileSync, existsSync, linkSync, lstatSync, mkdirSync, openSync, readdirSync, readFileSync,
+  closeSync, constants, copyFileSync, createReadStream, createWriteStream, existsSync, linkSync, lstatSync, mkdirSync, openSync, readdirSync, readFileSync,
   renameSync, rmSync, statSync, writeFileSync, writeSync,
 } from 'node:fs';
 import { dirname, join } from 'node:path';
@@ -463,6 +468,40 @@ export function unpackInWorker(data, { signal, onProgress = () => {}, onStep = (
   });
 }
 
+/**
+ * The release file an installed app carries (`source`), copied into `destination` (the attempt's own work folder)
+ * and compared with the pin as it is copied: its size, then its SHA-256. What is unpacked is the copy, so nothing
+ * can change the file between the check and the read. A file that does not match is removed and named.
+ */
+export async function copyPinned({ source, pin, destination, signal, onProgress = () => {} }) {
+  const hash = createHash('sha256');
+  let size = 0;
+  const count = new Transform({
+    transform(chunk, encoding, done) {
+      size += chunk.length;
+      if (size > pin.size) { done(new GitBashError('checksum', `${source} is larger than the pinned ${pin.file}.`)); return; }
+      hash.update(chunk);
+      onProgress({ received: size, total: pin.size });
+      done(null, chunk);
+    },
+  });
+  try {
+    await pipeline(createReadStream(source, { signal }), count, createWriteStream(destination, { flags: 'wx', mode: 0o600 }), { signal });
+  } catch (error) {
+    // A file that was there already is not this attempt's to remove.
+    if (error?.code !== 'EEXIST') rmSync(destination, { force: true });
+    if (signal?.aborted) throw cancelled();
+    if (error instanceof GitBashError) throw error;
+    throw new GitBashError('disk', `The Git for Windows release file this app carries could not be read (${error?.code || error?.message || error}).`);
+  }
+  const sha256 = hash.digest('hex');
+  if (size !== pin.size || sha256 !== pin.sha256) {
+    rmSync(destination, { force: true });
+    throw new GitBashError('checksum', `${source} is not the pinned ${pin.file} (${size} bytes, sha256 ${sha256}).`, { detail: sha256 });
+  }
+  return { size, sha256 };
+}
+
 /** Renaming a folder on Windows can meet a file an antivirus scanner holds open for a moment: try again, briefly. */
 async function renameWithRetry(from, to, { tries = 6, wait = (ms) => new Promise((done) => setTimeout(done, ms)) } = {}) {
   for (let attempt = 1; ; attempt++) {
@@ -489,9 +528,10 @@ async function renameWithRetry(from, to, { tries = 6, wait = (ms) => new Promise
  * @param {(p: { phase: string, received?: number, total: number, consumed?: number }) => void} [o.onProgress]
  * @param {boolean} [o.worker] unpack in a worker thread (true for the server; tests and builds run it inline)
  * @param {Function} [o.unpack] what unpacks (data, { signal, onProgress, onStep }): unpackInWorker or unpackAndCheck
+ * @param {string|null} [o.archive] the release file an installed app carries: used instead of a download
  * @returns {Promise<{ path: string, version: string }>}
  */
-export async function installGitBash({ pins, pin, root, fetchImpl, signal, onStep = () => {}, onProgress = () => {}, stallMs, worker = true, unpack = null, platform = process.platform, licensesDir }) {
+export async function installGitBash({ pins, pin, root, fetchImpl, signal, onStep = () => {}, onProgress = () => {}, stallMs, worker = true, unpack = null, platform = process.platform, licensesDir, archive = null }) {
   const directory = join(root, pin.version);
   let work = null;
   try {
@@ -501,12 +541,18 @@ export async function installGitBash({ pins, pin, root, fetchImpl, signal, onSte
     work = join(root, `${WORK_PREFIX}${process.pid}-${randomBytes(6).toString('hex')}`);
     mkdirSync(work, { mode: 0o700 });
     const releaseFile = join(work, 'release.part');
-    onStep('download');
-    await downloadPinned({ pin, destination: releaseFile, fetchImpl, signal, stallMs, onProgress: ({ received, total }) => onProgress({ phase: 'download', received, total }) });
+    if (archive) {
+      // The release file this app carries: copied and checked, then unpacked like a download.
+      onStep('extract');
+      await copyPinned({ source: archive, pin, destination: releaseFile, signal });
+    } else {
+      onStep('download');
+      await downloadPinned({ pin, destination: releaseFile, fetchImpl, signal, stallMs, onProgress: ({ received, total }) => onProgress({ phase: 'download', received, total }) });
+    }
     if (signal?.aborted) throw cancelled();
     const tree = join(work, 'tree');
     mkdirSync(tree);
-    const options = { archive: releaseFile, destination: tree, pins, pin, source: 'downloaded', platform, licensesDir };
+    const options = { archive: releaseFile, destination: tree, pins, pin, source: archive ? 'archive' : 'downloaded', platform, licensesDir };
     const report = ({ consumed, total }) => onProgress({ phase: 'extract', consumed, total });
     const run = unpack || (worker
       ? unpackInWorker

package/neural-interface/lib/git-bash/manager.js

@@ -7,23 +7,31 @@
 // Claude Code started by SynaBun get" (resolver.js) and, on a PC that has
 // none, puts SynaBun's own copy of Git for Windows in place:
 //
-//   bundled      inside an installed app: <resources>\git (the Windows x64
-//                installer carries it; packaging/lib/git-bash.mjs)
-//   downloaded   on an npm install: DATA_HOME/runtime/git/<version>/, fetched
-//                once from the pinned release (pins.js), checked and unpacked
-//                by install.js, outside data/ so no backup holds it
+//   bundled      inside an installed app of an earlier build: <resources>\git
+//   downloaded   DATA_HOME/runtime/git/<version>/, outside data/ so no backup
+//                holds it: on an npm install fetched once from the pinned
+//                release (pins.js); in an installed app unpacked from the
+//                release file the Windows x64 installer carries
+//                (<resources>\git-archive\<file>; packaging/lib/git-bash.mjs),
+//                which keeps ~9,600 files out of every install and update. Either
+//                way checked and unpacked by install.js, and kept across updates
+//                (an update from a build with the tree moves that tree here:
+//                packaging/desktop/src/updater/git-adopt.mjs)
 //
-// It downloads only on Windows, only for a processor a release is pinned for,
-// and only when neither the PC nor the app has a Git Bash: at the server's
-// start (ensure) or at the first Claude Code start that finds none (childEnv),
-// once per process. A failed download is not tried again by itself: Settings
+// It downloads (or unpacks the carried release file) only on Windows, only for
+// a processor a release is pinned for, and only when neither the PC nor the app
+// has a Git Bash: at the server's start (ensure) or at the first Claude Code
+// start that finds none (childEnv), once per process. Until it is in place a
+// Claude Code started by SynaBun runs as it does on a PC without Git Bash (its
+// PowerShell fallback); whenReady() waits for it, bounded. A failed download is not tried again by itself: Settings
 // shows why and has the button that tries again. SYNABUN_GIT_BASH=off turns all
 // of it off: no download, nothing added to any environment.
 //
 //   resolution()   the Git Bash in use (refreshed when older than half a minute)
 //   childEnv(env)  the environment of a Claude Code process SynaBun starts
 //   gitExecutable() git.exe of SynaBun's copy when it is the one in use (SynaBun's own git features)
-//   ensure()       download when there is no Git Bash at all; never rejects
+//   ensure()       download (or unpack the carried file) when there is no Git Bash at all; never rejects
+//   whenReady(ms)  resolves the status once no download or unpacking runs, or after `ms`
 //   status()       what Settings shows: missing / downloading / ready / failed, and the rest
 //   onChange(fn)   told when the Git Bash in use changes (the settings of the user's own `claude` follow it)
 //   housekeep()    what an earlier run left in the data home: a stopped attempt's work folder, a version the
@@ -37,7 +45,7 @@ import { packagedRuntime } from '../../../lib/packaged-runtime.js';
 import { pathEnvValue } from '../augmented-path.js';
 import { sweepStaleWork } from '../cloudflared/install.js';
 import { checkInstalled, GitBashError, installGitBash } from './install.js';
-import { BUNDLED_FOLDER, gitBashPinFor, inTree, MARKER, readGitBashPins } from './pins.js';
+import { ARCHIVE_FOLDER, BUNDLED_FOLDER, gitBashPinFor, inTree, MARKER, readGitBashPins } from './pins.js';
 import { gitBashChildEnv, resolveGitBash } from './resolver.js';
 
 const VERSION_FOLDER = /^\d+\.\d+\.\d+\.\d+$/;
@@ -100,6 +108,12 @@ export function createGitBashManager({
   const root = gitRoot(dataHome);
   const bundledRoot = platform === 'win32' && packaged?.resources ? join(packaged.resources, BUNDLED_FOLDER) : null;
   const downloadedRoot = pin ? join(root, pin.version) : null;
+  // The release file an installed Windows app carries (packaging/lib/git-bash.mjs), unpacked instead of a download.
+  const carriedArchive = platform === 'win32' && pin && packaged?.resources ? join(packaged.resources, ARCHIVE_FOLDER, pin.file) : null;
+  const archiveThere = () => {
+    if (!carriedArchive) return false;
+    try { return statSync(carriedArchive).isFile(); } catch { return false; }
+  };
   const ownRoots = [bundledRoot, root].filter(Boolean);
 
   const verified = new Map();   // copy root → { sig, result }: a copy is hashed again only when its marker changes
@@ -110,6 +124,7 @@ export function createGitBashManager({
   let lastError = null;
   let attempted = false;        // a download was started in this process (the first-need trigger fires once)
   let settings = null;          // what the last sync of the user's settings did (noteSettings)
+  let earlyStartLogged = false; // a Claude Code started while the copy was being put in place (said once)
 
   /** SynaBun's own copies, checked: the app's, then the data home's. */
   function copies() {
@@ -179,7 +194,7 @@ export function createGitBashManager({
     return { swept, removed: await pruneOtherVersions() };
   }
 
-  /** Download SynaBun's copy when there is no Git Bash at all. Resolves the status; never rejects. */
+  /** Download (or unpack the carried release file of) SynaBun's copy when there is no Git Bash at all. Resolves the status; never rejects. */
   function ensure({ reason = 'start' } = {}) {
     if (platform !== 'win32' || !pin || off) return Promise.resolve(status());
     if (download) return download.promise.then(() => status());
@@ -187,12 +202,23 @@ export function createGitBashManager({
     attempted = true;
     lastError = null;
     const stop = new AbortController();
-    const job = { stop, step: 'download', progress: { phase: 'download', received: 0, total: pin.size } };
-    log(`[git-bash] No Git Bash on this PC (${reason}): downloading Git for Windows ${pin.version} (${(pin.size / 1024 / 1024).toFixed(1)} MB) from ${pin.url}`);
-    job.promise = install({
-      pins, pin, root, fetchImpl, stallMs, worker, platform: host, signal: stop.signal,
+    const archive = archiveThere() ? carriedArchive : null;
+    const job = { stop, archive, step: archive ? 'extract' : 'download', progress: archive ? { phase: 'extract', consumed: 0, total: pin.size } : { phase: 'download', received: 0, total: pin.size } };
+    const run = (from) => install({
+      pins, pin, root, fetchImpl, stallMs, worker, platform: host, signal: stop.signal, archive: from,
       onStep: (step) => { job.step = step; },
       onProgress: (progress) => { job.progress = progress; },
+    });
+    if (archive) log(`[git-bash] No Git Bash on this PC (${reason}): unpacking Git for Windows ${pin.version} from the release file this app carries (${archive}) in the background`);
+    else log(`[git-bash] No Git Bash on this PC (${reason}): downloading Git for Windows ${pin.version} (${(pin.size / 1024 / 1024).toFixed(1)} MB) from ${pin.url}`);
+    job.promise = run(archive).catch((error) => {
+      // A carried file that cannot be used (damaged, unreadable): the pinned download is the same release.
+      if (!archive || stop.signal.aborted || error?.code === 'cancelled') throw error;
+      log(`[git-bash] The carried release file could not be used (${describe(error).code}): ${describe(error).message} Downloading it instead.`);
+      job.archive = null;
+      job.step = 'download';
+      job.progress = { phase: 'download', received: 0, total: pin.size };
+      return run(null);
     }).then(async (placed) => {
       log(`[git-bash] Git for Windows ${pin.version} is in place, release file and tree checked: ${placed.path}`);
       verified.delete(downloadedRoot);
@@ -209,10 +235,24 @@ export function createGitBashManager({
     return job.promise.then(() => status());
   }
 
+  /** The status once nothing is being put in place, or after `timeoutMs`, whichever comes first. Never rejects. */
+  function whenReady(timeoutMs = 120_000) {
+    if (!download) return Promise.resolve(status());
+    const job = download;
+    return new Promise((done) => {
+      const timer = setTimeout(() => done(status()), Math.max(0, timeoutMs));
+      job.promise.then(() => { clearTimeout(timer); done(status()); }, () => { clearTimeout(timer); done(status()); });
+    });
+  }
+
   function childEnv(base = env) {
     const r = resolution();
     // The first Claude Code start that finds no Git Bash at all fetches one (once per process; Settings retries).
     if (platform === 'win32' && pin && !off && !r.source && !download && !attempted) ensure({ reason: 'first-need' });
+    if (platform === 'win32' && !r.source && download && !earlyStartLogged) {
+      earlyStartLogged = true;
+      log('[git-bash] A Claude Code started while Git for Windows is still being put in place: it runs without Git Bash (its PowerShell fallback) until the next start.');
+    }
     return gitBashChildEnv(base, r, { platform });
   }
 
@@ -240,7 +280,7 @@ export function createGitBashManager({
     if (download) {
       const { phase, received = 0, consumed = 0, total = 0 } = download.progress || {};
       const done = phase === 'extract' ? consumed : received;
-      return { ...base, state: 'downloading', step: download.step, progress: { phase, done, total, percent: total ? Math.min(100, Math.floor((done / total) * 100)) : 0 } };
+      return { ...base, state: 'downloading', step: download.step, fromArchive: !!download.archive, progress: { phase, done, total, percent: total ? Math.min(100, Math.floor((done / total) * 100)) : 0 } };
     }
     if (r.source === 'bundled' || r.source === 'downloaded') return { ...base, state: 'ready' };
     if (r.source) return { ...base, state: 'system' };
@@ -259,7 +299,9 @@ export function createGitBashManager({
     childEnv,
     gitExecutable,
     ensure,
+    whenReady,
     status,
+    carriedArchive,
     housekeep,
     cancel: () => { if (!download) return false; download.stop.abort(); return true; },
     noteSettings: (result) => { settings = result || null; },

package/neural-interface/lib/git-bash/pins.js

@@ -42,6 +42,13 @@ const SOURCE_TREE = 'https://github.com/git-for-windows/git/tree/';
 /** The folder of a packaged application that holds its Git for Windows, beside `runtime/` and `app/`. */
 export const BUNDLED_FOLDER = 'git';
 
+/**
+ * The folder of a packaged Windows application that holds the pinned release file itself (`<file>` of the pin):
+ * one file in the installer instead of a tree of ten thousand, unpacked into the data home on first need
+ * (manager.js) and kept there across updates.
+ */
+export const ARCHIVE_FOLDER = 'git-archive';
+
 /** What SynaBun puts at the top of its copy, beside what the release file holds (never part of the tree's digest). */
 export const MARKER = 'synabun-git.json';
 export const ADDED_FILES = Object.freeze(['LICENSE.txt', 'SOURCE.txt', MARKER]);
@@ -155,6 +162,11 @@ export function bundledGitRoot(resources, platform = process.platform) {
   return (platform === 'win32' ? win32 : posix).join(resources, BUNDLED_FOLDER);
 }
 
+/** The release file a packaged application carries for `pin`: `<resources>/git-archive/<file>`. */
+export function bundledGitArchive(resources, pin, platform = process.platform) {
+  return (platform === 'win32' ? win32 : posix).join(resources, ARCHIVE_FOLDER, pin.file);
+}
+
 /** LICENSE.txt of SynaBun's copy: Git's own license texts of the pinned tag, after a line that says what they cover. */
 export function licenseText(dir = LICENSES_DIR) {
   const copying = readFileSync(join(dir, 'COPYING'), 'utf8');

package/neural-interface/lib/git-read.js

@@ -126,12 +126,12 @@ export function readsIndex(args) {
  * @param {string[]} args the command and its arguments, the command first (['status', '--porcelain'])
  * @param {{ monitor?: boolean }} [o] `monitor`: the repository has git's built-in file system monitor switched on
  */
-export function gitReadArgs(args, { monitor = false } = {}) {
+export function gitReadArgs(args, { monitor = false, nullDevice = devNull } = {}) {
   const [command, ...rest] = Array.isArray(args) ? args : [];
   const own = [
     '--no-pager',
     '-c', `core.fsmonitor=${monitor === true ? 'true' : 'false'}`,
-    '-c', `core.hooksPath=${devNull}`,
+    '-c', `core.hooksPath=${nullDevice}`,
     '-c', 'log.showSignature=false',
   ];
   if (command === undefined) return own;