@vzn/vx 0.0.651 → 0.0.653

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')
@@ -433,6 +516,15 @@ function printQuery(db: Database, sql: string, format: 'pretty' | 'json'): numbe
   return 0
 }
 
+/** `text` as JSON, or undefined where it is not. */
+function parsed(text: string): unknown {
+  try {
+    return JSON.parse(text)
+  } catch {
+    return undefined
+  }
+}
+
 /** How long a run has to answer before `--live` gives up on it. */
 const LIVE_ANSWER_MS = 5_000
 
@@ -457,18 +549,36 @@ async function printLive(
   }
   let buffered = ''
   let snapshot: LiveSnapshot | undefined
+  /** The run answered a snapshot this vx cannot read: another vx version's. */
+  let unreadable = false
   let settle!: (answered: boolean) => void
   const done = new Promise<boolean>((resolve) => (settle = resolve))
   const line = (text: string): void => {
+    if (unreadable) return
     if (snapshot === undefined) {
-      snapshot = JSON.parse(text) as LiveSnapshot
+      const s = parsed(text) as Partial<LiveSnapshot> | undefined
+      const l = s?.live
+      if (
+        typeof l?.runId !== 'string' ||
+        typeof l.command !== 'string' ||
+        typeof l.startedAt !== 'number' ||
+        typeof l.elapsedMs !== 'number' ||
+        !Array.isArray(s!.tasks) ||
+        !Array.isArray(s!.warnings)
+      ) {
+        unreadable = true
+        return settle(false)
+      }
+      snapshot = s as LiveSnapshot
       if (format === 'json') ui.data('out', `${text}\n`)
       else ui.print('out', ...formatLive(snapshot))
       return
     }
     if (format === 'json') ui.data('out', `${text}\n`)
     else {
-      const event = formatLiveEvent(JSON.parse(text) as WireEvent)
+      const e = parsed(text)
+      const event =
+        typeof e === 'object' && e !== null ? formatLiveEvent(e as WireEvent) : undefined
       if (event !== undefined) ui.print('out', event)
     }
   }
@@ -503,6 +613,11 @@ async function printLive(
     : setTimeout(() => settle(snapshot !== undefined), LIVE_ANSWER_MS)
   const answered = await done
   clearTimeout(timer)
+  if (unreadable)
+    throw refusal({
+      headline: 'the run in progress answered in a form this vx does not read',
+      fix: 'ask with the vx that started the run',
+    })
   if (!answered) none()
   return 0
 }
@@ -682,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)
@@ -766,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}`)
@@ -799,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) {
@@ -812,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',
         )
       }
@@ -833,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' &&
@@ -843,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`)
@@ -885,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()
@@ -905,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',
       )
     }
@@ -975,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))