@vzn/vx 0.0.652 → 0.0.653

package/src/cli/index.ts

@@ -43,12 +43,21 @@ export async function run(argv: readonly string[]): Promise<number> {
     await printHelp(await (await plugins()).pluginCommandHelp(), command)
     return 0
   }
+  if (command !== undefined && forwardsNothing(command, rest)) {
+    return refuse(
+      command,
+      rest,
+      'forwards nothing after -- (only vx run and vx watch pass arguments on to a task)',
+      'VX_E_USAGE',
+    )
+  }
   // Each setting's variable once, before any verb: a renamed one is named,
   // and a deep reader trusts what it reads. Not for help, as `vx run
   // --help` above is not: help is where a setting's values are read. Nor
-  // for `vx info`, which reports a refused one (doctor.ts).
+  // for `vx info`, which reports a refused one (doctor.ts). Nor for one
+  // whose flag is given: the flag beats it.
   if (command !== 'help' && command !== '--help' && command !== '-h' && command !== 'info')
-    checkSettingsEnv()
+    checkSettingsEnv(process.env, rest)
 
   try {
     return await dispatch(command, rest)
@@ -93,6 +102,21 @@ function refuseControlArgs(command: string, rest: readonly string[]): void {
   }
 }
 
+/**
+ * A `--` given to a core verb that hands no task its words: each parser
+ * refused it as `unknown flag: --`, true of no flag. A `--sql` query is
+ * the one value that may be `--`.
+ */
+function forwardsNothing(command: string, rest: readonly string[]): boolean {
+  if (command === 'run' || command === 'watch') return false
+  if (!(CORE_VERBS as readonly string[]).includes(command)) return false
+  for (let i = 0; i < rest.length; i++) {
+    if (rest[i] === '--sql') i++
+    else if (rest[i] === '--') return true
+  }
+  return false
+}
+
 /**
  * A crash from a hand-broken lock entry is that entry's fault: runs validate
  * no entry, so it surfaced as a raw TypeError (2026-10-14). The lock is
@@ -148,7 +172,9 @@ async function dispatch(command: string | undefined, rest: string[]): Promise<nu
         // A name that is no verb here is the typo `vx rnu` is, not a request
         // for the whole reference: it printed 145 lines and no hint.
         const resolved = await (await plugins()).resolvePluginCommand(verb)
-        const unknown = resolved === null || 'declaredVerbs' in resolved
+        // A workspace that failed to load cannot say the verb exists: the
+        // whole reference and exit 0 hid the broken file (`vx okk` says so).
+        const unknown = resolved === null || !('plugin' in resolved)
         if (unknown && verb.startsWith('-')) {
           return refuse(
             'help',
@@ -158,15 +184,20 @@ async function dispatch(command: string | undefined, rest: string[]): Promise<nu
           )
         }
         if (unknown) {
-          const declared = resolved === null ? [] : resolved.declaredVerbs
+          const declared =
+            resolved !== null && 'declaredVerbs' in resolved ? resolved.declaredVerbs : []
+          const loadNote =
+            resolved !== null && 'loadError' in resolved
+              ? ` (plugin verbs could not be looked up: .vx/workspace failed to load: ${resolved.loadError})`
+              : ''
           return refuse(
             'help',
             rest,
-            `unknown command: ${verb}${didYouMeanVerb(verb, declared)} (see \`vx help\`)`,
+            `unknown command: ${verb}${didYouMeanVerb(verb, declared)}${loadNote} (see \`vx help\`)`,
             'VX_E_UNKNOWN_COMMAND',
           )
         }
-        if (resolved !== null && !('loadError' in resolved)) return dispatch(verb, ['--help'])
+        return dispatch(verb, ['--help'])
       }
       await printHelp(await (await plugins()).pluginCommandHelp(), core ? verb : undefined)
       return 0
@@ -239,7 +270,7 @@ async function dispatch(command: string | undefined, rest: string[]): Promise<nu
         // that returned 256 (a count of failures, say) exited 0.
         if (!Number.isInteger(code) || code < 0 || code > 255) {
           throw new UserError(
-            `plugin '${resolved.plugin.name}': command '${command}' resolved ${JSON.stringify(code)} instead of an exit code (an integer 0–255)`,
+            `plugin '${resolved.plugin.name}': command '${command}' resolved ${typeof code === 'bigint' ? `${String(code)}n` : typeof code === 'number' || code === undefined ? String(code) : JSON.stringify(code)} instead of an exit code (an integer 0–255)`,
           )
         }
         return code

package/src/cli/info.ts

@@ -101,7 +101,7 @@ function infoReport(f: InfoFacts): ui.Block {
     ],
     ['cache versions', `keys ${f.cacheVersion} · index schema ${f.schemaVersion}`],
     ['cache entries', describeEntries(f)],
-    // Only the settings a variable or the workspace changed.
+    // Only the settings a variable, the workspace or a plugin changed.
     ...(Object.values(f.settings).some((s) => s.source !== 'default')
       ? ([['settings', describeSettings(f.settings)]] as [string, string][])
       : []),
@@ -141,14 +141,15 @@ function describeEntries(f: InfoFacts): string {
 
 /**
  * The settings not at their default, with where each came from:
- * `run.timeout 30m (VX_RUN_TIMEOUT), cache.policy local:rw (.vx/workspace)`.
+ * `run.timeout 30m (VX_RUN_TIMEOUT), cache.policy local:rw (.vx/workspace)`,
+ * `cache.scope pr-2 (plugin @org/ci)`.
  */
 function describeSettings(settings: InfoFacts['settings']): string {
   return Object.entries(settings)
     .filter(([, s]) => s.source !== 'default')
     .map(
       ([path, s]) =>
-        `${path} ${String(s.value)} (${s.source === 'env' ? envName(path) : '.vx/workspace'}${s.refused === undefined ? '' : `, refused: ${s.refused}`})`,
+        `${path} ${String(s.value)} (${s.source === 'env' ? envName(path) : s.source === 'plugin' ? `plugin ${s.plugin}` : '.vx/workspace'}${s.refused === undefined ? '' : `, refused: ${s.refused}`})`,
     )
     .join(', ')
 }

