@vzn/vx 0.0.54 → 0.0.56

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.54",
+  "version": "0.0.56",
   "description": "An open, extensible monorepo task runner.",
   "type": "module",
   "exports": {
@@ -17,10 +17,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.54",
-    "@vzn/vx-linux-arm64": "0.0.54",
-    "@vzn/vx-darwin-x64": "0.0.54",
-    "@vzn/vx-darwin-arm64": "0.0.54"
+    "@vzn/vx-linux-x64": "0.0.56",
+    "@vzn/vx-linux-arm64": "0.0.56",
+    "@vzn/vx-darwin-x64": "0.0.56",
+    "@vzn/vx-darwin-arm64": "0.0.56"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/cache/cache.ts

@@ -1655,13 +1655,17 @@ export class Cache implements CacheLayer {
    * orphan sweep alone when an hour has passed since the last one. A run
    * with nothing due pays the accessed-at flush it owed at close anyway, one
    * scan of the index and one read of the sweep's clock — never the
-   * sweep's readdir. Null when nothing was due or this handle does not write.
+   * sweep's readdir. Null when nothing was due or the directory is not this
+   * handle's to write. The local WRITE axis does not gate it: under
+   * `--cache=local:r,remote:rw` a save writes nothing here, but every remote
+   * hit is still ingested (`ingest`, ungated by design), and gated on that
+   * axis the retention never ran while the store grew hit by hit (A-7).
    */
   async evictIfDue(
     policy: { maxAgeMs?: number; maxBytes?: number },
     now: number = Date.now(),
   ): Promise<PruneResult | null> {
-    if (!this.write) return null
+    if (this.writeBlocked !== null || this.inspecting) return null
     // First: an entry this run restored still carries its old `accessed_at`
     // until the deferred bump lands, and would read as due for eviction.
     this.flushAccessed()

package/src/cache/git-inputs.ts

@@ -635,6 +635,28 @@ function restampModes(trusted: Map<string, string>, workspaceRoot: string): void
   }
 }
 
+/**
+ * `true` when the repository's config weakens the stat `git status` judges
+ * a file clean by: `core.trustctime` off, or `core.checkStat=minimal`
+ * (whole-second mtime and size only). Then a same-size rewrite that restores
+ * its mtime — `cp -p`, `tar -x`, a formatter that keeps times — reads clean
+ * and would keep its index OID, while the file hasher's own memo still keys
+ * on ctime and inode (A-6). Read from the `git var -l` the run already
+ * spawns; git's false spellings, the last value winning.
+ */
+export function gitStatWeakened(gitVars: string): boolean {
+  const vars = gitVarList(gitVars)
+  const trustctime = vars.get('core.trustctime')?.trim().toLowerCase()
+  const checkStat = vars.get('core.checkstat')?.trim().toLowerCase()
+  return (
+    trustctime === 'false' ||
+    trustctime === 'no' ||
+    trustctime === 'off' ||
+    trustctime === '0' ||
+    checkStat === 'minimal'
+  )
+}
+
 /** `true` when git may rewrite bytes for EVERY auto-detected text file. */
 export function autocrlfConverts(gitVars: string): boolean {
   const v = gitVarList(gitVars).get('core.autocrlf')?.trim().toLowerCase()
@@ -945,6 +967,9 @@ export async function startGitEnumeration(
   // Dropping the OID sends these back through the probe, where they correctly
   // fall out of the input set while unmaterialized.
   for (const rel of flagged) trusted.delete(rel)
+  // Under a weakened stat, `git status` vouches for nothing a same-size,
+  // time-keeping rewrite made: every file is hashed from disk instead.
+  if (vars !== null && vars.exitCode === 0 && gitStatWeakened(vars.stdout)) trusted.clear()
   // An index OID is only the file's content hash when git stores the worktree
   // bytes VERBATIM. Under a clean filter (`text`/`eol`/`ident`/`filter`/`working-tree-encoding`) the blob is a
   // DIFFERENT sequence of bytes — the LF-normalized form — while the task

package/src/cache/inputs.ts

@@ -42,6 +42,7 @@ export {
   gitPathspecs,
   parseCheckAttrOutput,
   autocrlfConverts,
+  gitStatWeakened,
   attributeFilesOutsideTree,
   type GitEnumeration,
 } from './git-inputs.js'

package/src/orchestrator/projects.ts

@@ -17,7 +17,8 @@ import {
   type ProjectMeta,
 } from '../workspace/index.js'
 import type { WorkspaceConfig } from '../config.js'
-import { Cache, noteSchemaReset } from '../cache/index.js'
+import { Cache } from '../cache/index.js'
+import { UserError } from '../util/index.js'
 import {
   buildPackageGraph,
   computeWorkspaceFingerprint,
@@ -245,8 +246,15 @@ export async function loadResolvedProjects(
   const metas = await listProjects(await loadWorkspace(workspaceRoot, reads))
   const { workspaceConfig, plugins } = await loadWorkspacePlugins(workspaceRoot, warn)
   const cacheDir = resolveCacheDir(workspaceRoot, workspaceConfig)
-  const cache = new Cache(cacheDir, { read: true, write: true }, workspaceRoot)
-  noteSchemaReset(cache, warn)
+  // Opened as `vx last` opens it: a reader makes no index where there is
+  // none and never resets an earlier schema's (C-5). One it cannot read
+  // serves nothing; the configs evaluate live.
+  let cache: Cache | undefined
+  try {
+    cache = Cache.inspect(cacheDir)
+  } catch (err) {
+    if (!(err instanceof UserError)) throw err
+  }
   try {
     const loaded = await loadProjects({
       workspaceRoot,
@@ -257,15 +265,18 @@ export async function loadResolvedProjects(
       seeds: opts.scope ?? 'all',
       closure: false,
       lock: null,
-      evalCache: {
-        store: cache,
-        workspaceRoot,
-        workspaceFingerprint: await computeWorkspaceFingerprint(workspaceRoot, reads),
-      },
+      evalCache:
+        cache === undefined
+          ? undefined
+          : {
+              store: cache,
+              workspaceRoot,
+              workspaceFingerprint: await computeWorkspaceFingerprint(workspaceRoot, reads),
+            },
       warn,
     })
     return loaded.projects
   } finally {
-    cache.close()
+    cache?.close()
   }
 }

package/src/orchestrator/run-lock.ts

@@ -3,11 +3,13 @@
 // Two vx processes on one workspace race on every task's OUTPUT TREE: both
 // clean and restore the same `dist/`, and a clean landing while the other
 // run's restore is staging takes its files out from under it (item 215).
-// The cache itself is safe (SQLite waits, artifacts land by rename); the
-// tree is not, and a run that finished "green" can have had its restored
-// outputs deleted by the other run's clean a moment later. So a run takes
-// this lock before it schedules and releases it with its cache handle —
-// before a persistent task's wait, so a dev server never holds it.
+// The cache itself is safe (SQLite waits, and an artifact lands by rename
+// inside its rows' transaction, A-3), across workspaces sharing one
+// `--cache-dir` too; the tree is not, and a run that finished "green" can
+// have had its restored outputs deleted by the other run's clean a moment
+// later. So a run takes this lock before it schedules and releases it with
+// its cache handle — before a persistent task's wait, so a dev server never
+// holds it.
 //
 // Keyed by the workspace, not the cache directory (`--cache-dir` must not
 // make two runs strangers), and kept under the temp directory so a

package/src/orchestrator/run.ts

@@ -1192,7 +1192,9 @@ async function applyCacheRetention(prepared: PreparedRun, log: Logger): Promise<
  * existence check — no artifact download, no ingest, no accessed_at bump.
  */
 export async function planRun(options: RunOptions): Promise<RunPlan> {
-  const log = options.log ?? defaultLogger()
+  // The plan is the product and goes to stdout (`--dry=json` is parsed):
+  // what a stage says on the way goes to stderr (C-6).
+  const log = options.log ?? defaultLogger(undefined, undefined, process.stderr)
   const prepared = await prepareRun(options, log)
   try {
     if (prepared.unresolvedTasks.length > 0) {