@vzn/vx 0.0.555 → 0.0.557

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.555",
+  "version": "0.0.557",
   "description": "The fastest task runner and build cache for JavaScript monorepos.",
   "type": "module",
   "exports": {
@@ -21,10 +21,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.555",
-    "@vzn/vx-linux-arm64": "0.0.555",
-    "@vzn/vx-darwin-x64": "0.0.555",
-    "@vzn/vx-darwin-arm64": "0.0.555"
+    "@vzn/vx-linux-x64": "0.0.557",
+    "@vzn/vx-linux-arm64": "0.0.557",
+    "@vzn/vx-darwin-x64": "0.0.557",
+    "@vzn/vx-darwin-arm64": "0.0.557"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/cache/inputs.ts

@@ -692,10 +692,17 @@ export async function cleanOutputPaths(args: {
   await pruneEmptiedDirs(args.projectDir, await removeAll(files, args.projectDir))
 }
 
-/** A file's identity for the additive diff: what the hit path's fingerprint trusts too. */
+/**
+ * A file's identity for the additive diff: what the hit path's
+ * `isOutputsCurrent` trusts too. Size and mtime alone missed a rewrite to
+ * bytes of the same length with the mtime stamped back; the inode and
+ * ctime are what no task sets (item 886).
+ */
 export interface OutputStamp {
   size: number
   mtimeMs: number
+  ino: number
+  ctimeMs: number
 }
 
 /**
@@ -724,7 +731,7 @@ function stampFiles(files: readonly string[]): Map<string, OutputStamp> {
   for (const f of files) {
     try {
       const st = lstatSync(f)
-      out.set(f, { size: st.size, mtimeMs: st.mtimeMs })
+      out.set(f, { size: st.size, mtimeMs: st.mtimeMs, ino: st.ino, ctimeMs: st.ctimeMs })
     } catch {
       // Gone between the walk and the stat: not a file the task found.
     }
@@ -734,16 +741,20 @@ function stampFiles(files: readonly string[]): Map<string, OutputStamp> {
 
 /**
  * The files an additive task's run ADDED or CHANGED under its declared
- * outputs: every selected file that was not in `before`, or whose size or
- * mtime moved. Size + mtime is the proof the hit path already trusts for
- * a current tree, so no new trust is introduced. A file the run rewrote
- * with identical bytes counts as its own (the mtime moved), which is the
+ * outputs: every selected file that was not in `before`, or whose stamp
+ * (`OutputStamp`) moved — the proof the hit path trusts for a current
+ * tree, so no new trust is introduced. A file the run rewrote, even with
+ * identical bytes, counts as its own (its ctime moved), which is the
  * rewrite-in-place cost the design note records.
+ *
+ * Undefined when the run REMOVED a file it found: an artifact holds what a
+ * run wrote, never what it took away, and the upstream's restore puts the
+ * file back, so no entry reproduces that run and none is saved.
  */
 export async function ownOutputsSince(
   args: { projectDir: string; outputs: string[]; nestedProjectDirs: string[] },
   before: ReadonlyMap<string, OutputStamp>,
-): Promise<string[]> {
+): Promise<string[] | undefined> {
   return changedSince(await resolveOutputs(args), before)
 }
 
@@ -751,15 +762,16 @@ export async function ownOutputsSince(
 export async function ownWorkspaceOutputsSince(
   args: { workspaceRoot: string; outputs: string[] },
   before: ReadonlyMap<string, OutputStamp>,
-): Promise<string[]> {
+): Promise<string[] | undefined> {
   return changedSince(await resolveWorkspaceOutputs(args), before)
 }
 
 function changedSince(
   after: readonly string[],
   before: ReadonlyMap<string, OutputStamp>,
-): string[] {
+): string[] | undefined {
   const own: string[] = []
+  let kept = 0
   for (const f of after) {
     const was = before.get(f)
     if (was === undefined) {
@@ -768,12 +780,19 @@ function changedSince(
     }
     try {
       const st = lstatSync(f)
-      if (st.size !== was.size || st.mtimeMs !== was.mtimeMs) own.push(f)
+      kept++
+      if (
+        st.size !== was.size ||
+        st.mtimeMs !== was.mtimeMs ||
+        st.ino !== was.ino ||
+        st.ctimeMs !== was.ctimeMs
+      )
+        own.push(f)
     } catch {
-      // Vanished since the walk: not an output.
+      // Vanished since the walk: removed, as one the walk missed is.
     }
   }
-  return own
+  return kept < before.size ? undefined : own
 }
 
 /**

package/src/orchestrator/execute-task.ts

@@ -1213,6 +1213,7 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
 
   const wallclockEndNs = process.hrtime.bigint() - args.runStartHrTimeNs
 
+  let own: Awaited<ReturnType<typeof ownOutputs>>
   if (effectiveExitCode === 0 && willSave && deferralRequested) {
     // The outputs never landed here: no artifact, no rows. A partial local
     // record (a row with no artifact) is exactly the corrupt-entry shape
@@ -1234,18 +1235,14 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
         },
       })
     }
-  } else if (effectiveExitCode === 0 && willSave && (await keyStillTrue())) {
-    const ownOutputFiles =
-      additive && stampedBefore !== undefined
-        ? await ownOutputsSince(cleanArgs, stampedBefore)
-        : undefined
-    const ownWsOutputFiles =
-      additive && wsStampedBefore !== undefined
-        ? await ownWorkspaceOutputsSince(wsCleanArgs, wsStampedBefore)
-        : undefined
+  } else if (
+    effectiveExitCode === 0 &&
+    willSave &&
+    (await keyStillTrue()) &&
+    (own = await ownOutputs()) !== undefined
+  ) {
     const { landed } = await saveMiss({
-      ...(ownOutputFiles !== undefined ? { ownOutputFiles } : {}),
-      ...(ownWsOutputFiles !== undefined ? { ownWsOutputFiles } : {}),
+      ...own,
       node,
       hash,
       cache,
@@ -1302,6 +1299,28 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
     return true
   }
 
+  /**
+   * What an additive run saves as its own, or undefined when it removed a
+   * file it found: no entry replays a removal (`ownOutputsSince`), so the
+   * task saves nothing and runs again.
+   */
+  async function ownOutputs(): Promise<
+    { ownOutputFiles?: string[]; ownWsOutputFiles?: string[] } | undefined
+  > {
+    const mine: { ownOutputFiles?: string[]; ownWsOutputFiles?: string[] } = {}
+    if (stampedBefore !== undefined) {
+      const files = await ownOutputsSince(cleanArgs, stampedBefore)
+      if (files === undefined) return undefined
+      mine.ownOutputFiles = files
+    }
+    if (wsStampedBefore !== undefined) {
+      const files = await ownWorkspaceOutputsSince(wsCleanArgs, wsStampedBefore)
+      if (files === undefined) return undefined
+      mine.ownWsOutputFiles = files
+    }
+    return mine
+  }
+
   /**
    * The input that no longer holds what the key folded: `null` when the
    * key re-derived just before the command already differed (the file