@vzn/vx 0.0.564 → 0.0.566

package/package.json

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

package/src/cli/watch-filter.ts

@@ -229,6 +229,7 @@ export function makeRootEventFilter(
   projectDirs: readonly string[],
   workspaceInputs: readonly string[],
   claimedRootFiles: ReadonlySet<string> = new Set(),
+  fenced: (ownDir: string, abs: string) => boolean = () => false,
 ): (filename: string) => boolean {
   const dirs = projectDirs.map((d) => path.resolve(d))
   const globs = workspaceInputs
@@ -257,12 +258,33 @@ export function makeRootEventFilter(
       return true
     }
     const abs = path.resolve(workspaceRoot, filename)
-    for (const d of dirs) if (abs === d || abs.startsWith(d + path.sep)) return true
+    for (const d of dirs)
+      if (abs === d || (abs.startsWith(d + path.sep) && !fenced(d, abs))) return true
     for (const g of globs) if (g.match(rel)) return true
     return false
   }
 }
 
+/**
+ * Whether `abs`, under the project at `ownDir`, lies inside another
+ * project nested there: the key's boundary (`computeNestedProjectDirs`)
+ * leaves such a file out, so it is no edit of `ownDir`'s. A root project
+ * watched its whole tree and ran a cycle for every edit in a nested one
+ * (X-42). The fences are the projects with a config, which fence a key
+ * whatever the plugins; a config-less one may not, and an edit there
+ * still counts. The fence's own config is let through: it coming or going
+ * moves the boundary, and the cycle it starts re-reads the set.
+ */
+export function makeFence(fenceDirs: readonly string[]): (ownDir: string, abs: string) => boolean {
+  const fences = fenceDirs.map((d) => path.resolve(d))
+  return (ownDir, abs) => {
+    const config = PROJECT_CONFIGS.has(path.basename(abs)) ? path.dirname(abs) : undefined
+    return fences.some(
+      (f) => f !== config && f.startsWith(ownDir + path.sep) && abs.startsWith(f + path.sep),
+    )
+  }
+}
+
 /**
  * A file whose edit can change what the loop watches: a `package.json`
  * (a dependency added under `--filter` widens the closure), a project

package/src/cli/watch.ts

@@ -37,6 +37,7 @@ import {
   isWorkspaceConfigFile,
   gitFiles,
   isWorkspaceFingerprintFile,
+  makeFence,
   makeRootEventFilter,
   makeWatchIgnore,
   shapesWatchedSet,
@@ -242,6 +243,7 @@ export async function watchCmd(args: readonly string[]): Promise<number> {
     workspaceConfigImports: swept.workspaceConfigImports,
     memberBases: memberBaseDirs(workspace),
     packageDirs: new Set(allProjects.map((p) => p.dir)),
+    fenceDirs: fenceDirs(allProjects),
     // The workspace as the cycle that just ran saw it: a package added or
     // removed since the loop armed joins or leaves the watched set. The
     // scope is the one resolved at start; a new package joins it only as a
@@ -266,6 +268,7 @@ export async function watchCmd(args: readonly string[]): Promise<number> {
         configImports: sweep.configImports,
         workspaceConfigImports: sweep.workspaceConfigImports,
         packageDirs: new Set(all.map((p) => p.dir)),
+        fenceDirs: fenceDirs(all),
       }
     },
     // Under --frozen every cycle's configs are the lock's, so a re-lock is
@@ -312,10 +315,15 @@ interface WatchLoopArgs {
   memberBases: readonly string[]
   /** Every package's directory, in scope or not: a member base's other entries are packages still to come. */
   packageDirs: ReadonlySet<string>
+  /** Every project with a config, in scope or not: a project's key leaves out what lies in one nested under it. */
+  fenceDirs: readonly string[]
   /** The watched set again, after a cycle that followed an event which can change it. */
   rediscover: () => Promise<Rediscovered>
 }
 
