@vzn/vx 0.0.651 → 0.0.653

package/src/cache/checkpointer.ts

@@ -0,0 +1,102 @@
+// The index's WAL checkpoints, on a thread of their own while a run saves.
+// SQLite checkpoints on the committing connection once the WAL passes 1,000
+// pages: on a cold run that was the main thread, the scheduler's, copying
+// pages and waiting on two fsyncs a checkpoint, stalls of up to 750 ms in
+// a cold 8,002-task run (2026-11-06). Here a second connection checkpoints
+// PASSIVE on a timer: it never waits on a lock and never blocks the writer,
+// which appends as before; the run's connection checkpoints nothing until
+// its close, which finds the WAL nearly copied.
+
+import { SQLITE_FCNTL_PERSIST_WAL } from './schema.js'
+
+/** How often the thread checkpoints: about 1,000 pages of a cold run's writes. */
+const EVERY_MS = 100
+
+// The thread as source, not a file: a compiled vx carries only its entry
+// points' graphs (spawn-off.ts does the same).
+const WORKER = `
+const { Database } = require('bun:sqlite')
+let db
+let timer
+const schemas = []
+const tick = () => {
+  for (const s of schemas) {
+    try {
+      db.exec('PRAGMA ' + s + '.wal_checkpoint(PASSIVE)')
+    } catch {
+      // Busy or gone: the next tick, or the run's close, copies it.
+    }
+  }
+}
+self.onmessage = (e) => {
+  const m = e.data
+  if (m.open !== undefined) {
+    db = new Database(m.open.index)
+    // As Cache opens it: a close here must not delete the WAL (O-10).
+    db.fileControl(${SQLITE_FCNTL_PERSIST_WAL}, 1)
+    schemas.push('main')
+    if (m.open.store !== undefined) {
+      // Finalized: a statement still alive left the close a zombie
+      // connection, and a write right after the run was SQLITE_BUSY
+      // (shared-store.test.ts).
+      const attach = db.prepare('ATTACH DATABASE ? AS store')
+      attach.run(m.open.store)
+      attach.finalize()
+      db.fileControl('store', ${SQLITE_FCNTL_PERSIST_WAL}, 1)
+      schemas.push('store')
+    }
+    timer = setInterval(tick, m.everyMs)
+    return
+  }
+  clearInterval(timer)
+  try {
+    db?.close()
+  } catch {
+    // The run's own close copies what is left.
+  }
+  postMessage({ ended: true })
+}
+`
+
+export class WalCheckpointer {
+  private readonly worker: Worker
+  private failed = false
+  private ended: (() => void) | undefined
+
+  /** Starts checkpointing `files` every `everyMs`; `onError` hears a thread that could not. */
+  constructor(
+    files: { index: string; store?: string },
+    onError: () => void,
+    everyMs: number = EVERY_MS,
+  ) {
+    const w = new Worker(URL.createObjectURL(new Blob([WORKER], { type: 'text/javascript' })))
+    // A run that throws before `stop` must still exit.
+    w.unref()
+    w.onmessage = () => this.ended?.()
+    w.onerror = (e) => {
+      e.preventDefault()
+      this.failed = true
+      this.ended?.()
+      onError()
+    }
+    w.postMessage({ open: files, everyMs })
+    this.worker = w
+  }
+
+  /** Stops the timer and closes the thread's connection, so the run's close is the last. */
+  async stop(): Promise<void> {
+    if (!this.failed) {
+      this.worker.ref()
+      await new Promise<void>((resolve) => {
+        this.ended = resolve
+        this.worker.postMessage({ end: true })
+      })
+    }
+    this.worker.terminate()
+  }
+
+  /** A close that could not wait for `stop`: the thread ends where it is. */
+  terminate(): void {
+    this.worker.terminate()
+  }
+}

package/src/cache/file-hashes.ts

