@vzn/vx 0.0.154 → 0.0.156

package/package.json

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

package/src/cli/plan-format.ts

@@ -28,11 +28,14 @@ export function formatPlanText(plan: RunPlan): string {
   let remote = 0
   let miss = 0
   let nocache = 0
+  let noop = 0
   for (const t of real) {
-    const sym = symbolFor(t.cacheStatus)
-    const desc = describe(t.cacheStatus)
+    // `@noop`: the run succeeds it without running, whatever its key says.
+    const skipped = t.executor === 'noop'
+    const sym = skipped ? '∅' : symbolFor(t.cacheStatus)
+    const desc = skipped ? 'noop — would not run' : describe(t.cacheStatus)
     const shortHash = t.hash ? t.hash.slice(0, 8) : ''
-    const executes = t.cacheStatus === 'miss' || t.cacheStatus === 'no-cache'
+    const executes = !skipped && (t.cacheStatus === 'miss' || t.cacheStatus === 'no-cache')
     const eta = executes && t.p50Ms !== undefined ? `  ~${formatDuration(t.p50Ms)}` : ''
     // Placement, by EXECUTOR NAME rather than a local/remote word: the
     // summary line below already spends "local" and "remote" on the cache
@@ -48,7 +51,8 @@ export function formatPlanText(plan: RunPlan): string {
     if (taskDesc) {
       lines.push(`     ${' '.repeat(idWidth)}  ${taskDesc}`)
     }
-    if (t.cacheStatus === 'hit-local') local++
+    if (skipped) noop++
+    else if (t.cacheStatus === 'hit-local') local++
     else if (t.cacheStatus === 'hit-remote') remote++
     else if (t.cacheStatus === 'miss') miss++
     else if (t.cacheStatus === 'no-cache') nocache++
@@ -62,6 +66,7 @@ export function formatPlanText(plan: RunPlan): string {
   if (hits > 0) summary.push(`${hits} cache hit${hits === 1 ? '' : 's'} (${hitParts.join(', ')})`)
   if (miss > 0) summary.push(`${miss} would run`)
   if (nocache > 0) summary.push(`${nocache} no-cache`)
+  if (noop > 0) summary.push(`${noop} noop`)
   lines.push('')
   lines.push(summary.join(', ') + '.')
 

package/src/cli/watch-filter.ts

@@ -52,7 +52,7 @@ export function isIgnoredWatchPath(rel: string): boolean {
 export function makeWatchIgnore(
   cacheDir: string,
   outputs: ReadonlyMap<string, readonly string[]> = new Map(),
-  inputs: ReadonlyMap<string, readonly string[]> = new Map(),
+  inputs: ReadonlyMap<string, ReadonlyArray<readonly string[]>> = new Map(),
 ): (base: string, filename: string) => boolean {
   const cacheAbs = path.resolve(cacheDir)
   // A task's own outputs are not edits: without this every cycle that
@@ -82,23 +82,37 @@ export function makeWatchIgnore(
   // A path some task takes as an INPUT is never an output to ignore, even
   // when another task declares it one: an in-place formatter declaring
   // `src/**` hid every `src` edit from a `build` watched beside it, and no
-  // cycle ran (item 946). Negations are not consulted — they only narrow,
-  // and a path they would exclude costs one cache-hit cycle.
-  const read = [...inputs].map(
-    ([dir, globs]) =>
-      [
-        path.resolve(dir),
-        asTrees(globs.filter((g) => !g.startsWith('!'))).map((g) => taskGlob(g)),
-      ] as const,
+  // cycle ran (item 946). Each task's inputs are judged on their own, less
+  // their `!` entries (its own outputs among them): a turbo() task reading
+  // `**/*` took its own `dist/` write for an edit, and every save ran one
+  // more "up-to-date" cycle (2026-09-28).
+  const read = [...inputs].flatMap(([dir, tasks]) =>
+    tasks.map(
+      (globs) =>
+        [
+          path.resolve(dir),
+          asTrees(globs.filter((g) => !g.startsWith('!'))).map((g) => taskGlob(g)),
+          asTrees(globs.filter((g) => g.startsWith('!')).map((g) => g.slice(1))).map((g) =>
+            taskGlob(g),
+          ),
+          // The directory an own output lives in is the task's too (see below).
+          globs
+            .filter((g) => g.startsWith('!'))
+            .map((g) => outputContainer(g.slice(1)))
+            .filter((c) => c !== ''),
+        ] as const,
+    ),
   )
   const isInput = (abs: string): boolean =>
-    read.some(([dir, globs]) => {
+    read.some(([dir, globs, not, containers]) => {
       if (!abs.startsWith(dir + path.sep)) return false
       const rel = abs
         .slice(dir.length + 1)
         .split(path.sep)
         .join('/')
-      return globs.some((g) => g.match(rel))
+      if (!globs.some((g) => g.match(rel))) return false
+      if (not.some((g) => g.match(rel))) return false
+      return !containers.some((c) => c === rel || c.startsWith(`${rel}/`))
     })
   return (base, filename) => {
     if (isIgnoredWatchPath(filename)) return true

package/src/cli/watch-set.ts

@@ -56,8 +56,12 @@ export interface ConfigSweep {
   workspaceWide: boolean
   workspaceInputs: string[]
   outputs: Map<string, string[]>
-  /** Declared input globs per directory they are relative to, the counterweight to `outputs`. */
-  inputs: Map<string, string[]>
+  /**
+   * Each task's input globs per directory they are relative to, the
+   * counterweight to `outputs`; the task's own outputs ride along as `!`
+   * entries, as its key leaves them out.
+   */
+  inputs: Map<string, string[][]>
   /** Projects with a task that has a command and no cache: it reads what it likes, git-ignored files included. */
   uncached: Set<string>
   /** Files the project configs import by relative path (item 949). */
@@ -86,7 +90,19 @@ export async function sweepConfigs(
   load: CliLoadOptions = {},
 ): Promise<ConfigSweep> {
   const outputs = new Map<string, string[]>()
-  const inputs = new Map<string, string[]>()
+  const inputs = new Map<string, string[][]>()
+  // One task's inputs, less what it writes itself: the key leaves a task's
+  // own outputs out of its inputs, so a turbo() task reading `**/*` does not
+  // read the `dist/` it builds, and its write is no edit to watch.
+  const addInputs = (
+    dir: string,
+    files: readonly string[] | undefined,
+    own: readonly string[] | undefined,
+  ): void => {
+    if (files === undefined || files.length === 0) return
+    const minus = (own ?? []).filter((o) => !o.startsWith('!')).map((o) => `!${o}`)
+    inputs.set(dir, [...(inputs.get(dir) ?? []), [...files, ...minus]])
+  }
   const addTo = (
     into: Map<string, string[]>,
     dir: string,
@@ -104,8 +120,12 @@ export async function sweepConfigs(
       if (task.cache === undefined && task.exec !== undefined && task.exec.persistent === undefined)
         uncached.add(dir)
       for (const g of task.cache?.inputs?.workspaceFiles ?? []) workspaceInputs.add(g)
-      addTo(inputs, dir, task.cache?.inputs?.files)
-      addTo(inputs, workspaceRoot, task.cache?.inputs?.workspaceFiles)
+      addInputs(dir, task.cache?.inputs?.files, task.cache?.outputs?.files)
+      addInputs(
+        workspaceRoot,
+        task.cache?.inputs?.workspaceFiles,
+        task.cache?.outputs?.workspaceFiles,
+      )
       add(dir, task.cache?.outputs?.files)
       add(workspaceRoot, task.cache?.outputs?.workspaceFiles)
     }

package/src/cli/watch.ts

@@ -272,7 +272,7 @@ interface WatchLoopArgs {
   /** Declared output globs per directory they are relative to (project dir, or the root for `workspaceFiles`). */
   outputs: ReadonlyMap<string, readonly string[]>
   /** Declared input globs per directory: never ignored as another task's output. */
-  inputs: ReadonlyMap<string, readonly string[]>
+  inputs: ReadonlyMap<string, ReadonlyArray<readonly string[]>>
   /** Projects whose uncached task may read a git-ignored file: such a path there is still an edit. */
   uncached: ReadonlySet<string>
   /** Files the configs import: an edit to one outside the watched projects is a cycle that re-reads them. */
@@ -299,7 +299,7 @@ interface Rediscovered {
   workspaceWide: boolean
   workspaceInputs: readonly string[]
   outputs: ReadonlyMap<string, readonly string[]>
-  inputs: ReadonlyMap<string, readonly string[]>
+  inputs: ReadonlyMap<string, ReadonlyArray<readonly string[]>>
   uncached: ReadonlySet<string>
   configImports: readonly string[]
   workspaceConfigImports: readonly string[]

package/src/orchestrator/remote-prefetch.ts

@@ -20,6 +20,7 @@
 // that implements neither still prefetches, per-hash.
 
 import type { TaskNode } from '../graph/index.js'
+import { maskedCommand } from '../util/index.js'
 import type { CacheLayer, GitFilesCache } from '../cache/index.js'
 import type { HashCache } from './task-hash.js'
 import { deriveStableKeys } from './stable-keys.js'
@@ -114,7 +115,9 @@ export function getContext(node: TaskNode, command: string) {
   const outputs = node.config.cache?.outputs
   return {
     taskId: node.id,
-    command,
+    // Stored in the entry row a remote hit inserts: masked as a save's is,
+    // or the token a config inlined sat in cache.db (L-27).
+    command: maskedCommand(command, node.config.exec?.env),
     outputs: { files: outputs?.files ?? [], workspaceFiles: outputs?.workspaceFiles ?? [] },
   }
 }

package/src/orchestrator/run-records.ts

@@ -1,9 +1,10 @@
 // What a finished run leaves behind: the `runs` rows, the `invocations`
 // header row, and — only when a telemetry sink is active — the per-task
 // telemetry mirror. One pass over the outcome list builds all three, so
-// `invocations.task_count`, the terminal's "N total" and the number of
-// telemetry tasks are the same count by construction (`tallyOutcomes`
-// applies the same group/aborted filter).
+// `invocations.task_count` and the number of telemetry tasks agree by
+// construction; the terminal's "N total" agrees because `tallyOutcomes`
+// applies the same group/aborted filter, a second copy of the rule that
+// tests/run-records.test.ts holds to this one.
 
 import type { InvocationRecord, RunRecord } from '../cache/index.js'
 import { isGroupTask, type TaskOutcome } from '../graph/index.js'