+const fenceDirs = (all: readonly ProjectMeta[]): string[] =>
+  all.filter((p) => p.configPath !== null).map((p) => p.dir)
+
 interface Rediscovered {
   projects: readonly ProjectMeta[]
   claimedRootFiles: ReadonlySet<string>
@@ -328,6 +336,7 @@ interface Rediscovered {
   configImports: readonly string[]
   workspaceConfigImports: readonly string[]
   packageDirs: ReadonlySet<string>
+  fenceDirs: readonly string[]
 }
 
 async function runWatchLoop(args: WatchLoopArgs): Promise<number> {
@@ -424,7 +433,14 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<number> {
   // project would otherwise trigger every save during `bun install` —
   // and vx's own cache writes would trigger a cycle that writes again.
   let isIgnoredPath = makeWatchIgnore(cacheDir, outputs, inputs)
-  let matters = makeRootEventFilter(workspaceRoot, projectDirs, workspaceInputs, claimedRootFiles)
+  let fenced = makeFence(args.fenceDirs)
+  let matters = makeRootEventFilter(
+    workspaceRoot,
+    projectDirs,
+    workspaceInputs,
+    claimedRootFiles,
+    fenced,
+  )
   /** Since the last cycle, a member came or went, or a file that shapes the watched set changed (`shapesWatchedSet`). */
   let reread = false
 
@@ -472,9 +488,10 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<number> {
   const armProject = (proj: ProjectMeta): void => {
     try {
       const handle = arm(proj.dir, true, (filename) => {
-        if (isIgnoredPath(proj.dir, filename)) return
+        const abs = path.join(proj.dir, filename)
+        if (isIgnoredPath(proj.dir, filename) || fenced(proj.dir, abs)) return
         if (shapesWatchedSet(filename)) reread = true
-        trigger(`${proj.name} ${filename}`, path.join(proj.dir, filename))
+        trigger(`${proj.name} ${filename}`, abs)
       })
       perProject.set(proj.dir, handle)
       armedAs.set(proj.dir, inodeOf(proj.dir) ?? '')
@@ -659,7 +676,14 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<number> {
     memberBases = next.memberBases
     armBases()
     isIgnoredPath = makeWatchIgnore(cacheDir, outputs, inputs)
-    matters = makeRootEventFilter(workspaceRoot, projectDirs, workspaceInputs, claimedRootFiles)
+    fenced = makeFence(next.fenceDirs)
+    matters = makeRootEventFilter(
+      workspaceRoot,
+      projectDirs,
+      workspaceInputs,
+      claimedRootFiles,
+      fenced,
+    )
     if (next.workspaceWide !== workspaceWide) {
       // A task started or stopped declaring `workspaceFiles`: the other
       // arm's shape. Until item 891 the choice was made once, at start, and

package/src/orchestrator/framed-output.ts

@@ -25,6 +25,7 @@
 // price is no live progress within a task. This matches Turbo's
 // `--ui=stream` mode.
 
+import { withForwardArgs } from '../exec/index.js'
 import { isGroupTask, type TaskNode, type TaskOutcome } from '../graph/index.js'
 import { maskedCommand } from '../util/index.js'
 import { paint, type ColorSupport } from './colors.js'
@@ -82,6 +83,7 @@ export function formatTaskBlock(
   // tasks set this so a requested task's frame is identical whether it
   // ran or was cached — you asked for it, you see what it would run.
   forceCommand = false,
+  forwardArgs: readonly string[] = [],
 ): string {
   // Group tasks (no `exec`) do no work and have no body — they're
   // organizational nodes the user wrote so a `vx run ci` invocation
@@ -105,11 +107,7 @@ export function formatTaskBlock(
   if (forceCommand || outcome.status === 'success' || outcome.status === 'failed') {
     // No section label for the command (owner cut it) — the dim `$ `
     // line under the header reads as the command on its own.
-    lines.push(
-      '',
-      corner(`$ ${maskedCommand(node.config.exec?.command ?? '', node.config.exec?.env)}`),
-      '',
-    )
+    lines.push('', corner(`$ ${shownCommand(node, forwardArgs)}`), '')
   }
 
   pushStreamSection(lines, stdout, 'STDOUT', SUCCESS, body.droppedStdout ?? 0, colors)
@@ -444,9 +442,13 @@ export function formatTaskAbortedLine(
  * formatTaskBlock, but emitted in real time around the live stream
  * instead of buffered.
  */
-export function formatFrameOpen(node: TaskNode, colors: ColorSupport = NO_COLOR): string {
+export function formatFrameOpen(
+  node: TaskNode,
+  colors: ColorSupport = NO_COLOR,
+  forwardArgs: readonly string[] = [],
+): string {
   const corner = (t: string) => paint('', t, colors, { dim: true })
-  const cmd = maskedCommand(node.config.exec?.command ?? '', node.config.exec?.env)
+  const cmd = shownCommand(node, forwardArgs)
   const mark = isPersistentNode(node) ? `${paint(ACCENT, '▸', colors)} ` : ''
   return `${corner('┌─')} ${mark}${paintTaskId(node, colors, { bold: true })} ${corner('>')} $ ${cmd}`
 }
@@ -492,6 +494,15 @@ export function formatFrameClose(
   return violations.length === 0 ? close : `${violations.join('\n')}\n${close}`
 }
 
+/** What ran: a requested task gets the args after `--`, as execute-task.ts appends them. */
+function shownCommand(node: TaskNode, forwardArgs: readonly string[]): string {
+  const exec = node.config.exec
+  return maskedCommand(
+    withForwardArgs(exec?.command ?? '', node.requested ? forwardArgs : []),
+    exec?.env,
+  )
+}
+
 function isPersistentNode(node: TaskNode): boolean {
   return node.config.exec?.persistent !== undefined
 }
@@ -512,11 +523,12 @@ export function formatPersistentTailBlock(
   body: TaskBlockBody,
   dropped: { stdout?: number; stderr?: number } = {},
   colors: ColorSupport = NO_COLOR,
+  forwardArgs: readonly string[] = [],
 ): string {
   const stdout = body.stdout ?? ''
   const stderr = body.stderr ?? ''
   if (stdout.trim().length === 0 && stderr.trim().length === 0) return ''
-  const lines: string[] = [formatFrameOpen(node, colors)]
+  const lines: string[] = [formatFrameOpen(node, colors, forwardArgs)]
   pushStreamSection(lines, stdout, 'STDOUT (since ready)', SUCCESS, dropped.stdout ?? 0, colors)
   pushStreamSection(lines, stderr, 'STDERR (since ready)', ERROR, dropped.stderr ?? 0, colors)
   lines.push(formatFrameClose(node, outcome, colors))

package/src/orchestrator/logger.ts

@@ -166,8 +166,15 @@ export function defaultLogger(
   colors: ColorSupport = detectColors(),
   view: OutputView = { mode: 'full' },
   out: StatusStream = process.stdout,
-  opts: { forceFloorMs?: number; coalesce?: boolean; tty?: boolean } = {},
+  opts: {
+    forceFloorMs?: number
+    coalesce?: boolean
+    tty?: boolean
+    /** The args after `--`: a requested task's `$ <command>` line shows them, as it ran. */
+    forwardArgs?: readonly string[]
+  } = {},
 ): DefaultLogger {
+  const forwardArgs = opts.forwardArgs ?? []
   // Per-task buffers, split by stream. Splitting lets the framed-output
   // renderer put stdout under `├─ stdout` and stderr under `├─ stderr`.
   // The price: chunks that interleaved at runtime get re-ordered (all
@@ -478,7 +485,7 @@ export function defaultLogger(
         killStatus()
         // Open the live frame: full task info even when the command
         // streams nothing (or the hit replays nothing).
-        emitLine(formatFrameOpen(node, colors))
+        emitLine(formatFrameOpen(node, colors, forwardArgs))
         return
       }
       // Bound a persistent task's output from its FIRST chunk. Waiting for
@@ -520,6 +527,7 @@ export function defaultLogger(
                   { stdout: tailText(t.out), stderr: tailText(t.err) },
                   { stdout: t.out.dropped, stderr: t.err.dropped },
                   colors,
+                  forwardArgs,
                 ),
               ),
             )
@@ -619,7 +627,16 @@ export function defaultLogger(
           return
         }
         if (framed && (stdout.length > 0 || stderr.length > 0)) {
-          emitBlock(formatTaskBlock(node, outcome, { stdout, stderr, ...dropped }, colors, true))
+          emitBlock(
+            formatTaskBlock(
+              node,
+              outcome,
+              { stdout, stderr, ...dropped },
+              colors,
+              true,
+              forwardArgs,
+            ),
+          )
           return
         }
         // Otherwise a row in the task list, in every view that lists a
@@ -709,7 +726,14 @@ export function defaultLogger(
           if (outcome.status !== 'failed') return
           emitLine(failureRow(node, outcome))
           deferredFailures.push(
-            formatTaskBlock(node, outcome, { stdout, stderr, ...dropped }, colors),
+            formatTaskBlock(
+              node,
+              outcome,
+              { stdout, stderr, ...dropped },
+              colors,
+              false,
+              forwardArgs,
+            ),
           )
           return
         case 'broad':
@@ -721,7 +745,14 @@ export function defaultLogger(
             // ◼ row now; the full frame replays at runEnd.
             emitLine(failureRow(node, outcome))
             deferredFailures.push(
-              formatTaskBlock(node, outcome, { stdout, stderr, ...dropped }, colors),
+              formatTaskBlock(
+                node,
+                outcome,
+                { stdout, stderr, ...dropped },
+                colors,
+                false,
+                forwardArgs,
+              ),
             )
           } else if (outcome.status === 'success') {
             emitLine(formatTaskExecutedLine(node, outcome, colors))
@@ -758,13 +789,29 @@ export function defaultLogger(
             if (outcome.status === 'failed') {
               emitLine(failureRow(node, outcome))
               deferredFailures.push(
-                formatTaskBlock(node, outcome, { stdout, stderr, ...dropped }, colors),
+                formatTaskBlock(
+                  node,
+                  outcome,
+                  { stdout, stderr, ...dropped },
+                  colors,
+                  false,
+                  forwardArgs,
+                ),
               )
               return
             }
             // forceCommand: a requested task's frame shows `$ cmd`
             // whether it ran or was cached — same frame every run.
-            emitBlock(formatTaskBlock(node, outcome, { stdout, stderr, ...dropped }, colors, true))
+            emitBlock(
+              formatTaskBlock(
+                node,
+                outcome,
+                { stdout, stderr, ...dropped },
+                colors,
+                true,
+                forwardArgs,
+              ),
+            )
             return
           }
           // Dependency-pulled nodes: silent on success; a skip gets its
@@ -774,7 +821,14 @@ export function defaultLogger(
           } else if (outcome.status === 'failed') {
             emitLine(failureRow(node, outcome))
             deferredFailures.push(
-              formatTaskBlock(node, outcome, { stdout, stderr, ...dropped }, colors),
+              formatTaskBlock(
+                node,
+                outcome,
+                { stdout, stderr, ...dropped },
+                colors,
+                false,
+                forwardArgs,
+              ),
             )
           }
           return
@@ -793,7 +847,14 @@ export function defaultLogger(
             emitLine(formatTaskSkippedLine(node, colors, outcome.blockedBy))
             return
           }
-          const block = formatTaskBlock(node, outcome, { stdout, stderr, ...dropped }, colors)
+          const block = formatTaskBlock(
+            node,
+            outcome,
+            { stdout, stderr, ...dropped },
+            colors,
+            false,
+            forwardArgs,
+          )
           if (block.length === 0) return
           if (view.gha) {
             // The block is the task's own output — fenced, so a task that

package/src/orchestrator/run.ts

@@ -297,6 +297,7 @@ export async function run(options: RunOptions): Promise<RunSummary> {
       ? defaultLogger(colors, resolveOutputView(options), process.stdout, {
           coalesce: true,
           ...(options.tty === true ? { tty: true } : {}),
+          ...(options.forwardArgs !== undefined ? { forwardArgs: options.forwardArgs } : {}),
         })
       : null
   const sink = options.log ?? terminal!