@vzn/vx 0.0.77 → 0.0.78

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.77",
+  "version": "0.0.78",
   "description": "An open, extensible monorepo task runner.",
   "type": "module",
   "exports": {
@@ -17,10 +17,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.77",
-    "@vzn/vx-linux-arm64": "0.0.77",
-    "@vzn/vx-darwin-x64": "0.0.77",
-    "@vzn/vx-darwin-arm64": "0.0.77"
+    "@vzn/vx-linux-x64": "0.0.78",
+    "@vzn/vx-linux-arm64": "0.0.78",
+    "@vzn/vx-darwin-x64": "0.0.78",
+    "@vzn/vx-darwin-arm64": "0.0.78"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/orchestrator/excluded-keys.ts

@@ -54,8 +54,6 @@ export async function keyExcludedDependencies(args: KeyExcludedArgs): Promise<vo
   const derive = async (node: TaskNode): Promise<string | undefined> => {
     const upstream = await outcomes(fullDeps(node))
     if (isGroupTask(node)) return computeGroupHash(upstream)
-    // A persistent task has no key on the live path, so none here either.
-    if (node.config.exec?.persistent !== undefined) return undefined
     return computeTaskHash({
       node,
       upstream,

package/src/orchestrator/execute-task.ts

@@ -260,6 +260,23 @@ async function executePersistentTask(args: ExecuteArgs): Promise<TaskOutcome> {
   const effectiveForwardArgs = node.requested ? (args.forwardArgs ?? []) : []
   const env = taskEnv(node, step, args.workspaceRoot)
   const wallclockStartNs = process.hrtime.bigint() - args.runStartHrTimeNs
+  // Keyed like an uncached task (its whole project), so a cached dependant
+  // behind a dev server re-runs when the server's sources change; with no
+  // key the dependant folded nothing of it and replayed a stale e2e (A-17).
+  const hash =
+    args.noDependants === true
+      ? undefined
+      : await computeTaskHash({
+          node,
+          upstream: args.upstream,
+          workspaceRoot: args.workspaceRoot,
+          workspaceFingerprint: args.workspaceFingerprint,
+          cache: args.cache,
+          forwardArgs: args.forwardArgs,
+          nestedProjectDirs: args.nestedProjectDirs,
+          ...(args.gitFilesCache !== undefined ? { gitFilesCache: args.gitFilesCache } : {}),
+          ...(args.hashCache !== undefined ? { hashCache: args.hashCache } : {}),
+        })
 
   // The args after `--` reach a server as they reach any task. A readyWhen
   // server once got none — "so the matcher sees the unmodified output",
@@ -383,6 +400,7 @@ async function executePersistentTask(args: ExecuteArgs): Promise<TaskOutcome> {
     status: 'success',
     exitCode: 0,
     durationMs: spawn.readyMs(),
+    ...(hash !== undefined ? { hash } : {}),
     wallclockStartNs,
     wallclockEndNs: process.hrtime.bigint() - args.runStartHrTimeNs,
   }

package/src/orchestrator/keyed-projects.ts

@@ -18,10 +18,7 @@ import { selectFoldedDeps, type FoldCandidate } from './upstream.js'
  *     selects them (absent, or no `cache` at all, means all);
  *   - a group folds every dependency (`computeGroupHash`) and folds no
  *     files of its own;
- *   - a persistent task has no hash on the live path, so it is folded by
- *     no one and its own dependencies reach no key through it. (The local
- *     classify pass does give it one — stable-keys.ts — so a key there can
- *     move with more than this set names; never with less.)
+ *   - a persistent task is keyed as a task with no `cache` (A-17).
  *
  * Every exec task reached contributes its project, cached or not: a key
  * folds the task's own project files, and a task with no `cache` declares
@@ -71,7 +68,6 @@ function folded(node: TaskNode, nodes: ReadonlyMap<string, TaskNode>): FoldCandi
   const candidates: FoldCandidate[] = []
   for (const id of node.deps) {
     const dep = nodes.get(id)!
-    if (dep.config.exec?.persistent !== undefined) continue
     candidates.push({ node: dep, unit: foldUnit(dep) })
   }
   if (isGroupTask(node)) return candidates

package/src/orchestrator/plan.ts

@@ -131,14 +131,6 @@ export async function plan(args: PlanArgs): Promise<RunPlan> {
         cacheStatusById.set(node.id, 'group')
         return planOutcome(node, computeGroupHash(upstream))
       }
-      // A persistent task has no key on the live path (its outcome carries
-      // none, `stable-keys.ts`), so a dependant folds nothing for it. The
-      // plan keyed it and folded that, and `--dry` then called a dependant
-      // a miss under a key the run never looks up (item 766).
-      if (node.config.exec?.persistent !== undefined) {
-        cacheStatusById.set(node.id, 'no-cache')
-        return planOutcome(node, undefined)
-      }
 
       const hash = await computeTaskHash({
         node,

package/src/orchestrator/stable-keys.ts

@@ -87,13 +87,12 @@ export async function deriveStableKeys(args: DeriveStableKeysArgs): Promise<Stab
   const unfoldedById = new Map<string, ProjectSet>()
   const wsRewriters = new Set<string>()
   // A cached rewriter matters only to a key that leaves a dependency's key
-  // out: a `cache.inputs.tasks` filter, or a persistent dependency, which
-  // has no key. With neither in the graph every edge folds and the sets
-  // above stay empty, so they are not built (about 2 ms, median, of a 27 ms
-  // memoised walk over the 3,000-task bench; item 750).
+  // out: a `cache.inputs.tasks` filter. With none in the graph every edge
+  // folds and the sets above stay empty, so they are not built (about 2 ms,
+  // median, of a 27 ms memoised walk over the 3,000-task bench; item 750).
   let anyUnfolded = false
   for (const n of args.nodes.values()) {
-    if (n.config.cache?.inputs?.tasks !== undefined || n.config.exec?.persistent !== undefined) {
+    if (n.config.cache?.inputs?.tasks !== undefined) {
       anyUnfolded = true
       break
     }
@@ -188,12 +187,6 @@ export async function deriveStableKeys(args: DeriveStableKeysArgs): Promise<Stab
       continue
     }
 
-    // A persistent task has no key on the live path (its outcome carries no
-    // hash, so a dependent folds nothing of it); recording one here gave
-    // its dependents a second key, which a `--force` or remote run never
-    // saved under.
-    if (node.config.exec?.persistent !== undefined) continue
-
     const hash = await computeTaskHash({
       node,
       upstream,
@@ -226,8 +219,7 @@ export async function deriveStableKeys(args: DeriveStableKeysArgs): Promise<Stab
 /**
  * Does this task's key fold the dependency's? What `computeTaskHash` folds
  * (`filterUpstreamHashes` over the same synthetic outcomes); a group folds
- * every keyed member. A dependency with no key (persistent) is folded by
- * none.
+ * every keyed member.
  */
 function foldedBy(
   node: TaskNode,

package/src/orchestrator/upstream.ts

@@ -47,7 +47,7 @@ export function keyedDeps(node: TaskNode): readonly string[] {
  * folded into the cache key (the fold sorts by hash, so ordering here
  * doesn't affect derivation); the task id rides along so Tier-3's
  * `entry_inputs` rows can NAME which upstream a hash came from. An
- * upstream with no hash (a persistent task) folds nothing.
+ * upstream with no hash folds nothing.
  */
 export function filterUpstreamHashes(
   upstream: TaskOutcome[],