@@ -138,7 +138,7 @@ export class FileHashStore {
    * form while this hashes the worktree bytes, so `inputs.ts` drops
    * the index OID for those paths and routes them here.
    */
-  async hashFile(filePath: string): Promise<string> {
+  async hashFile(filePath: string, seen?: (ctimeMs: number) => void): Promise<string> {
     // lstatSync intentional: a single stat is ~1.6µs (Bun 1.3); the
     // async-stat equivalent adds ~75µs of Promise machinery per call.
     // Promise.all over the batched callers (key derivation) gives no
@@ -154,6 +154,7 @@ export class FileHashStore {
       // a more useful error.
       return await this.hashFileFromDisk(filePath)
     }
+    seen?.(st.ctimeMs)
     // A symlink's identity is git's: the blob of its TARGET STRING, its
     // mode-120000 index OID, so a retarget moves it. What it points to
     // folds after it (linked-inputs.ts). No memo: readlink is one syscall,

package/src/cache/fold-memo.ts

@@ -22,6 +22,7 @@ export interface FoldMemo {
 
 export class IndexFoldMemo implements FoldMemo {
   private rows: Map<string, FoldMemoRow> | undefined
+  private readonly runRows = new Map<string, FoldMemoRow | null>()
   private readonly dirty = new Map<string, FoldMemoRow>()
 
   constructor(
@@ -32,18 +33,37 @@ export class IndexFoldMemo implements FoldMemo {
 
   /** The key remembered for `taskId` under `probe`, if that is the probe it was folded under. */
   get(taskId: string, probe: string): string | undefined {
-    // One read of every row: a warm run asks for nearly all of them.
+    const row = this.dirty.get(taskId) ?? this.read(taskId)
+    return row?.probe === probe ? row.key : undefined
+  }
+
+  private read(taskId: string): FoldMemoRow | null | undefined {
+    // A run's own rows (`\0run\0…`, the graph's) are read one each: a warm
+    // run whose keys are remembered whole asks for no task's row, and
+    // reading all of them held every task's row to the end of the run.
+    if (taskId.startsWith('\0')) {
+      let row = this.runRows.get(taskId)
+      if (row === undefined) {
+        row = this.db
+          .query('SELECT probe, key FROM fold_memo WHERE task_id = ?')
+          .get(taskId) as FoldMemoRow | null
+        this.runRows.set(taskId, row)
+      }
+      return row
+    }
+    // One read of every task's row: a run that folds asks for nearly all of them.
     this.rows ??= new Map(
       (
-        this.db.query('SELECT task_id, probe, key FROM fold_memo').all() as Array<{
+        this.db
+          .query('SELECT task_id, probe, key FROM fold_memo WHERE task_id >= ?')
+          .all('\u0001') as Array<{
           task_id: string
           probe: string
           key: string
         }>
       ).map((r) => [r.task_id, { probe: r.probe, key: r.key }]),
     )
-    const row = this.dirty.get(taskId) ?? this.rows.get(taskId)
-    return row?.probe === probe ? row.key : undefined
+    return this.rows.get(taskId)
   }
 
   set(taskId: string, probe: string, key: string): void {

package/src/cache/fs-clock.ts

@@ -40,6 +40,32 @@ export function stampGrainMs(stampMs: number): number {
   return stampMs % 1000 === 0 ? 1000 : 0
 }
 
+/**
+ * "Now" as the file system will stamp the next write, not as `Date.now()`
+ * reads it: a stamp read off a file written and removed in `dir` (the
+ * run's cache dir), and every later write's mtime and ctime is at or after
+ * it. Linux before 6.13 stamps from its coarse clock, a tick behind the
+ * fine clock `Date.now()` reads — on the Linux bench box 2026-09-11, 2 of
+ * 3,000 tight writes carried an mtime 5.8 ms EARLIER than a `Date.now()`
+ * taken before the write, and more under CPU load. That lag is under the
+ * one `measureFsClockLag` applies, so a window that asks "written after
+ * this moment?" takes the moment from here: `vx watch`'s arm and cycle
+ * start (an edit right after the ready line was dropped as "before the
+ * arm"), and the re-check's command start. A dir that cannot take the
+ * file falls back to `Date.now()` less the measured lag.
+ */
+export function fsClockNow(dir: string): number {
+  const stamp = path.join(dir, `.vx-clock-${process.pid}`)
+  try {
+    writeFileSync(stamp, '')
+    const at = statSync(stamp).mtimeMs
+    unlinkSync(stamp)
+    return at
+  } catch {
+    return Date.now() - lagMs
+  }
+}
+
 /**
  * Measure the lag from a file written and removed in `dir` (the run's cache
  * dir: on the workspace's file system by default, and ignored by git and

package/src/cache/git-inputs.ts

@@ -8,7 +8,9 @@
 import os from 'node:os'
 import path from 'node:path'
 import {
+  accessSync,
   closeSync,
+  constants as fsConstants,
   existsSync,
   fstatSync,
   lstatSync,
@@ -27,9 +29,11 @@ import {
 import {
   checkIgnoreSync,
   executablePath,
+  gitCaseArgs,
   gitEnv,
   gitFailure,
   gitSpawnRefusal,
+  ignoreCaseLies,
   isInstalledPath,
   notAWorkTree,
   relPosix,
@@ -41,7 +45,18 @@ import { FILE_HASH_RACY_MS, racyWindowMs } from './layer.js'
 /** A name no ignore rule names, standing for a file a task may create. */
 const FRESH_NAME = '__vx_probe__'
 
-/** Three facts of the repository a directory is in: read off the disk, or one `git rev-parse`. */
+/**
+ * Which of `dirs` (relative to `root`) git ignores a new file directly in,
+ * in one `git check-ignore`: `GitFilesCache.newFilesIgnored`'s probe, which
+ * watch asks of the entries a task names (`namedIgnoredReach`).
+ */
+export function newFilesIgnoredIn(root: string, dirs: readonly string[]): Set<string> {
+  const probes = dirs.map((d) => `${d}/${FRESH_NAME}`)
+  const hit = checkIgnoreSync(root, probes)
+  return new Set(dirs.filter((_, i) => hit?.has(probes[i]!) === true))
+}
+
+/** The facts of the repository a directory is in: read off the disk, or one `git rev-parse`. */
 export interface RepoFacts {
   /** `--show-prefix`: the directory's path below the worktree root, `''` at the root. */
   prefix: string
@@ -51,6 +66,8 @@ export interface RepoFacts {
   objectFormat: 'sha1' | 'sha256'
   /** `--git-path index` (it honours `GIT_INDEX_FILE`), relative to the directory asked. */
   indexFile: string
+  /** `--absolute-git-dir`: the per-worktree git dir, which the sandbox walls off when it lies outside. */
+  gitDir: string
 }
 
 const repoFactsMemo = new Map<string, RepoFacts>()
@@ -82,6 +99,7 @@ export function repoFacts(dir: string): RepoFacts | null {
         '--show-object-format',
         '--git-path',
         'index',
+        '--absolute-git-dir',
       ],
       env: gitEnv(),
       cwd: dir,
@@ -95,9 +113,12 @@ export function repoFacts(dir: string): RepoFacts | null {
   // One line per flag, in order. A git that does not know
   // `--show-object-format` echoes it back, as it does any unknown flag,
   // which reads as sha1 — what the flag's own spawn answered there too.
-  const [prefix = '', commonDir = '', format = '', indexFile = ''] = new TextDecoder('utf-8', {
-    ignoreBOM: true,
-  })
+  const [prefix = '', commonDir = '', format = '', indexFile = '', gitDir = ''] = new TextDecoder(
+    'utf-8',
+    {
+      ignoreBOM: true,
+    },
+  )
     .decode(proc.stdout)
     .split('\n')
     .map((l) => l.trim())
@@ -106,6 +127,7 @@ export function repoFacts(dir: string): RepoFacts | null {
     commonDir,
     objectFormat: format === 'sha256' ? 'sha256' : 'sha1',
     indexFile,
+    gitDir,
   }
   repoFactsMemo.set(dir, facts)
   return facts
@@ -172,6 +194,7 @@ function repoFactsFromDisk(dir: string): RepoFacts | undefined {
           commonDir: relPosix(real, dotGit),
           objectFormat,
           indexFile: path.relative(real, path.join(dotGit, 'index')).split(path.sep).join('/'),
+          gitDir: dotGit,
         }
       }
       const parent = path.dirname(at)
@@ -221,6 +244,24 @@ interface PartitionDigest {
   digest: () => string | undefined
 }
 
+/**
+ * `compute`'s answer, computed on the first ask, after which `compute` is
+ * let go: a digest's records are a rope of three strings per file, ~3.7 MB
+ * of heap at 1,601 projects, held to the end of the run otherwise. Built
+ * here, not in the caller, so the caller's scope (which holds `compute`)
+ * is not the getter's.
+ */
+function once<T>(compute: (() => T) | undefined): () => T | undefined {
+  let value: T | undefined
+  return () => {
+    if (compute !== undefined) {
+      value = compute()
+      compute = undefined
+    }
+    return value
+  }
+}
+
 /**
  * A partition's trusted OIDs, built on first read: a warm run whose keys
  * come back from the fold memo reads none, and building 125,000 abs-path
@@ -252,6 +293,8 @@ class OidSlot {
 
 interface IgnoredListing {
   root: string
+  /** `root/` when `root` is absolute and normalized: a normalized path under it is relative as its rest. */
+  base: string | undefined
   paths: readonly string[]
   asked: Map<string, boolean>
 }
@@ -314,7 +357,8 @@ export class GitFilesCache extends Map<string, readonly string[]> {
   /**
    * Under `core.ignorecase` (macOS's default volume) git's `Foo.txt` is the
    * disk's `foo.txt` after a rename git never saw, so paths are compared
-   * case-folded. Decided at the first note: the run's `git var -l`, else
+   * case-folded. Decided at the first note: the run's `git var -l` (false
+   * there when the disk does not fold case, `ignoreCaseLies`), else
    * the platform.
    */
   private foldCase: boolean | undefined
@@ -385,7 +429,13 @@ export class GitFilesCache extends Map<string, readonly string[]> {
   private ignored: IgnoredListing | null = null
 
   setIgnored(root: string, paths: readonly string[]): void {
-    this.ignored = { root, paths, asked: new Map() }
+    const base =
+      path.sep === '/' && path.isAbsolute(root) && path.normalize(root) === root
+        ? root.endsWith('/')
+          ? root
+          : `${root}/`
+        : undefined
+    this.ignored = { root, base, paths, asked: new Map() }
   }
 
   /**
@@ -400,7 +450,17 @@ export class GitFilesCache extends Map<string, readonly string[]> {
   newFilesIgnored(dir: string): boolean {
     const ig = this.ignored
     if (ig === null || ig.paths.length === 0) return false
-    const rel = relPosix(ig.root, dir)
+    // Asked once per project a run keys: `path.relative` was ~2 ms of
+    // 1,601 (2026-11-07). Below a normalized root, a path with no `.`
+    // segment and no doubled or trailing slash is its rest.
+    const rel =
+      ig.base !== undefined &&
+      dir.startsWith(ig.base) &&
+      !dir.includes('/.') &&
+      !dir.includes('//') &&
+      !dir.endsWith('/')
+        ? dir.slice(ig.base.length)
+        : relPosix(ig.root, dir)
     if (rel === '' || rel.startsWith('../')) return false
     let known = ig.asked.get(rel)
     if (known !== undefined) return known
@@ -413,10 +473,7 @@ export class GitFilesCache extends Map<string, readonly string[]> {
       else hi = mid
     }
     known = false
-    if (ig.paths[lo]?.startsWith(under) === true) {
-      const probe = `${under}${FRESH_NAME}`
-      known = checkIgnoreSync(ig.root, [probe])?.has(probe) === true
-    }
+    if (ig.paths[lo]?.startsWith(under) === true) known = newFilesIgnoredIn(ig.root, [rel]).size > 0
     ig.asked.set(rel, known)
     return known
   }
@@ -543,11 +600,10 @@ export class GitFilesCache extends Map<string, readonly string[]> {
     snapshot: readonly string[],
     digest: () => string | undefined,
   ): void {
-    let memo: { value: string | undefined } | undefined
     this.digests.set(projectDir, {
       snapshot,
       oids: this.oids.get(projectDir),
-      digest: () => (memo ??= { value: digest() }).value,
+      digest: once(digest),
     })
   }
 
@@ -565,6 +621,20 @@ export class GitFilesCache extends Map<string, readonly string[]> {
     this.oids.set(projectDir, new OidSlot(build))
   }
 
+  /**
+   * Each file of `snapshot` by its absolute path, filled as callers spell
+   * them: one string per file for the run, however many memo keys resolve
+   * it and whether the OID map names it too. Each spelled its own: a cold
+   * 9,603-task run held ~96,000 path strings for ~32,000 files.
+   */
+  absPaths(snapshot: readonly string[]): Array<string | undefined> {
+    let paths = this.abs.get(snapshot)
+    if (paths === undefined) this.abs.set(snapshot, (paths = []))
+    return paths
+  }
+
+  private readonly abs = new WeakMap<readonly string[], Array<string | undefined>>()
+
   /** Snapshot if still valid for these input globs; undefined → re-spawn. */
   snapshotFor(projectDir: string, inputGlobs: readonly Bun.Glob[]): readonly string[] | undefined {
     const snap = this.get(projectDir)
@@ -685,12 +755,66 @@ const FATAL_UTF8 = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true })
 
 const LS_FILES_STAGE_RE = /^(?:([A-Za-z]) )?([0-7]{6}) ([0-9a-f]{40,64}) ([0-3])\t/
 
+const UNOPENED = "warning: could not open directory '"
+
+/**
+ * Refuses a walk git did not finish. `could not open directory` is a
+ * warning and the exit is 0, so the files under it were in no key: past
+ * PATH_MAX (4096 bytes on Linux) an edit there was a stale hit. A directory
+ * this user may not read is left out as before: no task of theirs reads it
+ * either, and a root-owned volume beside the projects must not stop every
+ * run. git cuts its message at 4096 bytes, so a long path comes with no
+ * reason. `cwd`: where git ran; it names the directory from its work tree's top.
+ */
+function refuseUnopenedDirs(cwd: string, stderr: string): void {
+  if (!stderr.includes(UNOPENED)) return
+  const prefix = repoFacts(cwd)?.prefix ?? ''
+  const top = path.resolve(
+    cwd,
+    ...prefix
+      .split('/')
+      .filter((s) => s !== '')
+      .map(() => '..'),
+  )
+  for (const line of stderr.split('\n')) {
+    if (!line.startsWith(UNOPENED)) continue
+    const rest = line.slice(UNOPENED.length)
+    const end = rest.indexOf("': ")
+    const dir = end === -1 ? rest : rest.slice(0, end)
+    const at = path.resolve(top, dir)
+    // Gone since git read its parent (a run lock's staging directory in a
+    // TMPDIR inside the workspace): no file is under it to miss. Only a
+    // line git did not cut: a cut one may name a prefix of a real path.
+    if (end !== -1 && vanished(at)) continue
+    try {
+      accessSync(at, fsConstants.R_OK | fsConstants.X_OK)
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === 'EACCES') continue
+    }
+    const shown = dir.length > 100 ? `${dir.slice(0, 40)}…${dir.slice(-40)}` : dir
+    throw new UserError(
+      `git could not open the directory ${shown}, so no key would see the files under it. Shorten the path, or ignore it in .gitignore.`,
+      'VX_E_GIT',
+    )
+  }
+}
+
+function vanished(p: string): boolean {
+  try {
+    lstatSync(p)
+    return false
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException).code
+    return code === 'ENOENT' || code === 'ENOTDIR'
+  }
+}
+
 /**
  * Run `git ls-files -s --others --exclude-standard -z .` in `cwd`.
  * One spawn yields BOTH the file list (identical visibility to the
  * pre-v20 `--cached --others` form, verified empirically: same set
- * including staged-but-deleted files and per-stage conflict
- * duplicates) AND each tracked file's index OID — the heart of the
+ * including staged-but-deleted files; an unmerged path, listed there
+ * once per stage, is listed once) AND each tracked file's index OID — the heart of the
  * Turbo-parity "hashes come from git's index" fast path. Throws a
  * `UserError` when git is unavailable or `cwd` isn't a git work
  * tree; vx requires git. `-z` survives filenames with newlines /
@@ -700,7 +824,16 @@ export function runGitLsFiles(cwd: string, env = gitEnv()): GitLsResult {
   let proc
   try {
     proc = Bun.spawnSync({
-      cmd: [executablePath('git'), 'ls-files', '-s', '--others', '--exclude-standard', '-z', '.'],
+      cmd: [
+        executablePath('git'),
+        ...gitCaseArgs(cwd),
+        'ls-files',
+        '-s',
+        '--others',
+        '--exclude-standard',
+        '-z',
+        '.',
+      ],
       env,
       cwd,
       stdout: 'pipe',
@@ -714,6 +847,7 @@ export function runGitLsFiles(cwd: string, env = gitEnv()): GitLsResult {
     // cannot be enumerated, and the two have different fixes.
     throw gitFailure(cwd, 'ls-files', proc.exitCode, new TextDecoder().decode(proc.stderr).trim())
   }
+  refuseUnopenedDirs(cwd, new TextDecoder().decode(proc.stderr))
   const { text, undecodable } = decodeGitZ(proc.stdout)
   const parsed = parseLsFilesOutput(text.length === 0 ? [] : text.split('\0'), undecodable)
   const nested = expandNestedRepos(cwd, parsed.files, parsed.gitlinks)
@@ -915,6 +1049,14 @@ function parseLsFilesOutput(
     const m = LS_FILES_STAGE_RE.exec(record)
     const filePath = m === null ? record : record.slice(m[0].length) // --others: bare path
     if (m === null && isInstalledPath(filePath)) continue
+    // An unmerged path prints once per stage (1, 2, 3), in a row. Listed
+    // each time, the key folded the file once per stage, so a conflict
+    // resolved on disk keyed apart from the same bytes once added. It
+    // carries no OID either way: its worktree bytes are what folds.
+    if (m !== null && m[4] !== '0' && files.length > 0 && files[files.length - 1] === filePath) {
+      if (m[2] === '160000') gitlinks.add(filePath)
+      continue
+    }
     files.push(filePath)
     if (undecodableRecords.size > 0 && undecodableRecords.has(record)) undecodable.push(filePath)
     if (m === null) continue
@@ -1790,6 +1932,9 @@ export async function startGitEnumeration(
   pathspecs: readonly string[],
 ): Promise<GitEnumeration> {
   attributeReads.clear()
+  // A dir is a path, never pathspec magic: `:top` listed `top`, `*g` matched
+  // `:top/src/log`, and a project's edit left its key (a stale hit).
+  const literal = pathspecs.map((p) => (p === '.' ? p : `:(literal)${p}`))
   // The spawns are independent — run them concurrently so the
   // bulk-populate costs max(ls-files, status) wall time, not the sum
   // (status alone is ~74 ms on a 1000-project tree; serial spawning
@@ -1911,7 +2056,7 @@ export async function startGitEnumeration(
   // tracked paths are dirty AND which files are untracked. Asking
   // `ls-files --others` for the untracked set walked the same tree a second
   // time (~50 ms of CPU, concurrent with status but contending with it).
-  const listing = spawnGit(['ls-files', '-s', '-v', '-z', '--', ...pathspecs])
+  const listing = spawnGit(['ls-files', '-s', '-v', '-z', '--', ...literal])
   // Read synchronously: `status` spawns once the read is in, and an async
   // read's answer waited for the main thread to yield, behind the workspace
   // config and discovery (~5 ms of a 1,200-task warm run's wait for git).
@@ -1944,9 +2089,10 @@ export async function startGitEnumeration(
   // any other, and the filter gate below must see it (A-19).
   // `--no-renames`: a deletion paired as an unmerged path's rename source
   // prints only as `UU <path>`, and the deleted file stayed trusted (A-59).
-  const spawnStatus = (index: string | undefined) =>
+  const spawnStatus = (index: string | undefined, args: readonly string[] = []) =>
     spawnGit(
       [
+        ...args,
         'status',
         '--porcelain',
         '-z',
@@ -1954,7 +2100,7 @@ export async function startGitEnumeration(
         '--ignored=matching',
         '--no-renames',
         '--',
-        ...pathspecs,
+        ...literal,
       ],
       undefined,
       index === undefined ? undefined : { GIT_INDEX_FILE: index },
@@ -1984,7 +2130,23 @@ export async function startGitEnumeration(
     attributesInIndex({ tracked: parsedLs.files, workspaceRoot, gitDir, gitPrefix, pathspecs })
       ? spawnGit(CHECK_ATTR, [...parsedLs.oids.keys()].join('\0'))
       : undefined
-  const [, status, vars] = await running
+  const [, firstStatus, gitVars] = await running
+  // `core.ignorecase` is known only once `var` answers, so a status run
+  // under a setting the disk does not hold is run again without it: a
+  // cost only that misconfigured repository pays.
+  const caseBlind =
+    facts !== null &&
+    gitVars !== null &&
+    gitVars.exitCode === 0 &&
+    gitVars.stdout.includes('core.ignorecase') &&
+    gitBool(gitVarList(gitVars.stdout).get('core.ignorecase')) === true &&
+    ignoreCaseLies(workspaceRoot, path.resolve(workspaceRoot, gitDir, 'HEAD'))
+  const status = caseBlind ? await spawnStatus(statusCopy, gitCaseArgs(workspaceRoot)) : firstStatus
+  // The listing as git reads it with the override, which `trackedKey` reads too.
+  const vars =
+    caseBlind && gitVars !== null
+      ? { ...gitVars, stdout: `${gitVars.stdout}core.ignorecase=false\n` }
+      : gitVars
   const indexMoved = indexStamp() !== stampBefore
   // The key stands for the index `ls-files` listed only when that index
   // was written before the enumeration began (git writes it by rename, so
@@ -2019,6 +2181,7 @@ export async function startGitEnumeration(
   }
   if (parsedLs === undefined)
     throw gitFailure(workspaceRoot, 'ls-files', ls.exitCode, ls.stderr.trim())
+  if (status !== null && status.exitCode === 0) refuseUnopenedDirs(workspaceRoot, status.stderr)
   const { files: tracked, oids, flagged, gitlinks, undecodable } = parsedLs
   // Normalize `status`'s repo-root-relative paths to workspace-relative (strip
   // the `--show-prefix`) so the dirty set is keyed identically to the trusted
@@ -2119,7 +2282,7 @@ export async function startGitEnumeration(
           return null
         }
         const run = await spawnGit(
-          ['ls-files', '-s', '-v', '-z', '--debug', '--', ...pathspecs],
+          ['ls-files', '-s', '-v', '-z', '--debug', '--', ...literal],
           undefined,
           statusCopy === undefined ? undefined : { GIT_INDEX_FILE: statusCopy },
         )
@@ -2300,10 +2463,13 @@ export async function applyGitEnumeration(
       relPrefix === spelled ? abs : (rel: string) => path.join(projectDir, rel.slice(prefix.length))
     const projOids = (): Map<string, string> => {
       const oids = new Map<string, string>()
+      // `resolveFiles` spells `matches[j]` the same, so both take one string.
+      const paths = base !== undefined && projAbs === abs ? cache.absPaths(matches) : undefined
       for (let i = start; i < end; i++) {
         const rel = sorted[i]!
         const oid = trusted.get(rel)
-        if (oid !== undefined) oids.set(projAbs(rel), oid)
+        if (oid === undefined) continue
+        oids.set(paths === undefined ? projAbs(rel) : (paths[i - start] ??= abs(rel)), oid)
       }
       return oids
     }