@vzn/vx 0.0.594 → 0.0.595

package/src/exec/runner.ts

@@ -12,6 +12,7 @@ import {
   isOutOfFds,
   killGraceMs,
   OUT_OF_FDS_HINT,
+  type SecretMask,
 } from '../util/index.js'
 import {
   closeSignalChannel,
@@ -112,30 +113,49 @@ export function shellQuote(arg: string): string {
 }
 
 /**
- * Where a shell comment still open at the end of `command` starts, or -1.
- * A `#` opens one only unquoted and at the start of a word (`a#b`, `$#` and
- * `${#x}` are words), and a newline closes it.
+ * One pass over `command` as sh reads it. `comment`: where a comment still
+ * open at the end starts, or -1 — a `#` opens one only unquoted and at the
+ * start of a word (`a#b`, `$#` and `${#x}` are words), and a newline closes
+ * it. `body`: per line, is it a heredoc's body or terminator (`<<X` /
+ * `<<-'X'` / `<<\X` … `X`). One scan, because each needs the other: a
+ * `<<X` in a comment or quotes opens no heredoc, and a quote in a body
+ * opens nothing (X-110).
  */
-function trailingCommentStart(command: string): number {
+function shellShape(command: string): { comment: number; body: boolean[] } {
+  const lines = command.split('\n')
+  const body = lines.map(() => false)
+  const pending: Array<{ delim: string; tabs: boolean }> = []
   let quote = ''
   let comment = -1
   let atWordStart = true
+  let line = 0
   for (let i = 0; i < command.length; i++) {
     const c = command[i]!
-    if (comment >= 0) {
-      if (c === '\n') {
-        comment = -1
-        atWordStart = true
+    if (c === '\n') {
+      line++
+      comment = -1
+      if (quote !== '') continue
+      atWordStart = true
+      // A heredoc's body starts on the line after its `<<`.
+      while (pending.length > 0 && line < lines.length) {
+        const text = lines[line]!
+        body[line] = true
+        const open = pending[0]!
+        if ((open.tabs ? text.replace(/^\t+/, '') : text) === open.delim) pending.shift()
+        i += text.length + 1
+        line++
       }
       continue
     }
+    if (comment >= 0) continue
     if (quote === "'") {
       if (c === "'") quote = ''
       continue
     }
     if (c === '\\') {
+      if (command[i + 1] === '\n') line++
+      else atWordStart = false
       i++
-      atWordStart = false
       continue
     }
     if (quote === '"') {
@@ -151,25 +171,18 @@ function trailingCommentStart(command: string): number {
       comment = i
       continue
     }
+    if (c === '<' && command[i - 1] !== '<') {
+      const m = /^<<(-?)[ \t]*\\?(['"]?)([A-Za-z_]\w*)\2/.exec(command.slice(i, i + 256))
+      if (m !== null) {
+        pending.push({ delim: m[3]!, tabs: m[1] === '-' })
+        i += m[0].length - 1
+        atWordStart = false
+        continue
+      }
+    }
     atWordStart = /[\s;&|()<>]/.test(c)
   }
-  return comment
-}
-
-/** Per line: is it a heredoc's body or terminator (`<<X` / `<<-'X'` … `X`)? */
-function heredocLines(lines: readonly string[]): boolean[] {
-  const pending: Array<{ delim: string; tabs: boolean }> = []
-  return lines.map((line) => {
-    const open = pending[0]
-    if (open !== undefined) {
-      if ((open.tabs ? line.replace(/^\t+/, '') : line) === open.delim) pending.shift()
-      return true
-    }
-    for (const m of line.matchAll(/(?<!<)<<(?!<)(-?)\s*(['"]?)([A-Za-z_]\w*)\2/g)) {
-      pending.push({ delim: m[3]!, tabs: m[1] === '-' })
-    }
-    return false
-  })
+  return { comment, body }
 }
 
 /**
@@ -183,27 +196,34 @@ export function withForwardArgs(command: string, args: readonly string[] | undef
   // `X FWD` closed nothing and the args never reached the command (X-12).
   // They go on the last line that is a command, where `cat <<X FWD` is
   // still `cat FWD` reading the heredoc.
-  const lines = command.trimEnd().split('\n')
-  const body = heredocLines(lines)
-  if (body[lines.length - 1] === true) {
-    const last = body.lastIndexOf(false)
+  const trimmed = command.trimEnd()
+  const lines = trimmed.split('\n')
+  const shape = shellShape(trimmed)
+  if (shape.body[lines.length - 1] === true) {
+    const last = shape.body.lastIndexOf(false)
     const tail = lines.slice(last + 1).join('\n')
     return `${withForwardArgs(lines.slice(0, last + 1).join('\n'), args)}\n${tail}`
   }
   const quoted = args.map(shellQuote).join(' ')
-  let comment = trailingCommentStart(command)
+  // Of the trimmed command: the newline closing a template literal's last
+  // line closed its comment too, and `echo args: # c\n` took the args into
+  // the comment (X-110).
+  let comment = shape.comment
   if (comment < 0) {
     // A command that ends in a newline (a template literal's closing line)
     // ran the args as a command of their own: `--watch: not found`. Kept
     // when an odd run of backslashes ends it: that escapes what follows.
-    const body = command.trimEnd()
-    const escaped = (/\\+$/.exec(body)?.[0].length ?? 0) % 2 === 1
-    return `${escaped ? command : body} ${quoted}`
+    const escaped = (/\\+$/.exec(trimmed)?.[0].length ?? 0) % 2 === 1
+    return `${escaped ? command : trimmed} ${quoted}`
   }
   // A comment-only last line after a commented line: the args go before
   // the earliest comment, or they land inside it (`echo one # c\n# two`).
-  for (let c = comment; c >= 0; c = trailingCommentStart(command.slice(0, c).trimEnd())) comment = c
-  return `${command.slice(0, comment).trimEnd()} ${quoted} ${command.slice(comment)}`
+  for (let c = comment; c >= 0; c = shellShape(trimmed.slice(0, c).trimEnd()).comment) comment = c
+  // What precedes the comment may end in a heredoc: the args go where they
+  // would with no comment, never on its terminator.
+  const head = trimmed.slice(0, comment).trimEnd()
+  const gap = trimmed.slice(head.length, comment) || ' '
+  return `${withForwardArgs(head, args)}${gap}${trimmed.slice(comment)}`
 }
 
 // Any shell control/expansion character means the wrapping `sh` has real
@@ -348,6 +368,18 @@ const SIGNAL_ALIASES = new Set(['SIGIOT', 'SIGPOLL', 'SIGCLD'])
  */
 const TIMEOUT_SIGKILL_GRACE_MS = 2000
 
+/**
+ * Run `fn` one loop turn later, once the child exits already pending are
+ * read. A deadline due in the same turn as a child's exit fires BEFORE Bun
+ * reaps it: a task that exited 0 inside its timeout, seen late by a busy vx,
+ * was SIGTERMed as a zombie and failed as timed out, and a server that died
+ * before ready read as a readiness timeout (2026-10-08). A turn later the
+ * exit has settled the caller, which clears the returned timer.
+ */
+function afterPendingExits(fn: () => void): ReturnType<typeof setTimeout> {
+  return setTimeout(fn, 0)
+}
+
 /**
  * Arm a SIGTERM timeout on a spawned child. Returns a handle whose
  * `timedOut()` reports whether the timer fired — so the caller can
@@ -368,7 +400,10 @@ export function armTimeout(
   let firedAt: number | undefined
   let killTimer: ReturnType<typeof setTimeout> | undefined
   const graceMs = killGraceMs(TIMEOUT_SIGKILL_GRACE_MS)
-  const timer = setTimeout(() => {
+  let timer = setTimeout(() => {
+    timer = afterPendingExits(fire)
+  }, timeoutMs)
+  function fire(): void {
     firedAt = Date.now()
     killTree(proc, 'SIGTERM')
     // Escalate to SIGKILL after a grace: a child that TRAPS+IGNORES SIGTERM
@@ -379,7 +414,7 @@ export function armTimeout(
     // the CLI alive.
     killTimer = setTimeout(() => killTree(proc, 'SIGKILL'), graceMs)
     killTimer.unref?.()
-  }, timeoutMs)
+  }
   return {
     timedOut: () => firedAt !== undefined,
     settle: async () => {
@@ -680,7 +715,7 @@ export function runPersistent(opts: PersistentOptions): PersistentSpawn {
   // a healthy server is never killed by a stale timer.
   let readyTimer: ReturnType<typeof setTimeout> | undefined
   if (readyRe && opts.timeoutMs !== undefined) {
-    readyTimer = setTimeout(() => {
+    const giveUp = (): void => {
       if (readyAt === undefined) {
         gaveUpAt = Date.now()
         rejectReady(
@@ -705,6 +740,9 @@ export function runPersistent(opts: PersistentOptions): PersistentSpawn {
         }, killGraceMs(TIMEOUT_SIGKILL_GRACE_MS))
         killTimer.unref?.()
       }
+    }
+    readyTimer = setTimeout(() => {
+      readyTimer = afterPendingExits(giveUp)
     }, opts.timeoutMs)
   }
 
@@ -883,6 +921,23 @@ export function droppedOutputLine(dropped: number): string {
   )
 }
 
+/**
+ * A captured `text` with `secrets` masked. A value the dropped middle cut
+ * left a piece at the head's end and one at the tail's start, which the
+ * whole-value mask missed, and the cache entry stored and replayed both.
+ */
+export function maskCaptured(text: string, secrets: SecretMask): string {
+  const at = text.indexOf('\n[vx] ', CAPTURE_HEAD_CHARS - 1)
+  const end = at === -1 ? -1 : text.indexOf('\n', at + 1) + 1
+  if (at === -1 || at > CAPTURE_HEAD_CHARS || !DROPPED_LINE.test(text.slice(at, end))) {
+    return secrets.mask(text)
+  }
+  const [head, tail] = secrets.maskCut(text.slice(0, at), text.slice(end))
+  return head + text.slice(at, end) + tail
+}
+
+const DROPPED_LINE = /^\n\[vx\] [\d.]+ MiB of output not kept — /
+
 const isHighSurrogate = (code: number): boolean => code >= 0xd800 && code <= 0xdbff
 
 /**
@@ -897,7 +952,10 @@ class BoundedCapture {
   private dropped = 0
 
   push(chunk: string): void {
-    if (this.head.length < CAPTURE_HEAD_CHARS) {
+    // Once the tail has begun the head is closed, even a unit short of its
+    // bound (the surrogate case below): a later short chunk fit there and
+    // was retained ahead of the chunk before it.
+    if (this.tailLen === 0 && this.head.length < CAPTURE_HEAD_CHARS) {
       let room = CAPTURE_HEAD_CHARS - this.head.length
       if (chunk.length <= room) {
         this.head += chunk

package/src/exec/sandbox-paths.ts

@@ -78,14 +78,16 @@ export function localBindingOn(c: { localBinding?: boolean | readonly number[] }
 }
 
 /**
- * Whether a sandboxed task may read `file`: it lies under a read grant,
- * a write grant or a baseline read, by its canonical path. A path no
- * grant holds is not there inside the sandbox, which the shell reports
+ * Whether a sandboxed task may read `file`: it lies under no denial (the
+ * rest of the host is mounted read-only), or under a read grant, a write
+ * grant or a baseline read, by its canonical path. A path no grant holds
+ * under a denial is not there inside the sandbox, which the shell reports
  * as "not found" with no denial a trace can see (an `execve`).
  */
 export function sandboxReads(
   sandbox: {
     readonly baseAllowRead: readonly string[]
+    readonly baseDenyRead: readonly string[]
     readonly config: {
       readonly allowRead: readonly string[]
       readonly allowWrite: readonly string[]
@@ -94,7 +96,11 @@ export function sandboxReads(
   file: string,
 ): boolean {
   const real = toRealPath(file)
-  return [...sandbox.baseAllowRead, ...sandbox.config.allowRead, ...sandbox.config.allowWrite].some(
-    (g) => atOrUnder(real, toRealPath(g)),
+  const under = (g: string): boolean => atOrUnder(real, toRealPath(g))
+  return (
+    !sandbox.baseDenyRead.some(under) ||
+    [...sandbox.baseAllowRead, ...sandbox.config.allowRead, ...sandbox.config.allowWrite].some(
+      under,
+    )
   )
 }

package/src/exec/sandbox-runtime.ts

@@ -279,9 +279,16 @@ export function dependencyReason(errors: readonly string[]): string {
  * listen" on macOS and "Failed to create bridge sockets after 5 attempts"
  * on Linux (its retry loop swallows the code), neither naming the
  * directory (2026-09-16). Checked up front, with room for the sequence.
+ * On Linux the longer name is the network bridge's,
+ * `claude-http-<16 hex>.sock`, and it is the one that fails there.
  */
 export function socketPathRefusal(tmpdir = os.tmpdir()): string | undefined {
-  const sample = path.join(tmpdir, `srt-mux-${process.pid}-zzz.sock`)
+  const sample = path.join(
+    tmpdir,
+    process.platform === 'linux'
+      ? `claude-http-${'0'.repeat(16)}.sock`
+      : `srt-mux-${process.pid}-zzz.sock`,
+  )
   const limit = process.platform === 'darwin' ? 103 : 107
   const length = Buffer.byteLength(sample)
   if (length <= limit) return undefined
@@ -1246,7 +1253,13 @@ async function wrapIn(
       ...macProfileRules(args.config),
       ...darwinWallRules(args.config, baselines.allowRead),
     ]
-    if (rules.length > 0) wrapped = injectProfileRules(wrapped, rules)
+    try {
+      if (rules.length > 0) wrapped = injectProfileRules(wrapped, rules)
+    } catch (err) {
+      releaseBridges(tag)
+      afterCommand(SandboxManager)
+      throw err
+    }
   }
   // Linux: the shell execs bwrap, so bwrap is the spawn itself and its
   // `--die-with-parent` is keyed to vx. Behind a shell that waited on it,
@@ -1383,11 +1396,14 @@ function ownGroupCommand(
     .join(' ')
   const body = shellQuote(`exec ${TRACE_FD}>&-; ${userCommand}`)
   const run = `{ trap - INT QUIT; exec ${setsid ?? ''}${tracer} ${shellQuote(sh)} -c ${body} 3<&-; } & c=$!;`
+  // Bash reports a job a signal killed on its stderr, the task's: a task
+  // whose shell died of SIGKILL printed this whole wrapper (X-111).
+  const wait = `wait "$c" 2>/dev/null`
   if (setsid === undefined) {
-    return { command: `${tag0} ${run} wait "$c"`, forwards: false, traced: true }
+    return { command: `${tag0} ${run} ${wait}`, forwards: false, traced: true }
   }
   const watch = `{ IFS= read -r s && kill -s "$s" -- "-$c"; } 2>/dev/null <&3 3<&- &`
-  return { command: `${tag0} ${run} ${watch} wait "$c"`, forwards: true, traced: true }
+  return { command: `${tag0} ${run} ${watch} ${wait}`, forwards: true, traced: true }
 }
 
 /** What strace stops on: the reads, and what moves or makes a process's cwd. */

package/src/graph/index.ts

@@ -11,6 +11,7 @@ export {
 export {
   type ContinueMode,
   deadServerBehind,
+  idleServers,
   type InputChanges,
   RestoreDemoted,
   runGraph,

package/src/graph/scheduler.ts

@@ -969,7 +969,7 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
 }
 
 /** Persistent tasks nobody asked for whose every dependant is a restore-tier hit. */
-function idleServers(
+export function idleServers(
   nodes: ReadonlyMap<string, TaskNode>,
   dependents: ReadonlyMap<string, string[]>,
   restoreTier: ReadonlySet<string> | undefined,

package/src/index.ts

@@ -179,6 +179,12 @@ export type {
 // A remote executor gives a task back to the local floor by rejecting with
 // this (B-100): core runs it here and says why once.
 export { executorFallback } from './exec/index.js'
+// How the local executor puts the args after `--` on a command, for an
+// executor that runs `ExecuteRequest.command` itself: `@vzn/vx-reapi` and
+// the `vx init --plugin executor` example each joined their own, and a
+// trailing comment or a template literal's closing newline lost the args
+// there while the local floor kept them (X-112).
+export { withForwardArgs } from './exec/index.js'
 export type {
   ExecuteRequest,
   ExecuteResult,

package/src/orchestrator/execute-task.ts

@@ -38,6 +38,7 @@ import {
   type TaskInputs,
   PersistentReadyError,
   sandboxReads,
+  maskCaptured,
 } from '../exec/index.js'
 import { isGroupTask, RestoreDemoted, type TaskNode, type TaskOutcome } from '../graph/index.js'
 import {
@@ -534,6 +535,20 @@ async function executePersistentTask(args: ExecuteArgs): Promise<TaskOutcome> {
     }
   }
 
+  // Ready only once the stop had landed: a trap that prints the marker on
+  // the way down, or a race with the signal. The stop is killing it (it
+  // is in `liveChildren`), and it served nobody, as a one-shot that exits
+  // 0 on the stop is aborted (item 962).
+  if (isAborted(args.stopSignal)) {
+    return {
+      node,
+      status: 'aborted',
+      exitCode: signalExitCode(forwardedSignal(args.stopSignal!.reason)),
+      durationMs: spawn.readyMs(),
+      wallclockStartNs,
+      wallclockEndNs: process.hrtime.bigint() - args.runStartHrTimeNs,
+    }
+  }
   args.persistentRegistry?.set(node.id, spawn.child)
   forgetUndeclaredWrites(args, undeclaredWriteReach(node, args.workspaceRoot))
   if (mayWriteFingerprint(node, args.workspaceRoot)) args.fingerprintWatch?.wrote()
@@ -914,7 +929,7 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
       // re-create would stay in a same-project consumer's input set, keeping
       // that consumer's key unchanged while the file is gone from disk.
       const endClean = span('miss: clean outputs')
-      const cleanedRels = await cleanOutputs({ ...cleanArgs, keepGlobRoots: true })
+      const cleanedRels = await cleanOutputs(cleanArgs)
       endClean()
       args.gitFilesCache?.noteClean(node.id, node.projectDir, cleanedRels)
       args.gitFilesCache?.markOutputsChanged(node.projectDir, cleanedRels)
@@ -988,7 +1003,11 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
       })
     endExec()
     if (secrets !== null)
-      res = { ...res, stdout: secrets.mask(res.stdout), stderr: secrets.mask(res.stderr) }
+      res = {
+        ...res,
+        stdout: maskCaptured(res.stdout, secrets),
+        stderr: maskCaptured(res.stderr, secrets),
+      }
     // An executor that stopped on the timeout's abort exits non-zero; say
     // why, so the frame, the retry line and `timedOut` read as a timeout.
     if (timeoutFired && res.exitCode !== 0 && res.timedOut !== true) {
@@ -1051,8 +1070,9 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
     // 258) — and an exit above 128 is a signal's number and nothing
     // about what sent it (259). One frame line names the rule. A spawn that
     // threw ran no shell: its 127 is vx's, and the line would send the
-    // reader after a command that exists (A-41).
-    if (!res.timedOut && res.spawnFailed !== true) {
+    // reader after a command that exists (A-41). A run's stop killed it
+    // itself: the SIGKILL past the grace read as the OOM killer's.
+    if (!res.timedOut && res.spawnFailed !== true && args.stopSignal?.aborted !== true) {
       const verdict = shellVerdict({
         code,
         command: step.command,
@@ -1203,7 +1223,6 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
             },
           }
         : {}),
-      signal: requestSignal(),
       ...(effectiveTimeout !== undefined ? { timeoutMs: effectiveTimeout } : {}),
       ...(inputs !== undefined ? { inputs } : {}),
       ...(cfgCacheable ? { cacheKey: hash } : {}),
@@ -1215,7 +1234,10 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
       outputs: { files: outputs, workspaceFiles: wsOutputs },
       ...(args.terminal === true ? { terminal: true as const } : {}),
     }
-    if (!userSandbox) return base
+    // The signal last: it arms `exec.timeout`, and the sandbox's arming
+    // below is vx's work, not the task's. Armed first, a 60 ms timeout
+    // expired before the spawn and failed `echo` as timed out, unrun.
+    if (!userSandbox) return { ...base, signal: requestSignal() }
     await args.armSandbox?.()
     const sb = await sandboxRequestFor(
       node,
@@ -1227,7 +1249,7 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
     )
     placeholders = sb.placeholders
     withheld = sb.withheld
-    return { ...base, sandbox: sb.sandbox }
+    return { ...base, sandbox: sb.sandbox, signal: requestSignal() }
   }
 
   const wallclockEndNs = process.hrtime.bigint() - args.runStartHrTimeNs

package/src/orchestrator/hit-restore.ts

@@ -8,7 +8,6 @@
 // which bytes a green run replays. Moved out of execute-task.ts
 // 2026-09-10 as pure code motion, the mirror of miss-save.ts.
 
-import path from 'node:path'
 import type { CacheConfig } from '../config.js'
 import {
   type CacheEntry,
@@ -224,11 +223,15 @@ export async function restoreHit(restore: RestoreHitArgs): Promise<TaskOutcome>
     let cleanedWsRels: string[] = []
     if (additive) {
       cleanedRels = hit.outputFiles.filter((p) => !p.startsWith(WORKSPACE_OUTPUT_PREFIX))
-      await cleanOutputPaths({ projectDir: node.projectDir, rels: cleanedRels })
+      await cleanOutputPaths({ projectDir: node.projectDir, rels: cleanedRels, outputs })
       cleanedWsRels = hit.outputFiles
         .filter((p) => p.startsWith(WORKSPACE_OUTPUT_PREFIX))
         .map((p) => p.slice(WORKSPACE_OUTPUT_PREFIX.length))
-      await cleanOutputPaths({ projectDir: args.workspaceRoot, rels: cleanedWsRels })
+      await cleanOutputPaths({
+        projectDir: args.workspaceRoot,
+        rels: cleanedWsRels,
+        outputs: wsOutputs,
+      })
     } else {
       if (outputs.length > 0) cleanedRels = await cleanOutputs(cleanArgs)
       if (wsOutputs.length > 0) cleanedWsRels = await cleanWorkspaceOutputs(wsCleanArgs)

package/src/orchestrator/local-shortcircuit.ts

@@ -194,7 +194,10 @@ export async function startLocalShortCircuit(args: ShortCircuitArgs): Promise<Sh
  * task's key, which is preliminary, so it cannot restore early either.
  * Cost: one pass over the nodes, no filesystem.
  */
-function restoreTierExclusions(nodes: Map<string, TaskNode>, workspaceRoot: string): Set<string> {
+export function restoreTierExclusions(
+  nodes: Map<string, TaskNode>,
+  workspaceRoot: string,
+): Set<string> {
   const prefixes: string[] = []
   let everything = false
   for (const node of nodes.values()) {

package/src/orchestrator/lockfile-claim.ts

@@ -9,8 +9,8 @@
 //
 // The digests are memoised on disk under the cache dir by the file's
 // xxh3, so a warm run pays one read + hash + a small JSON read, never a
-// parse; within one process (a run, a watch cycle) the file's size and
-// mtime gate even the read; and per run the read happens once (a WeakMap
+// parse; within one process (a run, a watch cycle) the file's size,
+// mtime, ctime and inode gate even the read; and per run the read happens once (a WeakMap
 // on the context core hands every `key` call of a run).
 
 import path from 'node:path'
@@ -87,18 +87,33 @@ async function hashExtra(workspaceRoot: string, rel: string): Promise<string> {
   }
 }
 
-async function statsOf(
+/**
+ * A file's identity for the in-process gate, as `Cache.hashFile`'s memo
+ * keys one: size and mtime alone kept the digests of a lockfile or patch
+ * replaced by another of the same size with its mtime kept (`cp -p`,
+ * `tar -x`), and no task sets a ctime.
+ */
+function identityOf(st: { size: number; mtimeMs: number; ctimeMs: number; ino: number }): string {
+  return `${st.size}:${st.mtimeMs}:${st.ctimeMs}:${st.ino}`
+}
+
+async function statsOf(workspaceRoot: string, rels: readonly string[]): Promise<string[]> {
+  return Promise.all(
+    rels.map((rel) => stat(path.join(workspaceRoot, rel)).then(identityOf, () => 'gone')),
+  )
+}
+
+/** Each file's identity, taken BEFORE its hash, so a write between the two re-reads it. */
+async function hashExtras(
   workspaceRoot: string,
   rels: readonly string[],
-): Promise<Array<{ size: number; mtimeMs: number }>> {
-  return Promise.all(
-    rels.map((rel) =>
-      stat(path.join(workspaceRoot, rel)).then(
-        (st) => ({ size: st.size, mtimeMs: st.mtimeMs }),
-        () => ({ size: -1, mtimeMs: -1 }),
-      ),
-    ),
+): Promise<{ hashes: Record<string, string>; stats: Record<string, string> }> {
+  const ids = await statsOf(workspaceRoot, rels)
+  const stats = Object.fromEntries(rels.map((rel, i) => [rel, ids[i]!] as const))
+  const hashes = Object.fromEntries(
+    await Promise.all(rels.map(async (rel) => [rel, await hashExtra(workspaceRoot, rel)] as const)),
   )
+  return { hashes, stats }
 }
 
 export function lockfileClaim(options: LockfileClaimOptions): LockfileClaimHooks {
@@ -108,15 +123,14 @@ export function lockfileClaim(options: LockfileClaimOptions): LockfileClaimHooks
   if (scope !== 'project' && scope !== 'workspace') {
     throw new Error(`scope must be 'project' or 'workspace', not ${JSON.stringify(scope)}`)
   }
-  // Per workspace root: what the last read saw. `size` + `mtimeMs` gate a
-  // re-read; the content hash decides whether the digests are current.
+  // Per workspace root: what the last read saw. Each file's identity gates
+  // a re-read; the content hash decides whether the digests are current.
   const seen = new Map<
     string,
     {
-      size: number
-      mtimeMs: number
+      identity: string
       extras: readonly string[]
-      extraStats: ReadonlyArray<{ size: number; mtimeMs: number }>
+      extraStats: Readonly<Record<string, string>>
       digests: Digests
     }
   >()
@@ -125,23 +139,18 @@ export function lockfileClaim(options: LockfileClaimOptions): LockfileClaimHooks
 
   const load = async (workspaceRoot: string, cacheDir: string): Promise<Digests> => {
     const full = path.join(workspaceRoot, file)
-    let st: { size: number; mtimeMs: number }
+    let identity: string
     try {
-      st = await stat(full)
+      identity = identityOf(await stat(full))
     } catch {
       const digests: Digests = { lock: '', importers: new Map() }
-      seen.set(workspaceRoot, { size: -1, mtimeMs: -1, extras: [], extraStats: [], digests })
+      seen.set(workspaceRoot, { identity: 'gone', extras: [], extraStats: {}, digests })
       return digests
     }
     const last = seen.get(workspaceRoot)
-    if (last !== undefined && last.size === st.size && last.mtimeMs === st.mtimeMs) {
+    if (last !== undefined && last.identity === identity) {
       const now = await statsOf(workspaceRoot, last.extras)
-      if (
-        now.every(
-          (s, i) =>
-            s.size === last.extraStats[i]!.size && s.mtimeMs === last.extraStats[i]!.mtimeMs,
-        )
-      ) {
+      if (now.every((s, i) => s === last.extraStats[last.extras[i]!])) {
         return last.digests
       }
     }
@@ -152,28 +161,22 @@ export function lockfileClaim(options: LockfileClaimOptions): LockfileClaimHooks
     // re-hashes the files the memo names and never parses to learn them.
     const memo = await readMemo(memoFile, version, lockHash)
     let extras: Record<string, string> = {}
+    let extraStats: Record<string, string> = {}
     let importers: ReadonlyMap<string, string> | undefined
     if (memo !== undefined) {
-      const now = Object.fromEntries(
-        await Promise.all(
-          Object.keys(memo.extras).map(
-            async (rel) => [rel, await hashExtra(workspaceRoot, rel)] as const,
-          ),
-        ),
-      )
-      if (Object.entries(memo.extras).every(([rel, h]) => now[rel] === h)) {
+      const now = await hashExtras(workspaceRoot, Object.keys(memo.extras))
+      if (Object.entries(memo.extras).every(([rel, h]) => now.hashes[rel] === h)) {
         extras = memo.extras
+        extraStats = now.stats
         importers = memo.importers
       }
     }
     if (importers === undefined) {
       const text = decode(bytes)
       const rels = [...new Set(options.extraFiles?.(text) ?? [])].sort()
-      extras = Object.fromEntries(
-        await Promise.all(
-          rels.map(async (rel) => [rel, await hashExtra(workspaceRoot, rel)] as const),
-        ),
-      )
+      const now = await hashExtras(workspaceRoot, rels)
+      extras = now.hashes
+      extraStats = now.stats
       importers =
         scope === 'workspace'
           ? new Map<string, string>()
@@ -191,13 +194,7 @@ export function lockfileClaim(options: LockfileClaimOptions): LockfileClaimHooks
         ? lockHash
         : xxh3hex([lockHash, ...rels.map((r) => `${r}\0${extras[r]}`)].join('\0'))
     const digests: Digests = { lock, importers }
-    seen.set(workspaceRoot, {
-      size: st.size,
-      mtimeMs: st.mtimeMs,
-      extras: rels,
-      extraStats: await statsOf(workspaceRoot, rels),
-      digests,
-    })
+    seen.set(workspaceRoot, { identity, extras: rels, extraStats, digests })
     return digests
   }
   const loadOnce = (ctx: KeyHookContext): Promise<Digests> => {