synabun 2.0.5 → 2.0.7

package/neural-interface/lib/codex-settings-schema.js

@@ -0,0 +1,120 @@
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync, statSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const cache = new Map();
+const featureCache = new Map();
+export const CODEX_SETTINGS_KEYS = Object.freeze([
+  'model', 'review_model', 'model_provider', 'approval_policy', 'sandbox_mode', 'personality',
+  'service_tier', 'model_reasoning_effort', 'model_reasoning_summary', 'model_verbosity',
+  'model_context_window', 'model_auto_compact_token_limit', 'web_search',
+]);
+
+export function schemaEnum(schema, definitions) {
+  if (!schema) return [];
+  if (schema.$ref) return schemaEnum(definitions[schema.$ref.split('/').pop()], definitions);
+  return [...new Set([...(schema.enum || []).filter(v => typeof v === 'string'),
+    ...['anyOf', 'oneOf', 'allOf'].flatMap(k => (schema[k] || []).flatMap(s => schemaEnum(s, definitions)))])];
+}
+
+export function settingsSchemaFromProtocol(configSchema, threadSchema) {
+  const properties = configSchema.definitions?.Config?.properties || {};
+  const fields = {};
+  for (const key of CODEX_SETTINGS_KEYS) {
+    const field = properties[key];
+    if (!field || /@deprecated/.test(field.description || '')) continue;
+    const values = schemaEnum(field, configSchema.definitions || {});
+    fields[key] = { values, enumerated: values.length > 0,
+      type: key.includes('token_limit') || key === 'model_context_window' ? 'number' : 'select' };
+  }
+  // Some older runtimes expose personality only on thread/turn params. Newer
+  // ones explicitly retain it as a no-op: never present a no-op preference.
+  const personality = threadSchema.properties?.personality;
+  if (personality && !/@deprecated/.test(personality.description || '')) {
+    fields.personality = { type: 'select', values: schemaEnum(personality, threadSchema.definitions || {}) };
+  }
+  return { fields };
+}
+
+/** Generate from the executable we actually launch; never use the global home. */
+export function readCodexSettingsSchema(codexBin) {
+  const stamp = statSync(codexBin);
+  const key = `${codexBin}:${stamp.mtimeMs}:${stamp.size}`;
+  if (cache.has(key)) return cache.get(key);
+  const home = mkdtempSync(join(tmpdir(), 'synabun-codex-schema-'));
+  try {
+    const out = join(home, 'schema');
+    const run = spawnSync(codexBin, ['app-server', 'generate-json-schema', '--experimental', '--out', out], {
+      env: { ...process.env, CODEX_HOME: home }, encoding: 'utf8', timeout: 15000, windowsHide: true,
+    });
+    if (run.error || run.status !== 0) throw new Error('Codex could not report its settings schema');
+    const read = name => JSON.parse(readFileSync(join(out, 'v2', `${name}.json`), 'utf8'));
+    const schema = settingsSchemaFromProtocol(read('ConfigReadResponse'), read('ThreadStartParams'));
+    // Protocol enums can retain deprecated variants that the config loader
+    // already rejects (0.162 still exports `untrusted`). Ask the loader too.
+    // `features list` validates config locally and never runs a model or tool.
+    for (const [fieldKey, field] of Object.entries(schema.fields)) {
+      field.values = field.values.filter(value => {
+        const check = spawnSync(codexBin, ['-c', `${fieldKey}=${JSON.stringify(value)}`, 'features', 'list'], {
+          env: { ...process.env, CODEX_HOME: home }, encoding: 'utf8', timeout: 5000, windowsHide: true,
+        });
+        return !check.error && check.status === 0;
+      });
+    }
+    cache.set(key, schema);
+    return schema;
+  } finally { rmSync(home, { recursive: true, force: true }); }
+}
+
+export function validateCodexSettings(config, schema, features = []) {
+  const result = {};
+  for (const [key, value] of Object.entries(config || {})) {
+    if (key === 'features') {
+      if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('Invalid feature settings');
+      Object.assign(result, validateCodexSettings(Object.fromEntries(Object.entries(value).map(([k, v]) => [`features.${k}`, v])), schema, features));
+      continue;
+    }
+    if (key.startsWith('features.')) {
+      const feature = features.find(f => `features.${f.name}` === key && ['stable', 'beta'].includes(f.stage) && f.configurable !== false);
+      if (!feature || typeof value !== 'boolean') throw new Error(`Unsupported Codex feature: ${key}`);
+    } else {
+      const field = schema.fields?.[key];
+      if (!field) throw new Error(`Unsupported Codex setting: ${key}`);
+      if (value !== null) {
+        if (field.type === 'number') {
+          if (!Number.isSafeInteger(value) || value <= 0) throw new Error(`Invalid token count: ${key}`);
+        } else if (typeof value !== 'string' || !value || ((field.enumerated || field.values.length) && !field.values.includes(value))) {
+          // Preserve granular approval policies; only the UI's string choices are editable.
+          throw new Error(`Invalid Codex setting value: ${key}`);
+        }
+      }
+    }
+    result[key] = value;
+  }
+  return result;
+}
+
+/** Some stable flags are now mandatory and ignore false (e.g. unified_exec).
+ * Check both states with the local loader instead of offering a no-op switch. */
+export function readCodexFeatureSupport(codexBin, features) {
+  const names = features.filter(f => ['stable', 'beta'].includes(f.stage) && /^[A-Za-z0-9_-]+$/.test(f.name)).map(f => f.name).sort();
+  const stat = statSync(codexBin);
+  const key = `${codexBin}:${stat.mtimeMs}:${stat.size}:${names.join(',')}`;
+  if (featureCache.has(key)) return featureCache.get(key);
+  const home = mkdtempSync(join(tmpdir(), 'synabun-feature-support-'));
+  try {
+    const states = [false, true].map(value => {
+      const check = spawnSync(codexBin, ['-c', `features={${names.map(name => `${name}=${value}`).join(',')}}`, 'features', 'list'], {
+        env: { ...process.env, CODEX_HOME: home }, encoding: 'utf8', timeout: 10000, windowsHide: true,
+      });
+      if (check.error || check.status !== 0) throw new Error('Codex could not validate feature switches');
+      return new Map(check.stdout.split('\n').map(line => {
+        const parts = line.trim().split(/\s+/); return [parts[0], parts.at(-1)];
+      }));
+    });
+    const supported = Object.fromEntries(names.map(name => [name, states[0].get(name) === 'false' && states[1].get(name) === 'true']));
+    featureCache.set(key, supported);
+    return supported;
+  } finally { rmSync(home, { recursive: true, force: true }); }
+}