package/src/cli/init.ts

@@ -6,7 +6,7 @@
 // `vx init --plugin <hook>` writes a runnable plugin for one hook and its
 // test instead (plugin-templates.ts, the examples the gate runs).
 
-import { existsSync, readFileSync } from 'node:fs'
+import { existsSync, lstatSync, readFileSync, statSync } from 'node:fs'
 import { mkdir, unlink } from 'node:fs/promises'
 import path from 'node:path'
 import { gitTop, workspaceFileWritten } from '../handoff.js'
@@ -132,11 +132,17 @@ export async function initCmd(args: readonly string[]): Promise<number> {
     dirs.push(d)
     if (d === top || path.dirname(d) === d) break
   }
-  if (dirs.some((d) => TOOL_CONFIGS.some((f) => existsSync(path.join(d, f))))) {
+  const pkgRoot = packageRoot(dirs, top !== null)
+  // Outside git `dirs` reach `/`: a stray turbo.json or nx.json above the
+  // project took init over, as a stray package.json did (2026-10-28).
+  const own = top !== null ? dirs : dirs.slice(0, dirs.indexOf(pkgRoot ?? cwd) + 1)
+  if (own.some((d) => TOOL_CONFIGS.some((f) => existsSync(path.join(d, f))))) {
     return migrate(dirs, parsed)
   }
-  const pkgRoot = packageRoot(dirs, top !== null)
-  return starter(marked ?? pkgRoot ?? cwd, pkgRoot, top === null, parsed)
+  // Asked of git itself: a kept workspace file is `top` too, and the
+  // `git init` hint went missing where the next run would refuse.
+  const noGit = marked === undefined ? top === null : (await gitTop(cwd)) === null
+  return starter(marked ?? pkgRoot ?? cwd, pkgRoot, noGit, parsed)
 }
 
 /**
@@ -314,6 +320,20 @@ function ownerNamed(dir: string): boolean {
   }
 }
 
+/**
+ * Whether anything stands at `file`, a dangling symlink included: writing
+ * through one created its target outside the workspace.
+ */
+function occupied(file: string): boolean {
+  try {
+    lstatSync(file)
+    return true
+  } catch {
+    // quiet: nothing there (a parent that is a file is refused at the write)
+    return false
+  }
+}
+
 /** Write `plugins/<seam>.ts` and its test under `root`: the workspace root, else the cwd. */
 async function scaffoldPlugin(seam: string, root: string, args: InitArgs): Promise<number> {
   const template = PLUGIN_TEMPLATES[seam]!
@@ -329,13 +349,14 @@ async function scaffoldPlugin(seam: string, root: string, args: InitArgs): Promi
   ] as const
   if (!args.force) {
     for (const [rel] of files) {
-      if (await Bun.file(path.join(root, rel)).exists()) {
+      if (occupied(path.join(root, rel))) {
         sayNotice('error', 'vx init', `${rel} exists. --force overwrites it`)
         return 1
       }
     }
   }
   if (!args.dry) {
+    for (const [rel] of files) refuseSymlink(path.join(root, rel), root)
     await mkdir(path.join(root, 'plugins'), { recursive: true }).catch(
       (err: NodeJS.ErrnoException) => {
         if (err.code !== 'EEXIST' && err.code !== 'ENOTDIR') throw err
@@ -344,7 +365,7 @@ async function scaffoldPlugin(seam: string, root: string, args: InitArgs): Promi
         )
       },
     )
-    for (const [rel, text] of files) await Bun.write(path.join(root, rel), text)
+    for (const [rel, text] of files) await writeNoFollow(path.join(root, rel), text, root)
   }
   const factory = /^export function (\w+)/m.exec(template.plugin)![1]!
   const workspaceFile =
