@vzn/vx 0.0.594 → 0.0.596

package/src/orchestrator/lockfile-claim.ts

@@ -9,8 +9,8 @@
 //
 // The digests are memoised on disk under the cache dir by the file's
 // xxh3, so a warm run pays one read + hash + a small JSON read, never a
-// parse; within one process (a run, a watch cycle) the file's size and
-// mtime gate even the read; and per run the read happens once (a WeakMap
+// parse; within one process (a run, a watch cycle) the file's size,
+// mtime, ctime and inode gate even the read; and per run the read happens once (a WeakMap
 // on the context core hands every `key` call of a run).
 
 import path from 'node:path'
@@ -87,18 +87,33 @@ async function hashExtra(workspaceRoot: string, rel: string): Promise<string> {
   }
 }
 
-async function statsOf(
+/**
+ * A file's identity for the in-process gate, as `Cache.hashFile`'s memo
+ * keys one: size and mtime alone kept the digests of a lockfile or patch
+ * replaced by another of the same size with its mtime kept (`cp -p`,
+ * `tar -x`), and no task sets a ctime.
+ */
+function identityOf(st: { size: number; mtimeMs: number; ctimeMs: number; ino: number }): string {
+  return `${st.size}:${st.mtimeMs}:${st.ctimeMs}:${st.ino}`
+}
+
+async function statsOf(workspaceRoot: string, rels: readonly string[]): Promise<string[]> {
+  return Promise.all(
+    rels.map((rel) => stat(path.join(workspaceRoot, rel)).then(identityOf, () => 'gone')),
+  )
+}
+
+/** Each file's identity, taken BEFORE its hash, so a write between the two re-reads it. */
+async function hashExtras(
   workspaceRoot: string,
   rels: readonly string[],
-): Promise<Array<{ size: number; mtimeMs: number }>> {
-  return Promise.all(
-    rels.map((rel) =>
-      stat(path.join(workspaceRoot, rel)).then(
-        (st) => ({ size: st.size, mtimeMs: st.mtimeMs }),
-        () => ({ size: -1, mtimeMs: -1 }),
-      ),
-    ),
+): Promise<{ hashes: Record<string, string>; stats: Record<string, string> }> {
+  const ids = await statsOf(workspaceRoot, rels)
+  const stats = Object.fromEntries(rels.map((rel, i) => [rel, ids[i]!] as const))
+  const hashes = Object.fromEntries(
+    await Promise.all(rels.map(async (rel) => [rel, await hashExtra(workspaceRoot, rel)] as const)),
   )
+  return { hashes, stats }
 }
 
 export function lockfileClaim(options: LockfileClaimOptions): LockfileClaimHooks {
@@ -108,15 +123,14 @@ export function lockfileClaim(options: LockfileClaimOptions): LockfileClaimHooks
   if (scope !== 'project' && scope !== 'workspace') {
     throw new Error(`scope must be 'project' or 'workspace', not ${JSON.stringify(scope)}`)
   }
-  // Per workspace root: what the last read saw. `size` + `mtimeMs` gate a
-  // re-read; the content hash decides whether the digests are current.
+  // Per workspace root: what the last read saw. Each file's identity gates
+  // a re-read; the content hash decides whether the digests are current.
   const seen = new Map<
     string,
     {
-      size: number
-      mtimeMs: number
+      identity: string
       extras: readonly string[]
-      extraStats: ReadonlyArray<{ size: number; mtimeMs: number }>
+      extraStats: Readonly<Record<string, string>>
       digests: Digests
     }
   >()
@@ -125,23 +139,18 @@ export function lockfileClaim(options: LockfileClaimOptions): LockfileClaimHooks
 
   const load = async (workspaceRoot: string, cacheDir: string): Promise<Digests> => {
     const full = path.join(workspaceRoot, file)
-    let st: { size: number; mtimeMs: number }
+    let identity: string
     try {
-      st = await stat(full)
+      identity = identityOf(await stat(full))
     } catch {
       const digests: Digests = { lock: '', importers: new Map() }
-      seen.set(workspaceRoot, { size: -1, mtimeMs: -1, extras: [], extraStats: [], digests })
+      seen.set(workspaceRoot, { identity: 'gone', extras: [], extraStats: {}, digests })
       return digests
     }
     const last = seen.get(workspaceRoot)
-    if (last !== undefined && last.size === st.size && last.mtimeMs === st.mtimeMs) {
+    if (last !== undefined && last.identity === identity) {
       const now = await statsOf(workspaceRoot, last.extras)
-      if (
-        now.every(
-          (s, i) =>
-            s.size === last.extraStats[i]!.size && s.mtimeMs === last.extraStats[i]!.mtimeMs,
-        )
-      ) {
+      if (now.every((s, i) => s === last.extraStats[last.extras[i]!])) {
         return last.digests
       }
     }
@@ -152,28 +161,22 @@ export function lockfileClaim(options: LockfileClaimOptions): LockfileClaimHooks
     // re-hashes the files the memo names and never parses to learn them.
     const memo = await readMemo(memoFile, version, lockHash)
     let extras: Record<string, string> = {}
+    let extraStats: Record<string, string> = {}
     let importers: ReadonlyMap<string, string> | undefined
     if (memo !== undefined) {
-      const now = Object.fromEntries(
-        await Promise.all(
-          Object.keys(memo.extras).map(
-            async (rel) => [rel, await hashExtra(workspaceRoot, rel)] as const,
-          ),
-        ),
-      )
-      if (Object.entries(memo.extras).every(([rel, h]) => now[rel] === h)) {
+      const now = await hashExtras(workspaceRoot, Object.keys(memo.extras))
+      if (Object.entries(memo.extras).every(([rel, h]) => now.hashes[rel] === h)) {
         extras = memo.extras
+        extraStats = now.stats
         importers = memo.importers
       }
     }
     if (importers === undefined) {
       const text = decode(bytes)
       const rels = [...new Set(options.extraFiles?.(text) ?? [])].sort()
-      extras = Object.fromEntries(
-        await Promise.all(
-          rels.map(async (rel) => [rel, await hashExtra(workspaceRoot, rel)] as const),
-        ),
-      )
+      const now = await hashExtras(workspaceRoot, rels)
+      extras = now.hashes
+      extraStats = now.stats
       importers =
         scope === 'workspace'
           ? new Map<string, string>()
@@ -191,13 +194,7 @@ export function lockfileClaim(options: LockfileClaimOptions): LockfileClaimHooks
         ? lockHash
         : xxh3hex([lockHash, ...rels.map((r) => `${r}\0${extras[r]}`)].join('\0'))
     const digests: Digests = { lock, importers }
-    seen.set(workspaceRoot, {
-      size: st.size,
-      mtimeMs: st.mtimeMs,
-      extras: rels,
-      extraStats: await statsOf(workspaceRoot, rels),
-      digests,
-    })
+    seen.set(workspaceRoot, { identity, extras: rels, extraStats, digests })
     return digests
   }
   const loadOnce = (ctx: KeyHookContext): Promise<Digests> => {

package/src/orchestrator/logger.ts

@@ -23,7 +23,7 @@ import { formatDuration, formatSummarySection, neverStarted, type RunContext } f
 import { isGroupTask } from '../graph/index.js'
 import { appendTail, createTail, resetTail, tailText, type Tail } from '../util/index.js'
 import { isCacheHit } from './telemetry.js'
-import { failedLabel, outcomeWord } from './events.js'
+import { failedLabel, outcomeWord, ranNoCache } from './events.js'
 
 export interface Logger {
   /** Header / footer / status text. Written verbatim, one trailing \n added. */
@@ -139,8 +139,7 @@ function ghaFence(body: string, token: string): string {
   return `::stop-commands::${token}\n${body}::${token}::\n`
 }
 
-const cacheWordOf = (n: TaskNode): 'miss' | 'no-cache' =>
-  n.config.cache === undefined ? 'no-cache' : 'miss'
+const cacheWordOf = (o: TaskOutcome): 'miss' | 'no-cache' => (ranNoCache(o) ? 'no-cache' : 'miss')
 
 export function resolveOutputView(
   options: {
@@ -440,7 +439,7 @@ export function defaultLogger(
     (view.mode === 'focused' && isPrimary(node) && !isGroupTask(node) && requestedCount <= 1)
 
   const failureRow = (node: TaskNode, outcome: TaskOutcome): string =>
-    formatFailureLine(node.id, outcome.durationMs, colors, cacheWordOf(node)) +
+    formatFailureLine(node.id, outcome.durationMs, colors, cacheWordOf(outcome)) +
     flakyNote(outcome, colors)
 
   return {
@@ -453,6 +452,12 @@ export function defaultLogger(
       // A kept server's held partial line is older than this line: held
       // past it, a server's last words printed below its own exit notice.
       flushKept()
+      // A live-streamed server keeps writing after its frame closes, so a
+      // summary row or "exited with code" can follow its partial line.
+      if (streamMidLine) {
+        writer.write('\n')
+        streamMidLine = false
+      }
       writer.write(`${line}\n`)
     },
     runStart(info) {
@@ -654,7 +659,7 @@ export function defaultLogger(
         done++
         if (outcome.status === 'failed') {
           failed++
-          if (node.config.cache === undefined) noCache++
+          if (ranNoCache(outcome)) noCache++
         } else if (node.config.exec?.persistent !== undefined && outcome.status === 'success') {
           // A persistent task's outcome arrives at READY; the child
           // keeps running until the orchestrator SIGTERMs it at run
@@ -678,7 +683,7 @@ export function defaultLogger(
         switch (outcome.status) {
           case 'success':
             succeeded++
-            if (node.config.cache === undefined) noCache++
+            if (ranNoCache(outcome)) noCache++
             break
           case 'cache-hit':
             if (outcome.restored === false) upToDate++

package/src/orchestrator/metrics.ts

@@ -407,11 +407,18 @@ function unchangedKeyNote(
       at: number
     } | null
   )?.at
-  // Both runs executed the task and succeeded with the cache writable, no
-  // entry holds the key, and each ran beside a failure: the continue-taint
-  // (admission.ts), which runs a task downstream of a failure and never
-  // saves it. Blaming `--no-cache` / `--force` named a flag nobody passed.
-  if (createdAt === undefined && this_.status === 'success' && prev.status === 'success') {
+  // The previous run executed the task and succeeded with the cache
+  // writable beside a failure, and no entry older than this run holds the
+  // key: the continue-taint (admission.ts), which runs a task downstream of
+  // a failure and never saves it. Blaming `--no-cache` / `--force` named a
+  // flag nobody passed, and a prune when this run saved the key named an
+  // eviction that never happened.
+  if (
+    (createdAt === undefined || createdAt >= this_.startedAt) &&
+    this_.status === 'success' &&
+    prev.status === 'success' &&
+    prev.cacheHit === 0
+  ) {
     const failedWithWrites = (id: string | null): number => {
       if (id === null) return 0
       const row = db
@@ -420,9 +427,13 @@ function unchangedKeyNote(
       const writes = row?.p.split(',').some((axis) => axis === 'lW' || axis === 'rW') === true
       return writes ? (row?.f ?? 0) : 0
     }
-    const now = failedWithWrites(runId)
-    if (prev.cacheHit === 0 && now > 0 && failedWithWrites(prev.runId) > 0) {
-      return `cache key unchanged — neither run saved it: each ran beside a failed task (${now} failed in this one), and a task run past a failed dependency (--continue) is never cached`
+    const before = failedWithWrites(prev.runId)
+    if (before > 0) {
+      const now = failedWithWrites(runId)
+      if (createdAt === undefined && now > 0) {
+        return `cache key unchanged — neither run saved it: each ran beside a failed task (${now} failed in this one), and a task run past a failed dependency (--continue) is never cached`
+      }
+      return `cache key unchanged — the previous run on this key ran beside a failed task (${before} failed in it) and was not saved: a task run past a failed dependency (--continue) is never cached, so there was nothing to hit`
     }
   }
   if (createdAt !== undefined && createdAt >= this_.startedAt) {

package/src/orchestrator/miss-save.ts

@@ -70,8 +70,8 @@ export interface SaveMissArgs {
   nestedProjectDirs: string[]
   gitFilesCache?: GitFilesCache | undefined
   /** Declared `cache.outputs.files` / `.workspaceFiles`. */
-  outputs: string[]
-  wsOutputs: string[]
+  outputs: readonly string[]
+  wsOutputs: readonly string[]
   /**
    * An ADDITIVE task's own set (item 588): the files its run added or
    * changed under its declared outputs, resolved by execute-task against

package/src/orchestrator/options.ts

@@ -171,6 +171,13 @@ export interface RunOptions {
    * else is treated as the literal file path (cwd-relative).
    */
   summarize?: string
+  /**
+   * Text printed just above the run's footer, given the outcomes the
+   * footer counts, after the `summaryTable`: nothing prints below the
+   * footer (owner), so a caller's end-of-run report (`--report`) rides
+   * here. Not called on a refused run.
+   */
+  beforeFooter?: (outcomes: readonly TaskOutcome[], ok: boolean) => string
   /**
    * If set, write a Chrome-trace JSON profile of the run's wallclock
    * spans. Path is cwd-relative. Default `profile.json` is selected

package/src/orchestrator/plan.ts

@@ -12,8 +12,15 @@
 // side-effect-free pure probes.
 
 import type { CacheLayer, CachePolicy, GitFilesCache } from '../cache/index.js'
-import { FULL_CACHE_POLICY } from '../cache/index.js'
-import { isGroupTask, runGraph, type TaskNode, type TaskOutcome } from '../graph/index.js'
+import { cachesNothing, FULL_CACHE_POLICY } from '../cache/index.js'
+import { ranNoCache } from './events.js'
+import {
+  idleServers,
+  isGroupTask,
+  runGraph,
+  type TaskNode,
+  type TaskOutcome,
+} from '../graph/index.js'
 import type { HistoryProvider } from './history.js'
 import { computeGroupKey, computeTaskHash } from './task-hash.js'
 import { keyUpstream } from './upstream.js'
@@ -24,6 +31,7 @@ export type CacheStatus =
   | 'miss' // caching enabled but no entry — would execute
   | 'no-cache' // task opts out of caching (no `cache` block) or --no-cache
   | 'group' // no `exec`; just an aggregator
+  | 'not-started' // a server every dependant of which restores early: the run never spawns it
 
 export interface PlannedTask {
   node: TaskNode
@@ -108,6 +116,12 @@ export interface PlanArgs {
   history?: HistoryProvider
   /** Placement lookup (`placement.ts`): >1 executor declared, or a `noop` task. */
   executorOf?: (id: string) => string | undefined
+  /**
+   * The tasks the run's short-circuit would restore ahead of their deps on
+   * a local hit (stable key, no workspace-output reach). A server whose
+   * every dependant is one of those and a local hit is never spawned.
+   */
+  restorable?: ReadonlySet<string>
 }
 
 /**
@@ -156,9 +170,8 @@ export async function plan(args: PlanArgs): Promise<RunPlan> {
       // policy-aware cache layer, which itself respects read gating.
       const policy = args.cachePolicy ?? FULL_CACHE_POLICY
       const reads = policy.localRead || policy.remoteRead
-      const writes = policy.localWrite || policy.remoteWrite
       let status: CacheStatus
-      if (node.config.cache === undefined || (!reads && !writes)) {
+      if (ranNoCache({ node, cacheOff: cachesNothing(policy) })) {
         status = 'no-cache'
       } else if (!reads) {
         status = 'miss'
@@ -171,6 +184,17 @@ export async function plan(args: PlanArgs): Promise<RunPlan> {
     },
   })
 
+  if (args.restorable !== undefined) {
+    const restoreTier = new Set(
+      [...args.restorable].filter((id) => cacheStatusById.get(id) === 'hit-local'),
+    )
+    const dependents = new Map<string, string[]>()
+    for (const node of args.nodes.values())
+      for (const dep of node.deps) dependents.set(dep, [...(dependents.get(dep) ?? []), node.id])
+    for (const id of idleServers(args.nodes, dependents, restoreTier))
+      cacheStatusById.set(id, 'not-started')
+  }
+
   const tasks: PlannedTask[] = []
   for (const id of args.nodes.keys()) {
     const o = outcomes.get(id)

package/src/orchestrator/plugin-host.ts

@@ -107,6 +107,25 @@ export function hasHook(
   return false
 }
 
+/**
+ * An in-place stage reads nothing a hook returns: Vite's `config` hook
+ * returns a partial config, and one written that way here loaded, changed
+ * nothing and said nothing. Returning the object it was handed is harmless.
+ */
+function assertEditedInPlace(
+  plugin: VxPlugin,
+  hook: 'config' | 'project' | 'graph',
+  returned: unknown,
+  edited: unknown,
+  what: string,
+): void {
+  if (returned === undefined || returned === edited) return
+  throw new UserError(
+    `plugin '${plugin.name}' failed in ${hook}: returned ${describeValue(returned)}, which core ` +
+      `ignores — edit ${what} in place`,
+  )
+}
+
 /** `config` stage: every plugin edits the workspace config in place. */
 export async function applyConfigHooks(
   plugins: readonly VxPlugin[],
@@ -117,7 +136,8 @@ export async function applyConfigHooks(
 ): Promise<void> {
   for (const plugin of plugins) {
     if (plugin.config === undefined) continue
-    await safe(plugin, 'config', () => plugin.config!(workspace, ctx))
+    const returned = await safe(plugin, 'config', () => plugin.config!(workspace, ctx))
+    assertEditedInPlace(plugin, 'config', returned, workspace, 'the workspace config')
     afterEach?.(plugin)
   }
 }
@@ -158,7 +178,8 @@ export async function applyProjectHooks(
 ): Promise<void> {
   for (const plugin of plugins) {
     if (plugin.project === undefined) continue
-    await safe(plugin, 'project', () => plugin.project!(config, ctx))
+    const returned = await safe(plugin, 'project', () => plugin.project!(config, ctx))
+    assertEditedInPlace(plugin, 'project', returned, config, "the project's config")
     afterEach?.(plugin)
   }
 }
@@ -184,7 +205,8 @@ export async function applyGraphHooks(
   let last: VxPlugin | undefined
   for (const plugin of plugins) {
     if (plugin.graph === undefined) continue
-    await safe(plugin, 'graph', () => plugin.graph!(nodes, ctx))
+    const returned = await safe(plugin, 'graph', () => plugin.graph!(nodes, ctx))
+    assertEditedInPlace(plugin, 'graph', returned, nodes, 'the task graph')
     await safe(plugin, 'graph', () => checkNodeShapes(nodes))
     afterEach?.(plugin)
     last = plugin

package/src/orchestrator/plugin.ts

@@ -142,9 +142,9 @@ export interface VxPlugin {
    * many times per run, so it must be cheap and synchronous; a throw, or
    * an answer that is a Promise, is reported once and the plugin admits
    * from then on — a policy never
-   * breaks a run. Restore-tier hits and tasks on an executor pool hold no
-   * local resources and are never asked. When several plugins answer, all
-   * must admit. Core keeps no notion of what a task needs: a plugin that
+   * breaks a run. Restore-tier hits, tasks on an executor pool and groups
+   * hold no local resources: never asked, never in `ctx.running`. When
+   * several plugins answer, all must admit. Core keeps no notion of what a task needs: a plugin that
    * packs memory or CPU learns or declares the numbers itself
    * (`@vzn/vx-schedule-history` packs what past executions used).
    */
@@ -341,7 +341,12 @@ export interface FingerprintContext extends BaseContext {
 }
 
 export interface AdmitContext {
-  /** The tasks executing on this machine right now, in dispatch order. */
+  /**
+   * The tasks holding a worker on this machine right now, in dispatch
+   * order. A persistent task leaves at ready, when it gives its worker
+   * back: it runs until the graph ends, so a policy that counted it would
+   * hold its dependants with no completion left to ask again.
+   */
   readonly running: readonly TaskNode[]
   /** The run's worker count — the ceiling the count gate already applies. */
   readonly concurrency: number
@@ -440,7 +445,8 @@ function pluginPackageName(dir: string): string {
   for (let d = dir; ;) {
     let text: string | undefined
     try {
-      text = readFileSync(path.join(d, 'package.json'), 'utf8')
+      // A byte-order mark is stripped, as npm, Node and discovery strip it.
+      text = readFileSync(path.join(d, 'package.json'), 'utf8').replace(/^\uFEFF/, '')
     } catch {
       /* not here; look one level up */
     }
@@ -600,7 +606,8 @@ export async function installPlugins(args: InstallPluginsArgs): Promise<() => vo
   const { plugins, bus, workspaceRoot, cacheDir } = args
   const warn = args.warn ?? ((m) => console.error(m))
   const disposers: Array<() => void> = []
-  const disabled = new Set<string>()
+  // By object, not name: one package can export two plugins.
+  const disabled = new Set<Plugin>()
 
   for (const plugin of plugins) {
     if (typeof plugin.name !== 'string' || plugin.name.length === 0) {
@@ -614,6 +621,13 @@ export async function installPlugins(args: InstallPluginsArgs): Promise<() => vo
       throw new UserError(`plugin '${plugin.name}' setup is not a function`)
     }
 
+    const fail = (where: string, err: unknown): void => {
+      if (disabled.has(plugin)) return
+      disabled.add(plugin)
+      warn(
+        `[vx] plugin '${plugin.name}' threw in ${where}; disabled for this run: ${err instanceof Error ? err.message : String(err)}`,
+      )
+    }
     const ctx: PluginContext = {
       workspaceRoot,
       cacheDir,
@@ -624,7 +638,18 @@ export async function installPlugins(args: InstallPluginsArgs): Promise<() => vo
       bus: {
         emit: (event) => bus.emit(event),
         subscribe(subscriber) {
-          const dispose = bus.subscribe(subscriber)
+          // Isolated like an `on` handler: the bus itself swallows a throw.
+          const dispose = bus.subscribe((event) => {
+            if (disabled.has(plugin)) return
+            let ret: unknown
+            try {
+              ret = subscriber(event)
+            } catch (err) {
+              fail('a bus subscriber', err)
+              return
+            }
+            if (ret instanceof Promise) ret.catch((err: unknown) => fail('a bus subscriber', err))
+          })
           disposers.push(dispose)
           return dispose
         },
@@ -637,15 +662,9 @@ export async function installPlugins(args: InstallPluginsArgs): Promise<() => vo
             `ctx.on: unknown hook '${String(hook)}' (one of ${Object.keys(HOOK_NAMES).join(', ')})`,
           )
         }
-        const fail = (err: unknown): void => {
-          if (disabled.has(plugin.name)) return
-          disabled.add(plugin.name)
-          warn(
-            `[vx] plugin '${plugin.name}' threw in ${hook}; disabled for this run: ${err instanceof Error ? err.message : String(err)}`,
-          )
-        }
+        const onFail = (err: unknown): void => fail(hook, err)
         const dispose = bus.subscribe((event) => {
-          if (disabled.has(plugin.name)) return
+          if (disabled.has(plugin)) return
           // Not awaited: the bus is synchronous and plugin work runs off the
           // critical path. A handler's rejection is caught like its throw.
           let ret: unknown
@@ -680,10 +699,10 @@ export async function installPlugins(args: InstallPluginsArgs): Promise<() => vo
                 break
             }
           } catch (err) {
-            fail(err)
+            onFail(err)
             return
           }
-          if (ret instanceof Promise) ret.catch(fail)
+          if (ret instanceof Promise) ret.catch(onFail)
         })
         disposers.push(dispose)
       },
@@ -692,6 +711,9 @@ export async function installPlugins(args: InstallPluginsArgs): Promise<() => vo
     try {
       await plugin.setup(ctx)
     } catch (err) {
+      // Earlier plugins' subscriptions too: the caller never gets the
+      // disposer, and a bus that outlives the run would keep them.
+      for (const d of disposers) d()
       throw new PluginSetupError(
         plugin,
         `plugin '${plugin.name}' failed in setup: ${err instanceof Error ? err.message : String(err)}`,

package/src/orchestrator/prepare.ts

@@ -368,8 +368,11 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
     ? options.projects.filter((p) => projects.has(p))
     : [...projects.keys()]
 
-  const requested = expandRequested(tasks, candidateProjects, projects)
-  let unresolvedTasks = unresolvedRequests(tasks, candidateProjects, projects)
+  // A bare name skips the default `build`: it runs nothing, and matched,
+  // `vx run build` in a project declaring none ran 0 tasks, exit 0 (X-102).
+  // A dependant's `^build` still reaches it, and `lib#build` names it.
+  const requested = expandRequested(tasks, candidateProjects, projects, isDefaultBuild)
+  let unresolvedTasks = unresolvedRequests(tasks, candidateProjects, projects, isDefaultBuild)
   if (options.selectedByDiff === true && unresolvedTasks.some((t) => !t.includes('#'))) {
     // A name a loaded project declares is no typo, whether or not the load
     // was whole: an unaffected dependency loaded for the closure declared
@@ -750,14 +753,20 @@ async function declaredNowhere(
   return undeclaredIn(unresolved, all.projects)
 }
 
-/** The bare names in `unresolved` no project in `projects` declares; `a#b` forms pass through. */
+/**
+ * The bare names in `unresolved` no project in `projects` declares; `a#b`
+ * forms pass through. Every project has a `build`, its default one if
+ * nothing declares it, and a bare name does not select that (X-102).
+ */
 function undeclaredIn(
   unresolved: readonly string[],
   projects: LoadedProjects['projects'],
 ): string[] {
   const declared = new Set<string>()
   for (const p of projects.values()) {
-    for (const t of Object.keys(p.config.tasks ?? {})) declared.add(t)
+    for (const [t, task] of Object.entries(p.config.tasks ?? {})) {
+      if (!isDefaultBuild(task)) declared.add(t)
+    }
   }
   return unresolved.filter((t) => t.includes('#') || !declared.has(t))
 }

package/src/orchestrator/run-artifacts.ts

@@ -18,6 +18,7 @@ import { isGroupTask, type TaskOutcome } from '../graph/index.js'
 import { tallyOutcomes, type Tally } from './tally.js'
 import type { FlakyFinding } from './failure-mode.js'
 import { isCacheHit } from './telemetry.js'
+import { ranNoCache } from './events.js'
 
 export interface SummarizeArgs {
   /** Empty string → default path; otherwise the explicit file path. */
@@ -92,7 +93,7 @@ function taskEntry(o: TaskOutcome, flaky?: FlakyFinding): SummaryTaskJson {
     // the flag a consumer computing a hit rate cannot tell a miss from a
     // task that could never hit (its `hash` is still set — dependents fold
     // it). Present only when true, so every other row is byte-identical.
-    ...(o.node.config.cache === undefined ? { noCache: true } : {}),
+    ...(ranNoCache(o) ? { noCache: true } : {}),
     // Present only when the run proved the task flaky: this exact key has
     // both passed and failed on record (this run counted), or the task
     // needed a retry. A consumer gating on `failed` can tell a break from a