package/neural-interface/lib/desktop/config.js

@@ -446,6 +446,9 @@ export const DESKTOP_DEFAULTS = Object.freeze({
         bundleIds: ['com.apple.Terminal', 'com.googlecode.iterm2', 'dev.warp.Warp-Stable', 'com.mitchellh.ghostty', 'net.kovidgoyal.kitty', 'com.github.wez.wezterm', 'org.alacritty', 'co.zeit.hyper'],
         reason: 'Terminal emulators are off-limits (your other agents run there); use your own shell tool instead',
       },
+      // The SynaBun desktop app (packaging/desktop): every window it has is SynaBun's own interface, as the
+      // synabun-ui rule below says of SynaBun in a browser or a web app.
+      { id: 'synabun-app', bundleIds: ['ai.synabun.app'], reason: "SynaBun's own interface" },
     ],
     // Arrays replace wholesale (mergeConfig): a user's own protectedWindows (or
     // blockedApps) list drops every default rule below, including the localized

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

@@ -0,0 +1,339 @@
+// ═══════════════════════════════════════════
+// SynaBun — bzip2, read
+// ═══════════════════════════════════════════
+//
+// Git for Windows publishes its full installation as a .tar.bz2, and Node has
+// no bzip2. A Windows 10 tar.exe may not have one either (older builds stop at
+// "unable to run program bzip2 -d"), so SynaBun reads the file itself, the same
+// way on the build machine and on the user's: this decoder, then the tar
+// reader in install.js.
+//
+// The whole format of bzip2 1.0 (Julian Seward's): one stream or several
+// concatenated, each "BZh1".."BZh9", blocks of Huffman-coded move-to-front
+// values with their runs, the inverse Burrows-Wheeler transform, the final run
+// decoding. Every block's CRC is compared with the one it carries, and every
+// stream's combined CRC with its trailer: a block that decodes to anything else
+// than what was compressed stops the read. A "randomised" block (written only
+// by bzip2 0.9.0, before 1998) is refused rather than guessed at.
+//
+// What it hands out is the decompressed bytes, block by block
+// (bunzip2Blocks: a generator, so a caller can stop at any block, and see how
+// far into the file it got). Every problem is a Bzip2Error.
+//
+// No imports: install.js and the extraction worker load it, and so does a
+// build, from the application it stages.
+
+export class Bzip2Error extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'Bzip2Error';
+    this.code = 'unpack';
+  }
+}
+
+const BLOCK_MAGIC_HI = 0x314159;   // π
+const BLOCK_MAGIC_LO = 0x265359;
+const END_MAGIC_HI = 0x177245;     // √π
+const END_MAGIC_LO = 0x385090;
+const MAX_GROUPS = 6;
+const MAX_ALPHA = 258;
+const MAX_CODE_LEN = 20;
+const MAX_SELECTORS = 18002;
+const RUNA = 0;
+const RUNB = 1;
+const GROUP_SIZE = 50;
+
+/** CRC-32 as bzip2 has it: polynomial 0x04c11db7, most significant bit first. */
+const CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let i = 0; i < 256; i++) {
+    let c = i << 24;
+    for (let k = 0; k < 8; k++) c = (c & 0x80000000) ? (c << 1) ^ 0x04c11db7 : c << 1;
+    table[i] = c >>> 0;
+  }
+  return table;
+})();
+
+/** Reads a Buffer bit by bit, most significant bit first. */
+class BitReader {
+  constructor(buffer) {
+    this.buffer = buffer;
+    this.pos = 0;      // the next byte to take
+    this.bits = 0;     // what is held, in the low `count` bits
+    this.count = 0;
+  }
+
+  /** `n` bits (1 to 24) as a number. */
+  read(n) {
+    while (this.count < n) {
+      if (this.pos >= this.buffer.length) throw new Bzip2Error('The archive ends inside a compressed block.');
+      this.bits = ((this.bits << 8) | this.buffer[this.pos++]) >>> 0;
+      this.count += 8;
+    }
+    this.count -= n;
+    const value = (this.bits >>> this.count) & ((1 << n) - 1);
+    this.bits &= (1 << this.count) - 1;
+    return value;
+  }
+
+  bit() {
+    if (this.count === 0) {
+      if (this.pos >= this.buffer.length) throw new Bzip2Error('The archive ends inside a compressed block.');
+      this.bits = this.buffer[this.pos++];
+      this.count = 8;
+    }
+    this.count--;
+    const value = (this.bits >>> this.count) & 1;
+    this.bits &= (1 << this.count) - 1;
+    return value;
+  }
+
+  read32() {
+    return ((this.read(16) << 16) | this.read(16)) >>> 0;
+  }
+
+  /** Drop what is left of the current byte (a stream ends on a byte boundary). */
+  align() {
+    this.bits = 0;
+    this.count = 0;
+  }
+
+  get done() {
+    return this.count === 0 && this.pos >= this.buffer.length;
+  }
+}
+
+/** Canonical Huffman decoding tables of one group, as bzip2's hbCreateDecodeTables makes them. */
+function decodeTables(lengths, alphaSize) {
+  let minLen = 32;
+  let maxLen = 0;
+  for (let i = 0; i < alphaSize; i++) {
+    if (lengths[i] > maxLen) maxLen = lengths[i];
+    if (lengths[i] < minLen) minLen = lengths[i];
+  }
+  const perm = new Int32Array(MAX_ALPHA);
+  const base = new Int32Array(MAX_CODE_LEN + 2);
+  const limit = new Int32Array(MAX_CODE_LEN + 1).fill(-1);
+  let pp = 0;
+  for (let len = minLen; len <= maxLen; len++) for (let j = 0; j < alphaSize; j++) if (lengths[j] === len) perm[pp++] = j;
+  for (let i = 0; i < alphaSize; i++) base[lengths[i] + 1]++;
+  for (let i = 1; i < base.length; i++) base[i] += base[i - 1];
+  let vec = 0;
+  for (let len = minLen; len <= maxLen; len++) {
+    vec += base[len + 1] - base[len];
+    limit[len] = vec - 1;
+    vec <<= 1;
+  }
+  for (let len = minLen + 1; len <= maxLen; len++) base[len] = ((limit[len - 1] + 1) << 1) - base[len];
+  return { minLen, maxLen, perm, base, limit };
+}
+
+/** The next symbol of a group's code. */
+function nextSymbol(reader, table) {
+  let len = table.minLen;
+  let code = reader.read(len);
+  while (len <= table.maxLen && code > table.limit[len]) {
+    len++;
+    code = (code << 1) | reader.bit();
+  }
+  if (len > table.maxLen) throw new Bzip2Error('The archive holds a code its tables do not know.');
+  const index = code - table.base[len];
+  if (index < 0 || index >= MAX_ALPHA) throw new Bzip2Error('The archive holds a code its tables do not know.');
+  return table.perm[index];
+}
+
+/**
+ * One block, from just after its magic: its bytes (the final run decoding done) and the CRC it carries.
+ * `tt` is the block's workspace, as large as the stream's block size.
+ */
+function decodeBlock(reader, tt, blockSize) {
+  const storedCrc = reader.read32();
+  if (reader.bit()) throw new Bzip2Error('The archive has a randomised block (bzip2 0.9.0), which this reader does not read.');
+  const origPtr = reader.read(24);
+
+  // Which byte values the block uses.
+  const used = [];
+  const inUse16 = reader.read(16);
+  for (let i = 0; i < 16; i++) {
+    if (!(inUse16 & (0x8000 >>> i))) continue;
+    const bits = reader.read(16);
+    for (let j = 0; j < 16; j++) if (bits & (0x8000 >>> j)) used.push(i * 16 + j);
+  }
+  if (!used.length) throw new Bzip2Error('The archive has a block that uses no byte value.');
+  const alphaSize = used.length + 2;
+  const eob = used.length + 1;
+
+  // The Huffman groups and which one codes each run of fifty symbols.
+  const groups = reader.read(3);
+  if (groups < 2 || groups > MAX_GROUPS) throw new Bzip2Error('The archive has a block with an impossible number of code tables.');
+  const selectorCount = reader.read(15);
+  if (selectorCount < 1) throw new Bzip2Error('The archive has a block without code selectors.');
+  const mtfGroups = [0, 1, 2, 3, 4, 5].slice(0, groups);
+  const selectors = new Uint8Array(Math.min(selectorCount, MAX_SELECTORS));
+  for (let i = 0; i < selectorCount; i++) {
+    let j = 0;
+    while (reader.bit()) {
+      j++;
+      if (j >= groups) throw new Bzip2Error('The archive has a block with an impossible code selector.');
+    }
+    // Selectors past the most a block can use are read and dropped, as bzip2 1.0.8 does.
+    if (i >= MAX_SELECTORS) continue;
+    const value = mtfGroups[j];
+    for (let k = j; k > 0; k--) mtfGroups[k] = mtfGroups[k - 1];
+    mtfGroups[0] = value;
+    selectors[i] = value;
+  }
+
+  const tables = [];
+  for (let t = 0; t < groups; t++) {
+    const lengths = new Uint8Array(alphaSize);
+    let current = reader.read(5);
+    for (let i = 0; i < alphaSize; i++) {
+      for (;;) {
+        if (current < 1 || current > MAX_CODE_LEN) throw new Bzip2Error('The archive has a block with an impossible code length.');
+        if (!reader.bit()) break;
+        current += reader.bit() ? -1 : 1;
+      }
+      lengths[i] = current;
+    }
+    tables.push(decodeTables(lengths, alphaSize));
+  }
+
+  // The move-to-front values and their runs: the block before the inverse transform.
+  const counts = new Int32Array(256);
+  const order = new Uint8Array(256);
+  for (let i = 0; i < 256; i++) order[i] = i;
+  let length = 0;
+  let selector = 0;
+  let left = 0;
+  let table = null;
+  const next = () => {
+    if (left === 0) {
+      if (selector >= selectors.length) throw new Bzip2Error('The archive has a block that runs past its code selectors.');
+      table = tables[selectors[selector++]];
+      left = GROUP_SIZE;
+    }
+    left--;
+    return nextSymbol(reader, table);
+  };
+  let symbol = next();
+  for (;;) {
+    if (symbol === eob) break;
+    if (symbol === RUNA || symbol === RUNB) {
+      let run = 0;
+      let weight = 1;
+      do {
+        run += (symbol === RUNA ? 1 : 2) * weight;
+        weight <<= 1;
+        if (run > blockSize) throw new Bzip2Error('The archive has a block larger than its stream says blocks are.');
+        symbol = next();
+      } while (symbol === RUNA || symbol === RUNB);
+      const value = used[order[0]];
+      if (length + run > blockSize) throw new Bzip2Error('The archive has a block larger than its stream says blocks are.');
+      counts[value] += run;
+      tt.fill(value, length, length + run);
+      length += run;
+      continue;
+    }
+    if (length >= blockSize) throw new Bzip2Error('The archive has a block larger than its stream says blocks are.');
+    const index = symbol - 1;
+    const front = order[index];
+    order.copyWithin(1, 0, index);
+    order[0] = front;
+    const value = used[front];
+    counts[value]++;
+    tt[length++] = value;
+    symbol = next();
+  }
+  if (origPtr >= length) throw new Bzip2Error('The archive has a block whose start lies outside it.');
+
+  // The inverse Burrows-Wheeler transform: each byte's successor in the upper 24 bits.
+  const start = new Int32Array(256);
+  for (let i = 0, sum = 0; i < 256; i++) { start[i] = sum; sum += counts[i]; }
+  for (let i = 0; i < length; i++) {
+    const value = tt[i] & 0xff;
+    tt[start[value]++] |= i << 8;
+  }
+
+  // The final run decoding (four equal bytes and a count), with the CRC over what comes out.
+  let out = Buffer.allocUnsafe(Math.max(1024, length + (length >>> 2)));
+  let at = 0;
+  let crc = 0xffffffff;
+  const room = (need) => {
+    const bigger = Buffer.allocUnsafe(Math.max(need, out.length * 2));
+    out.copy(bigger, 0, 0, at);
+    out = bigger;
+  };
+  let pos = tt[origPtr] >>> 8;
+  let last = -1;
+  let same = 0;
+  for (let i = 0; i < length; i++) {
+    const entry = tt[pos];
+    const byte = entry & 0xff;
+    pos = entry >>> 8;
+    if (same === 4) {
+      if (at + byte > out.length) room(at + byte);
+      for (let k = 0; k < byte; k++) {
+        out[at++] = last;
+        crc = (crc << 8) ^ CRC_TABLE[((crc >>> 24) ^ last) & 0xff];
+      }
+      same = 0;
+      last = -1;
+      continue;
+    }
+    if (byte === last) same++;
+    else { last = byte; same = 1; }
+    if (at === out.length) room(at + 1);
+    out[at++] = byte;
+    crc = (crc << 8) ^ CRC_TABLE[((crc >>> 24) ^ byte) & 0xff];
+  }
+  crc = (~crc) >>> 0;
+  if (crc !== storedCrc) throw new Bzip2Error('A block of the archive does not decode to what was compressed (CRC mismatch).');
+  return { data: out.subarray(0, at), crc };
+}
+
+/**
+ * The decompressed bytes of `buffer` (one or more concatenated bzip2 streams), one block at a time. `progress`,
+ * when given, is told after each block how far into `buffer` the reader is.
+ * @param {Buffer} buffer
+ * @param {{ progress?: (consumed: number, total: number) => void }} [o]
+ */
+export function* bunzip2Blocks(buffer, { progress } = {}) {
+  const reader = new BitReader(buffer);
+  let streams = 0;
+  while (!reader.done) {
+    // Zero bytes after the last stream are padding some writers leave; anything else has to be a stream.
+    if (streams > 0 && buffer.subarray(reader.pos).every((byte) => byte === 0)) break;
+    if (reader.read(8) !== 0x42 || reader.read(8) !== 0x5a || reader.read(8) !== 0x68) throw new Bzip2Error(streams ? 'The archive has something after its last stream.' : 'The archive is not a bzip2 file.');
+    const level = reader.read(8) - 0x30;
+    if (level < 1 || level > 9) throw new Bzip2Error('The archive names an impossible block size.');
+    const blockSize = level * 100000;
+    const tt = new Uint32Array(blockSize);
+    let combined = 0;
+    for (;;) {
+      const hi = reader.read(24);
+      const lo = reader.read(24);
+      if (hi === BLOCK_MAGIC_HI && lo === BLOCK_MAGIC_LO) {
+        const block = decodeBlock(reader, tt, blockSize);
+        combined = (((combined << 1) | (combined >>> 31)) ^ block.crc) >>> 0;
+        progress?.(reader.pos, buffer.length);
+        if (block.data.length) yield block.data;
+        continue;
+      }
+      if (hi === END_MAGIC_HI && lo === END_MAGIC_LO) {
+        if (reader.read32() !== combined) throw new Bzip2Error('The archive does not decode to what was compressed (stream CRC mismatch).');
+        reader.align();
+        break;
+      }
+      throw new Bzip2Error('The archive has something that is not a bzip2 block.');
+    }
+    streams++;
+  }
+  if (!streams) throw new Bzip2Error('The archive is empty.');
+}
+
+/** All of `buffer`, decompressed (tests and small files). */
+export function bunzip2(buffer) {
+  const parts = [...bunzip2Blocks(buffer)];
+  return Buffer.concat(parts);
+}

