@vzn/vx 0.0.55 → 0.0.56

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.55",
+  "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.55",
-    "@vzn/vx-linux-arm64": "0.0.55",
-    "@vzn/vx-darwin-x64": "0.0.55",
-    "@vzn/vx-darwin-arm64": "0.0.55"
+    "@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/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) {