@vzn/vx 0.0.563 → 0.0.565

package/package.json

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

package/src/orchestrator/affected-tasks.ts

@@ -49,8 +49,9 @@ function wholeProjects(
 /**
  * The task ids of `ids` whose closure the change reaches, in their order.
  * A group seeds nothing (it runs nothing) unless it is keyed, as the default
- * `build` is; an uncached task seeds whenever its project changed; a cached
- * one when a changed path is one of its declared inputs. A `^name` edge the
+ * `build` is; an uncached task seeds when a changed path lies in its project
+ * (or the whole project is reached); a cached one when a changed path is one
+ * of its declared inputs. A `^name` edge the
  * graph passes through a package it loaded no config for reaches it as the
  * default `build` would: any change there reaches the task.
  */
@@ -90,7 +91,11 @@ export function affectedRoots(
     if (!changes.projects.has(n.projectName)) return false
     const cache = n.config.cache
     // A group runs nothing; only the default `build` (projects.ts) is keyed.
-    if (cache === undefined) return !isGroupTask(n)
+    // An uncached task reads its project: a root file another task of it
+    // declares (`workspaceFiles`) is no change there.
+    if (cache === undefined) {
+      return !isGroupTask(n) && (whole.has(n.projectName) || changes.paths.has(n.projectName))
+    }
     if (whole.has(n.projectName)) return true
     if ((changes.paths.get(n.projectName) ?? []).some((rel) => declaresInput(cache, rel, null))) {
       return true

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!