@vzn/vx 0.0.153 → 0.0.155

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.153",
+  "version": "0.0.155",
   "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.153",
-    "@vzn/vx-linux-arm64": "0.0.153",
-    "@vzn/vx-darwin-x64": "0.0.153",
-    "@vzn/vx-darwin-arm64": "0.0.153"
+    "@vzn/vx-linux-x64": "0.0.155",
+    "@vzn/vx-linux-arm64": "0.0.155",
+    "@vzn/vx-darwin-x64": "0.0.155",
+    "@vzn/vx-darwin-arm64": "0.0.155"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

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/persistent.ts

@@ -3,7 +3,7 @@
 // ownership moves to the run's registry, and this is the one place that
 // decides which of them outlive the graph and how the rest go down.
 
-import type { TaskNode } from '../graph/index.js'
+import { isGroupTask, type TaskNode } from '../graph/index.js'
 import { killGraceMs } from '../util/index.js'
 import { holdGroups, killTree, untilGroupsGone } from '../exec/index.js'
 
@@ -25,9 +25,12 @@ export interface KeepAlive {
 /**
  * A persistent task the user REQUESTED (or one surfaced for display) is the
  * run's whole purpose — it is left running and blocked on at the very end,
- * after the summary. Only in the real CLI foreground: a custom logger or
- * `handleSignals: false` (watch mode, embedders) expects `run()` to return,
- * not to sit on a server.
+ * after the summary. So is every persistent task a kept one depends on,
+ * directly or through groups: `vx run dev --filter app` stopped the api#dev
+ * its app#dev was started against (C-46). A one-shot's persistent deps are
+ * not kept on its account; it has finished with them. Only in the real CLI
+ * foreground: a custom logger or `handleSignals: false` (watch mode,
+ * embedders) expects `run()` to return, not to sit on a server.
  */
 export function selectKeepAlive(
   registry: ReadonlyMap<string, Child>,
@@ -36,13 +39,25 @@ export function selectKeepAlive(
 ): KeepAlive {
   const out: KeepAlive = { nodes: [], children: [] }
   if (!foreground) return out
-  for (const [id, child] of registry) {
+  const stack = [...registry.keys()].filter((id) => {
     const n = nodes.get(id)
-    if (n !== undefined && (n.requested || n.surfaced === true)) {
-      out.nodes.push(n)
-      out.children.push(child)
+    return n !== undefined && (n.requested || n.surfaced === true)
+  })
+  const reached = new Set<string>()
+  while (stack.length > 0) {
+    const id = stack.pop()!
+    if (reached.has(id)) continue
+    reached.add(id)
+    for (const dep of nodes.get(id)?.deps ?? []) {
+      const d = nodes.get(dep)
+      if (d !== undefined && (registry.has(dep) || isGroupTask(d))) stack.push(dep)
     }
   }
+  for (const [id, child] of registry) {
+    if (!reached.has(id)) continue
+    out.nodes.push(nodes.get(id)!)
+    out.children.push(child)
+  }
   return out
 }
 

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 ?? [] },
   }
 }