package/neural-interface/lib/git-bash/claude-settings.js

@@ -0,0 +1,73 @@
+// ═══════════════════════════════════════════
+// SynaBun — Git Bash for the user's own `claude`
+// ═══════════════════════════════════════════
+//
+// Every Claude Code that SynaBun starts gets its Git Bash in its environment
+// (resolver.js gitBashChildEnv). A `claude` the user starts in another
+// terminal does not: on a PC whose only Git Bash is SynaBun's copy, that one
+// is named in the `env` block of ~/.claude/settings.json, which Claude Code
+// applies before it looks for Git Bash (checked in its 2.1.302 build:
+// applySafeConfigEnvironmentVariables applies the user settings' env in full,
+// in init(), before the Git Bash lookup).
+//
+//   SynaBun's copy is in use   env.CLAUDE_CODE_GIT_BASH_PATH = its bash.exe,
+//                              unless the user put a value of their own there
+//   it is not                  a value that is SynaBun's (a path inside one of
+//                              its copies) is removed; any other is left
+//
+// Windows only. The file is read and written by the caller's functions
+// (server.js readClaudeSettingsForWrite / writeClaudeSettings: a file that is
+// not JSON is never written over, and the write is atomic). Never throws.
+
+import { GIT_BASH_ENV, insideAny } from './resolver.js';
+
+/**
+ * Bring the user's settings in line with the Git Bash in use.
+ * @param {object} o
+ * @param {{ source: string|null, path: string|null }} o.resolution  resolver.js resolveGitBash()
+ * @param {string} o.settingsPath   ~/.claude/settings.json
+ * @param {(path: string) => object} o.read    {} when the file does not exist; throws when it is not JSON
+ * @param {(path: string, settings: object) => void} o.write
+ * @param {string[]} o.ownRoots     SynaBun's own Git folders
+ * @returns {{ state: 'skipped' | 'unchanged' | 'written' | 'removed' | 'kept-user-value' | 'error', value?: string|null, message?: string }}
+ */
+export function syncClaudeSettingsGitBash({ resolution, settingsPath, read, write, ownRoots = [], platform = process.platform }) {
+  if (platform !== 'win32' || !settingsPath) return { state: 'skipped' };
+  const ours = resolution?.source === 'bundled' || resolution?.source === 'downloaded' ? resolution.path : null;
+  let settings;
+  try { settings = read(settingsPath); } catch (error) {
+    return { state: 'error', message: String(error?.message || error) };
+  }
+  if (!settings || typeof settings !== 'object' || Array.isArray(settings)) return { state: 'error', message: `${settingsPath} does not hold a settings object.` };
+  const env = settings.env && typeof settings.env === 'object' && !Array.isArray(settings.env) ? settings.env : null;
+  const current = typeof env?.[GIT_BASH_ENV] === 'string' ? env[GIT_BASH_ENV] : null;
+  const isOurs = current !== null && insideAny(current, ownRoots);
+
+  if (ours) {
+    if (current === ours) return { state: 'unchanged', value: ours };
+    // A value of the user's own (one that does not work, or the resolver would have taken it) is theirs to change.
+    if (current !== null && !isOurs) return { state: 'kept-user-value', value: current };
+    settings.env = { ...(env || {}), [GIT_BASH_ENV]: ours };
+  } else {
+    if (!isOurs) return { state: 'unchanged', value: current };
+    const rest = { ...env };
+    delete rest[GIT_BASH_ENV];
+    if (Object.keys(rest).length) settings.env = rest;
+    else delete settings.env;
+  }
+  try {
+    write(settingsPath, settings);
+  } catch (error) {
+    return { state: 'error', message: String(error?.message || error) };
+  }
+  return ours ? { state: 'written', value: ours } : { state: 'removed', value: null };
+}
+
+/** The user's own value of CLAUDE_CODE_GIT_BASH_PATH in their settings, or null (what the resolver weighs). */
+export function settingsGitBashValue({ settingsPath, read }) {
+  try {
+    const settings = read(settingsPath);
+    const value = settings?.env?.[GIT_BASH_ENV];
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+  } catch { return null; }
+}