@@ -423,7 +444,7 @@ async function starter(
 ): Promise<number> {
   if (args.mode !== undefined) {
     throw new UserError(
-      `vx init: --${args.mode} answers a Turbo or Nx repo's question, and there is no turbo.json or nx.json here`,
+      `vx init: --${args.mode} answers a Turbo or Nx workspace's question, and there is no turbo.json or nx.json here`,
       'VX_E_USAGE',
     )
   }
@@ -450,11 +471,20 @@ async function starter(
     ],
     [PROJECT_CONFIG_FILENAMES, config, starterProject(ext)],
   ] as const) {
-    const existing = names.find((n) => existsSync(path.join(root, n)))
-    if (existing !== undefined && !args.force) kept.push(existing)
+    const existing = names.filter((n) => existsSync(path.join(root, n)))
+    // Kept, a directory read as the workspace's marker, and every verb after
+    // then found none and sent the user back here.
+    const dir = existing.find((n) => statSync(path.join(root, n)).isDirectory())
+    if (dir !== undefined) {
+      throw new UserError(
+        `vx init: ${dir} is a directory, where the ${name === config ? 'project config' : 'workspace file'} goes; move it and re-run`,
+      )
+    }
+    if (existing.length > 0 && !args.force) kept.push(existing[0]!)
     else {
       files.push({ path: name, contents })
-      if (existing !== undefined && existing !== name) replaced.push(existing)
+      // Every other name goes too: a second config beside the one written.
+      replaced.push(...existing.filter((n) => n !== name))
     }
   }
   // vx's own housekeeping, as a run's first cache open and `vx lock` write them.
@@ -465,7 +495,10 @@ async function starter(
     if (!existsSync(path.join(root, name))) files.push({ path: name, contents })
   }
   const declare = `declare a task in ${kept.find((f) => f.startsWith('vx.config.')) ?? config}, then vx lock && vx run <task>`