package/neural-interface/lib/git-bash/extract-worker.js

@@ -0,0 +1,34 @@
+// ═══════════════════════════════════════════
+// SynaBun — Git for Windows: the unpacking, in a thread of its own
+// ═══════════════════════════════════════════
+//
+// install.js unpackInWorker() starts this with what unpackAndCheck() takes and
+// a shared flag the server raises to stop it. The reading of the .tar.bz2, the
+// writing of some ten thousand files and the digest of what was written take
+// about a minute of CPU: here, they never hold the server's event loop. The
+// thread answers with messages: `step`, `progress` (a few times a second at
+// most), then `done` with the result or `error` with a GitBashError's code.
+
+import { parentPort, workerData } from 'node:worker_threads';
+import { asGitBashError, unpackAndCheck } from './install.js';
+
+const { flag, ...options } = workerData;
+let last = 0;
+
+try {
+  const result = unpackAndCheck({
+    ...options,
+    stopped: () => Atomics.load(flag, 0) === 1,
+    onStep: (step) => parentPort.postMessage({ type: 'step', step }),
+    onProgress: (progress) => {
+      const now = Date.now();
+      if (progress.consumed !== progress.total && now - last < 250) return;
+      last = now;
+      parentPort.postMessage({ type: 'progress', progress });
+    },
+  });
+  parentPort.postMessage({ type: 'done', result });
+} catch (failure) {
+  const error = asGitBashError(failure, 'unpack', 'The archive could not be unpacked.');
+  parentPort.postMessage({ type: 'error', code: error.code, message: error.message, detail: error.detail || null });
+}