-  const next = `${noGit ? 'git init, ' : ''}${hasScripts(pkgRoot) ? `bunx @vzn/vx-migrate${args.mjs ? ' --mjs' : ''} to make package.json scripts tasks, or ${declare}` : declare}`
+  // Run in the cwd, a git init below the root it chose hides the workspace from every verb.
+  const gitInit =
+    root === process.cwd() ? 'git init' : `git init ${path.relative(process.cwd(), root)}`
+  const next = `${noGit ? `${gitInit}, ` : ''}${hasScripts(pkgRoot) ? `bunx @vzn/vx-migrate${args.mjs ? ' --mjs' : ''} to make package.json scripts tasks, or ${declare}` : declare}`
   if (args.json === true) {
     ui.data(
       'out',
@@ -473,7 +506,7 @@ async function starter(
     )
     return 0
   }
-  const rows: ui.FieldRow[] = [['from', 'no turbo.json or nx.json: one project, the root']]
+  const rows: ui.FieldRow[] = [['from', 'no turbo.json or nx.json']]
   // The files are root-relative: a root above the cwd is named, or they read as written here.
   if (root !== process.cwd()) rows.push(['root', root])
   if (args.dry) rows.push(['dry run', 'nothing written'])
@@ -486,17 +519,19 @@ async function starter(
     ui.print('out', ui.report(`vx init ${VERSION}`, [...rows, null, ['next', next]]))
     return 0
   }
-  for (const f of files) refuseSymlink(path.join(root, f.path))
+  for (const f of files) refuseSymlink(path.join(root, f.path), root)
   const ran = await install(pkgRoot, false, plugins)
   if (ran.length > 0) rows.push(['installed', ...ran])
   for (const f of files) {
-    await writeNoFollow(path.join(root, f.path), f.contents).catch((err: NodeJS.ErrnoException) => {
-      // writeNoFollow's mkdir of a parent that is a file says EEXIST.
-      if (err.code !== 'ENOTDIR' && err.code !== 'EEXIST') throw err
-      throw new UserError(
-        `vx init: cannot write ${f.path}: ${path.dirname(f.path)} is a file, not a directory; move it and re-run`,
-      )
-    })
+    await writeNoFollow(path.join(root, f.path), f.contents, root).catch(
+      (err: NodeJS.ErrnoException) => {
+        // writeNoFollow's mkdir of a parent that is a file says EEXIST.
+        if (err.code !== 'ENOTDIR' && err.code !== 'EEXIST') throw err
+        throw new UserError(
+          `vx init: cannot write ${f.path}: ${path.dirname(f.path)} is a file, not a directory; move it and re-run`,
+        )
+      },
+    )
   }
   for (const f of replaced) await unlink(path.join(root, f))
   // The lock that follows loads the workspace file just written.

package/src/cli/last.ts

@@ -2,11 +2,12 @@
 // without re-executing anything. Comparison gap #12: with the dashboard's
 // run-detail page gone (the 2026-08-23 cloud removal), the local run
 // history in cache.db is the only replay surface, and this verb reads it.
-// Read-only — no config evaluation, no re-hash, no cache probe.
+// Read-only — no config evaluation, no re-hash, no cache probe; `--stats`
+// reads the lock only for each task's definition.
 
 import type { Database } from 'bun:sqlite'
 import { indexDb, Cache, keptSteps, keptWarnings, type RunStep } from '../cache/index.js'
-import { formatBytes } from './format.js'
+import { buildTaskGraph, expandRequested, isDefaultBuild, taskDefinitions } from '../graph/index.js'
 import { flagHint, formatValue, seeHelp } from './help.js'
 import {
   type FailureMode,
@@ -18,7 +19,9 @@ import {
   type RunSummaryRow,
 } from '../history/index.js'
 import {
+  applyGraphStage,
   currentBranch,
+  hasHook,
   type LiveSnapshot,
   liveSocketPath,
   exitSignal,
@@ -28,7 +31,13 @@ import {
   shortRunId,
   taskLog,
 } from '../orchestrator/index.js'
-import { formatRecordedRow, outcomeWord, taskList, type WireEvent } from '../report/index.js'
+import {
+  formatRecordedRow,
+  formatSize,
+  outcomeWord,
+  taskList,
+  type WireEvent,
+} from '../report/index.js'
 import {
   formatElapsed,
   nearest,
@@ -39,9 +48,18 @@ import {
 } from '../util/index.js'
 import * as ui from '../ui/index.js'
 import { sayNotice } from '../ui/index.js'
-import { findWorkspaceRoot } from '../workspace/index.js'
+import { runRules } from '../settings.js'
+import { buildPackageGraph, findWorkspaceRoot } from '../workspace/index.js'
 import { findCwdProject } from './select.js'
-import { cliCacheDir, parseCacheDirFlag, rootSpelled } from './workspace-config.js'
+import {
+  cliCacheDir,
+  discoverCliProjects,
+  loadCliProjects,
+  loadCliWorkspace,
+  parseCacheDirFlag,
+  rootSpelled,
+  stageCacheDir,
+} from './workspace-config.js'
 
 interface LastArgs {
   runId?: string
@@ -68,6 +86,9 @@ interface LastArgs {
   error?: string
 }
 
+/** The run grid's mark for a number history does not hold. */
+const UNKNOWN = '\u2014'
+
 /**
  * A run id as typed beside `--list`: a UUIDv7's first group (8 hex digits)
  * at least, whole or cut as `--list` prints it.
@@ -127,10 +148,16 @@ export function parseLastArgs(args: readonly string[]): LastArgs {
     }
     if (a === '--sql' || a.startsWith('--sql=')) {
       const v = a === '--sql' ? args[++i] : a.slice('--sql='.length)
-      if (v === undefined || v.trim() === '') {
+      // The space form took the next flag as the query, then blamed that
+      // flag for combining with --sql.
+      const flag =
+        a === '--sql' && v?.startsWith('-') === true
+          ? ` (got flag ${v}; a query that starts with - needs --sql=${v})`
+          : ''
+      if (v === undefined || v.trim() === '' || flag !== '') {
         return {
           ...out,
-          error: `--sql requires a query, like 'SELECT * FROM runs'${seeHelp('last')}`,
+          error: `--sql requires a query, like 'SELECT * FROM runs'${flag}${seeHelp('last')}`,
         }
       }
       out.sql = v
@@ -276,18 +303,71 @@ export interface TaskStats {
   maxCpuParallelism: number | null
 }
 
+/**
+ * Each task's definition (`taskDefinitions`) as a run builds the graph
+ * now: the lock's configs with the `project` and `graph` stages applied.
+ * Undefined when none loads (no lock, a broken config): then every
+ * definition's rows are read, as before definitions were kept.
+ */
+async function definitionsNow(
+  root: string,
+  cacheDir: string | undefined,
+): Promise<Map<string, string> | undefined> {
+  try {
+    // A plugin's warning is the run's to say, not a history read's.
+    const opts = { warn: () => {}, ...(cacheDir === undefined ? {} : { cacheDir }) }
+    const metas = await discoverCliProjects(root)
+    const projects = await loadCliProjects(root, metas, 'all', opts)
+    const ws = await loadCliWorkspace(root, opts.warn)
+    const rules = runRules(ws.workspaceConfig)
+    const names = new Set<string>()
+    for (const p of projects.values())
+      for (const t of Object.keys(p.config.tasks ?? {})) names.add(t)
+    const nodes = buildTaskGraph({
+      projects,
+      packageGraph: buildPackageGraph(metas),
+      requested: expandRequested([...names], [...projects.keys()], projects, isDefaultBuild),
+      workspaceRoot: root,
+      rules,
+    })
+    if (hasHook(ws.plugins, 'graph'))
+      await applyGraphStage(ws.plugins, nodes, {
+        workspaceRoot: root,
+        cacheDir: stageCacheDir(ws, opts),
+        projectMetas: metas,
+        warn: opts.warn,
+        rules,
+      })
+    return taskDefinitions(nodes.values())
+  } catch {
+    return undefined
+  }
+}
+
+/** Each task's definition as run `runId` recorded it: what its live rows read history by. */
+function runDefinitions(db: Database, runId: string): Map<string, string> {
+  const rows = db
+    .query(
+      `SELECT r.project, r.task, r.def FROM main.runs r JOIN main.run_ids k ON k.id = r.run
+       WHERE k.run_id = ? AND r.def IS NOT NULL`,
+    )
+    .all(runId) as { project: string; task: string; def: string }[]
+  return new Map(rows.map((r) => [`${r.project}#${r.task}`, r.def]))
+}
+
 /**
  * `--stats`: what the scheduler and `--dry` learn from history, per task,
  * over the same window (`LocalHistoryProvider`), with the p50 a run on
- * `branch` forecasts.
+ * `branch` forecasts from the timings of each task's definition `defs`.
  */
 async function printStats(
   db: Database,
   target: string | undefined,
   format: 'pretty' | 'json',
   branch: string | null,
+  defs: ReadonlyMap<string, string> | undefined,
 ): Promise<number> {
-  const provider = new LocalHistoryProvider(db, undefined, branch)
+  const provider = new LocalHistoryProvider(db, undefined, branch, defs)
   const matches = (id: string): boolean =>
     target === undefined || (target.includes('#') ? id === target : splitTaskId(id)[1] === target)
   const stats: TaskStats[] = [...(await provider.loadAll())]
@@ -319,7 +399,9 @@ async function printStats(
     return 0
   }
   const pct = (r: number): string => `${Math.round(r * 100)}%`
-  const ms = (v: number | null): string => (v === null ? '-' : fmtMs(v))
+  // The run grid's units and its unknown mark, so one number reads alike
+  // in both: cpu `127%` (was `1.3×`), mem `3.6MB` (was `3.6 MB`), `—`.
+  const ms = (v: number | null): string => (v === null ? UNKNOWN : fmtMs(v))
   const right = (title: string): ui.Column => ({ title, align: 'right' })
   ui.print(
     'out',
@@ -345,8 +427,8 @@ async function printStats(
           pct(s.successRate),
           pct(s.hitRate),
           s.failureMode,
-          s.maxPeakRssBytes === null ? '-' : formatBytes(s.maxPeakRssBytes),
-          s.maxCpuParallelism === null ? '-' : `${s.maxCpuParallelism.toFixed(1)}×`,
+          s.maxPeakRssBytes === null ? UNKNOWN : formatSize(s.maxPeakRssBytes),
+          s.maxCpuParallelism === null ? UNKNOWN : pct(s.maxCpuParallelism),
         ]),
       ),
     ),
@@ -373,7 +455,8 @@ function printQuery(db: Database, sql: string, format: 'pretty' | 'json'): numbe
   db.exec('PRAGMA query_only = ON')
   const refused = (err: unknown): never => {
     const message = err instanceof Error ? err.message : String(err)
-    if (/readonly|query_only/i.test(message)) {
+    // `runs` is a view: a write to it fails before query_only is asked.
+    if (/readonly|query_only|cannot modify/i.test(message)) {
       throw new UserError(`vx last: --sql reads only: ${message}`, 'VX_E_USAGE')
     }
     throw new UserError(`vx last: --sql: ${message}`, 'VX_E_USAGE')
@@ -714,9 +797,19 @@ export function formatTaskRows(
   // The run's own grid (`taskList`): a replay reads as the run did. What
   // the run said below the row (an exit, why it skipped) rides it dim.
   const rows = ordered.map((t) => {
+    // A cached failure with no cache outcome is a hit whose restore failed: no
+    // exit. One whose command exited 0 failed in its save (a server that
+    // exited 0 before ready says so in its reason).
+    const failure =
+      t.status !== 'failed'
+        ? ''
+        : t.cached === true && t.cacheHit === null
+          ? 'cache restore failed'
+          : t.exitCode === 0 && t.notReady === null
+            ? 'cache save failed'
+            : `exit ${t.exitCode}`
     const note = (
-      (t.status === 'failed' ? `exit ${t.exitCode}` : '') +
-      reasonParts(t, skippedHere, inputMoved.get(`${t.project}#${t.task}`))
+      failure + reasonParts(t, skippedHere, inputMoved.get(`${t.project}#${t.task}`))
     ).trim()
     const id = `${t.project}#${t.task}`
     const usualMs = usual === undefined ? undefined : (usual.get(id) ?? null)
@@ -798,7 +891,9 @@ export function formatRunList(
 async function bareTaskId(db: Database, task: string): Promise<string> {
   if (task.includes('#')) return task
   const ids = (
-    db.query('SELECT DISTINCT project FROM runs WHERE task = ? ORDER BY project').all(task) as {
+    db
+      .query('SELECT DISTINCT project FROM main.runs WHERE task = ? ORDER BY project')
+      .all(task) as {
       project: string
     }[]
   ).map((r) => `${r.project}#${task}`)
@@ -831,7 +926,13 @@ export async function lastCmd(args: readonly string[]): Promise<number> {
     if (parsed.stats === true) {
       const branch = currentBranch(root, undefined, parsed.branch)
       const task = parsed.task === undefined ? undefined : await rootSpelled(root, parsed.task)
-      return await printStats(db, task, parsed.format, branch)
+      return await printStats(
+        db,
+        task,
+        parsed.format,
+        branch,
+        await definitionsNow(root, parsed.cacheDir),
+      )
     }
 
     if (parsed.log !== undefined) {
@@ -844,19 +945,22 @@ export async function lastCmd(args: readonly string[]): Promise<number> {
         // The id's form is hinted only when it lacks one: a task that
         // never ran was told how to spell a task id. A typo of one that
         // ran is named, as `vx why` names it.
-        const ran = parsed.log.includes('#')
-          ? nearest(
-              parsed.log,
-              (
-                db.query('SELECT DISTINCT project, task FROM runs').all() as {
-                  project: string
-                  task: string
-                }[]
-              ).map((r) => `${r.project}#${r.task}`),
-            )
-          : undefined
+        const recorded = parsed.log.includes('#')
+          ? new LocalHistoryProvider(db).recentTaskIds()
+          : []
+        const ran = nearest(parsed.log, recorded)
+        // No near name: what of that project has run, so the next try is a pick.
+        const project = parsed.log.slice(0, parsed.log.lastIndexOf('#') + 1)
+        const theirs = recorded
+          .filter((id) => project !== '' && id.startsWith(project))
+          .map((id) => id.slice(project.length))
+          .sort()
+        const listed =
+          ran === undefined && theirs.length > 0
+            ? `; ${project.slice(0, -1)}'s recorded tasks: ${theirs.join(', ')}`
+            : ''
         throw new UserError(
-          `vx last: no recorded run of ${parsed.log}${parsed.runId === undefined ? '' : ` in run ${parsed.runId}`}${parsed.log.includes('#') ? '' : ' (a task id is project#task)'}${ran === undefined ? '' : ` — did you mean ${ran}?`}`,
+          `vx last: no recorded run of ${parsed.log}${parsed.runId === undefined ? '' : ` in run ${parsed.runId}`}${parsed.log.includes('#') ? '' : ' (a task id is project#task)'}${ran === undefined ? '' : ` — did you mean ${ran}?`}${listed}`,
           'VX_E_NO_HISTORY',
         )
       }
@@ -865,8 +969,9 @@ export async function lastCmd(args: readonly string[]): Promise<number> {
         return 0
       }
       if (log.source === null) {
-        // A cached task with no entry was not saved (a read-only policy) or
-        // was pruned; calling it uncached sends the user to the config.
+        // A cached task with no entry of its own was not saved (a read-only
+        // policy, a `--force` run that kept the entry it found), or its entry
+        // was pruned or saved over; calling it uncached sends the user to the config.
         const [project, task] = splitTaskId(log.taskId)
         const cached =
           log.status !== 'failed' &&
@@ -875,14 +980,27 @@ export async function lastCmd(args: readonly string[]): Promise<number> {
               .query('SELECT cached FROM runs WHERE run_id = ? AND project = ? AND task = ?')
               .get(log.runId, project, task) as { cached: number | null } | null
           )?.cached === 1
+        // A skip ran nothing: the output to read is its blocker's.
+        const blocker =
+          log.status === 'skipped'
+            ? (
+                db
+                  .query(
+                    'SELECT blocked_by AS b FROM runs WHERE run_id = ? AND project = ? AND task = ?',
+                  )
+                  .get(log.runId, project, task) as { b: string | null } | null
+              )?.b
+            : null
         sayNotice(
           'info',
           'vx last',
-          log.status === 'failed'
-            ? `${log.taskId} ended failed, and vx kept no output for it: it keeps the newest 50 failed runs`
-            : cached
-              ? `${log.taskId} ended ${log.status}, and its entry is not in the cache: the run did not save it, or it was pruned since`
-              : `${log.taskId} ended ${log.status}. vx keeps output only for failed and cached tasks`,
+          typeof blocker === 'string'
+            ? `${log.taskId} did not run: ${blocker} blocked it (vx last --log ${blocker})`
+            : log.status === 'failed'
+              ? `${log.taskId} ended failed, and vx kept no output for it: it keeps the newest 50 failed runs`
+              : cached
+                ? `${log.taskId} ended ${log.status}, and the cache does not hold its output: the run did not save it, or it was pruned or saved over since`
+                : `${log.taskId} ended ${log.status}. vx keeps output only for failed and cached tasks`,
         )
       } else if (log.output === '') {
         sayNotice('info', 'vx last', `${log.taskId} ended ${log.status} and printed nothing`)
@@ -917,18 +1035,34 @@ export async function lastCmd(args: readonly string[]): Promise<number> {
       return 0
     }
 
+    const named = parsed.runId === undefined ? null : resolveRunId(db, parsed.runId, 'vx last')
     const inv =
       parsed.runId !== undefined
-        ? getInvocation(db, resolveRunId(db, parsed.runId, 'vx last') ?? parsed.runId)
+        ? getInvocation(db, named ?? parsed.runId)
         : parsed.failed === true
           ? (failedInvocations(db, 1)[0] ?? null)
           : (listInvocations(db, { limit: 1 })[0] ?? null)
+    // A run with rows and no header is one a stop ended (item 854): `vx why`
+    // printed its id, so it is named, not called unrecorded.
+    if (named !== null && (inv === null || inv === undefined)) {
+      throw new UserError(
+        `vx last: run ${named} was stopped before it finished, so vx kept its tasks but no summary: \`vx last ${named} --log <task>\` prints one's output`,
+        'VX_E_NO_HISTORY',
+      )
+    }
     if ((inv === null || inv === undefined) && noRuns()) {
       throw refusal(
         { tone: 'info', headline: 'no runs yet', fix: 'vx run' },
         { code: 'VX_E_NO_HISTORY', message: 'vx last: no recorded runs yet — run something first' },
       )
     }
+    // Nothing failed is no fault: said as `--list --failed` says it.
+    if ((inv === null || inv === undefined) && parsed.failed === true) {
+      throw refusal(
+        { tone: 'info', headline: 'no failed runs', fix: 'vx last' },
+        { code: 'VX_E_NO_HISTORY', message: 'vx last: no failed runs' },
+      )
+    }
     if (inv === null || inv === undefined) {
       throw new UserError(
         noRuns()
@@ -937,9 +1071,7 @@ export async function lastCmd(args: readonly string[]): Promise<number> {
             ? `vx last: ${parsed.runId} is a task, not a run id — \`vx last --log ${parsed.runId}\` prints its output, \`vx last --stats ${parsed.runId}\` its durations`
             : parsed.runId !== undefined
               ? `vx last: no recorded run ${parsed.runId} (vx last --list shows recent runs)`
-              : parsed.failed === true
-                ? 'vx last: no recorded run failed'
-                : 'vx last: no recorded runs yet — run something first',
+              : 'vx last: no recorded runs yet — run something first',
         'VX_E_NO_HISTORY',
       )
     }
@@ -1007,7 +1139,18 @@ export async function lastCmd(args: readonly string[]): Promise<number> {
     const ranIds = (detail?.tasks ?? [])
       .filter((t) => t.status === 'success' || t.status === 'failed')
       .map((t) => `${t.project}#${t.task}`)
-    const usual = new LocalHistoryProvider(db, undefined, currentBranch(root)).p50sNow(ranIds)
+    // Each task's timings of the definition it ran under, as its live row
+    // read them: an older definition's timings are another task's.
+    const history = new LocalHistoryProvider(
+      db,
+      undefined,
+      currentBranch(root),
+      runDefinitions(db, inv.runId),
+    )
+    const usual = new Map(history.p50sNow(ranIds))
+    // A task whose one timing is this run's own has no usual to compare
+    // with: `+0ms` claimed a baseline the live row rightly showed as `—`.
+    for (const id of history.timedOnlySince(ranIds, inv.startedAt)) usual.delete(id)
     const taskRows = formatTaskRows(detail?.tasks ?? [], moved, usual)
     if (taskRows.length > 0)
       blocks.push(ui.section('Tasks', String(detail?.tasks.length ?? 0), ...taskRows))