@vzn/vx 0.0.646 → 0.0.649

package/src/cli/last.ts

@@ -19,18 +19,36 @@ import {
 } from '../history/index.js'
 import {
   currentBranch,
+  type LiveSnapshot,
+  liveSocketPath,
   exitSignal,
   resolveRunId,
   runFailures,
   type RunStep,
   runSteps,
+  runWarnings,
+  shellQuote,
   shortRunId,
   taskLog,
 } from '../orchestrator/index.js'
-import { outcomeWord } from '../report/index.js'
-import { formatElapsed, refusal, splitTaskId, UserError, sayNotice, ui } from '../util/index.js'
+import { outcomeWord, type WireEvent } from '../report/index.js'
+import {
+  detectColors,
+  ERROR,
+  formatElapsed,
+  paint,
+  parseDecimalInt,
+  refusal,
+  splitTaskId,
+  SUCCESS,
+  UserError,
+  sayNotice,
+  ui,
+  type ColorSupport,
+} from '../util/index.js'
 import { findWorkspaceRoot } from '../workspace/index.js'
-import { cliCacheDir, parseCacheDirFlag } from './workspace-config.js'
+import { findCwdProject } from './select.js'
+import { cliCacheDir, parseCacheDirFlag, rootSpelled } from './workspace-config.js'
 
 interface LastArgs {
   runId?: string
@@ -48,6 +66,12 @@ interface LastArgs {
   branch?: string
   /** `--cache-dir`: read the history a run with the same flag wrote. */
   cacheDir?: string
+  /** `--sql <query>`: the history's rows a read-only query selects. */
+  sql?: string
+  /** `--live`: the run in progress, from the run itself. */
+  live?: boolean
+  /** `--follow`: with `--live`, the run's events from now to its end. */
+  follow?: boolean
   error?: string
 }
 
@@ -77,8 +101,13 @@ export function parseLastArgs(args: readonly string[]): LastArgs {
           (!RUN_ID_SHAPE.test(next) && (!next.startsWith('-') || /^-\d/.test(next))))
       const lv = a === '--list' ? (spaced ? next : '10') : a.slice(7)
       if (spaced) i++
-      const n = Number(lv)
-      if (!Number.isInteger(n) || n < 1 || n > 500) {
+      if (lv === '')
+        return {
+          ...out,
+          error: `--list= requires a count from 1 to 500; bare --list shows 10${seeHelp('last')}`,
+        }
+      const n = parseDecimalInt(lv)
+      if (n === null || n < 1 || n > 500) {
         return {
           ...out,
           error: `--list must be a whole number from 1 to 500 (got ${lv})${seeHelp('last')}`,
@@ -95,6 +124,25 @@ export function parseLastArgs(args: readonly string[]): LastArgs {
       out.stats = true
       continue
     }
+    if (a === '--live') {
+      out.live = true
+      continue
+    }
+    if (a === '--follow') {
+      out.follow = true
+      continue
+    }
+    if (a === '--sql' || a.startsWith('--sql=')) {
+      const v = a === '--sql' ? args[++i] : a.slice('--sql='.length)
+      if (v === undefined || v.trim() === '') {
+        return {
+          ...out,
+          error: `--sql requires a query, like 'SELECT * FROM runs'${seeHelp('last')}`,
+        }
+      }
+      out.sql = v
+      continue
+    }
     if (a === '--branch' || a.startsWith('--branch=')) {
       const v = a === '--branch' ? args[++i] : a.slice('--branch='.length)
       if (v === undefined || v === '' || (a === '--branch' && v.startsWith('-'))) {
@@ -105,6 +153,9 @@ export function parseLastArgs(args: readonly string[]): LastArgs {
     }
     if (a === '--log') {
       const v = args[i + 1]
+      if (v === '') {
+        return { ...out, error: `--log requires a task id, like app#build${seeHelp('last')}` }
+      }
       if (v === undefined || v.startsWith('-')) bareLog = true
       else {
         out.log = v
@@ -135,10 +186,35 @@ export function parseLastArgs(args: readonly string[]): LastArgs {
     }
     if (a.startsWith('-'))
       return { ...out, error: `unknown flag: ${a}${flagHint('last', a)}${seeHelp('last')}` }
+    // Empty is no run id: '' is the start of every one.
+    if (a === '') continue
     if (out.runId !== undefined)
       return { ...out, error: `unexpected argument: ${a}${seeHelp('last')}` }
     out.runId = a
   }
+  if (out.follow === true && out.live !== true) {
+    return { ...out, error: `--follow needs --live${seeHelp('last')}` }
+  }
+  if (out.live === true) {
+    const other = [out.runId, out.list, out.failed, out.log, out.stats, out.branch, out.sql]
+    if (bareLog || other.some((v) => v !== undefined)) {
+      return {
+        ...out,
+        error: `--live combines only with --follow, --format and --cache-dir${seeHelp('last')}`,
+      }
+    }
+    return out
+  }
+  if (out.sql !== undefined) {
+    const other = [out.runId, out.list, out.failed, out.log, out.stats, out.branch]
+    if (bareLog || other.some((v) => v !== undefined)) {
+      return {
+        ...out,
+        error: `--sql combines only with --format and --cache-dir${seeHelp('last')}`,
+      }
+    }
+    return out
+  }
   if (bareLog) {
     if (out.runId === undefined) {
       return { ...out, error: `--log requires a task id, like app#build${seeHelp('last')}` }
@@ -266,9 +342,14 @@ async function printStats(
     ]),
   ]
   const widths = rows[0]!.map((_, c) => Math.max(...rows.map((r) => r[c]!.length)))
-  const lines = rows.map((r) =>
+  const c = detectColors(process.stdout)
+  const lines = rows.map((r, i) =>
     r
-      .map((cell, c) => cell.padEnd(widths[c]!))
+      .map((cell, col) => {
+        const padded = col === r.length - 1 ? cell : cell.padEnd(widths[col]!)
+        if (i === 0) return paint('', padded, c, { dim: true })
+        return col === 0 ? `${ui.inline(ui.id(cell), c)}${padded.slice(cell.length)}` : padded
+      })
       .join('  ')
       .trimEnd(),
   )
@@ -276,6 +357,203 @@ async function printStats(
   return 0
 }
 
+/**
+ * `--sql`: one SELECT over the history (`runs`, `invocations`, and the
+ * store's `entries`, `entry_inputs`, `task_durations`, `task_outcomes`),
+ * so an agent asks what no flag answers: a task's memory trend, the
+ * flakiest project, which input moved a key. `query_only` stops a write
+ * the statement hides (`WITH … DELETE`); it does not stop ATTACH, which
+ * creates a file, hence only SELECT or WITH may lead.
+ */
+function printQuery(db: Database, sql: string, format: 'pretty' | 'json'): number {
+  if (!/^\s*(select|with)\b/i.test(sql)) {
+    throw new UserError(
+      `vx last: --sql reads only: one SELECT (or WITH … SELECT) over the history`,
+      'VX_E_USAGE',
+    )
+  }
+  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)) {
+      throw new UserError(`vx last: --sql reads only: ${message}`, 'VX_E_USAGE')
+    }
+    throw new UserError(`vx last: --sql: ${message}`, 'VX_E_USAGE')
+  }
+  let stmt: ReturnType<Database['query']>
+  try {
+    stmt = db.query(sql)
+  } catch (err) {
+    return refused(err)
+  }
+  // SQLite prepares the first statement and drops the rest unread. Its
+  // text is the statement's own (a bound `?` expanded, hence the guard).
+  const own = stmt.toString()
+  const tail = sql.startsWith(own) ? sql.slice(own.length) : ''
+  if (tail.replace(/--[^\n]*|\/\*[^]*?\*\/|[\s;]/g, '') !== '') {
+    throw new UserError(
+      `vx last: --sql takes one statement, and ${JSON.stringify(tail.replace(/^[\s;]+/, '').trimEnd())} follows the first: run each in its own --sql`,
+      'VX_E_USAGE',
+    )
+  }
+  // Read by position: a join's `SELECT *` names `run_id` twice, and rows
+  // keyed by name kept one value per name.
+  const columns = stmt.columnNames
+  let values: unknown[][]
+  try {
+    values = stmt.values() as unknown[][]
+  } catch (err) {
+    return refused(err)
+  }
+  if (format === 'json') {
+    const twice = columns.find((c, i) => columns.indexOf(c) !== i)
+    if (twice !== undefined) {
+      throw new UserError(
+        `vx last: --sql: column ${JSON.stringify(twice)} is named twice, and a JSON row holds one value per name; name each with AS`,
+        'VX_E_USAGE',
+      )
+    }
+    const rows = values.map((v) => Object.fromEntries(columns.map((c, i) => [c, v[i]])))
+    process.stdout.write(`${JSON.stringify({ rows })}\n`)
+    return 0
+  }
+  if (values.length === 0) return 0
+  // A column's value as SQLite returns it: TEXT, a number, NULL or a BLOB.
+  const cell = (v: string | number | bigint | Uint8Array | null): string =>
+    v === null || v === undefined
+      ? '-'
+      : v instanceof Uint8Array
+        ? `<${v.length} bytes>`
+        : String(v)
+  const table = [columns, ...values.map((r) => r.map((v) => cell(v as Parameters<typeof cell>[0])))]
+  const widths = table[0]!.map((_, c) => Math.max(...table.map((r) => r[c]!.length)))
+  const lines = table.map((r) =>
+    r
+      .map((v, c) => v.padEnd(widths[c]!))
+      .join('  ')
+      .trimEnd(),
+  )
+  process.stdout.write(`${lines.join('\n')}\n`)
+  return 0
+}
+
+/** How long a run has to answer before `--live` gives up on it. */
+const LIVE_ANSWER_MS = 5_000
+
+/**
+ * `--live`: ask the run in progress (orchestrator/run-live.ts) for its
+ * snapshot, and with `--follow` print its events until it lets go. The
+ * history is not opened: the run itself answers.
+ */
+async function printLive(
+  root: string,
+  follow: boolean,
+  format: 'pretty' | 'json',
+): Promise<number> {
+  const none = (): never => {
+    throw refusal(
+      { tone: 'info', headline: 'no run in progress', fix: 'vx last' },
+      {
+        code: 'VX_E_NO_HISTORY',
+        message: 'vx last: no run in progress — `vx last` reads the last one',
+      },
+    )
+  }
+  let buffered = ''
+  let snapshot: LiveSnapshot | undefined
+  let settle!: (answered: boolean) => void
+  const done = new Promise<boolean>((resolve) => (settle = resolve))
+  const line = (text: string): void => {
+    if (snapshot === undefined) {
+      snapshot = JSON.parse(text) as LiveSnapshot
+      if (format === 'json') process.stdout.write(`${text}\n`)
+      else process.stdout.write(`${formatLive(snapshot).join('\n')}\n`)
+      return
+    }
+    if (format === 'json') process.stdout.write(`${text}\n`)
+    else process.stdout.write(formatLiveEvent(JSON.parse(text) as WireEvent))
+  }
+  try {
+    await Bun.connect({
+      unix: liveSocketPath(root),
+      socket: {
+        open(sock) {
+          sock.write(follow ? 'follow\n' : 'snapshot\n')
+        },
+        data(_sock, chunk) {
+          buffered += chunk.toString()
+          for (let at = buffered.indexOf('\n'); at !== -1; at = buffered.indexOf('\n')) {
+            line(buffered.slice(0, at))
+            buffered = buffered.slice(at + 1)
+          }
+        },
+        close() {
+          settle(snapshot !== undefined)
+        },
+        error() {
+          settle(snapshot !== undefined)
+        },
+      },
+    })
+  } catch {
+    // ENOENT, ECONNREFUSED: no run listens there (a killed run's socket).
+    none()
+  }
+  const timer = follow
+    ? undefined
+    : setTimeout(() => settle(snapshot !== undefined), LIVE_ANSWER_MS)
+  const answered = await done
+  clearTimeout(timer)
+  if (!answered) none()
+  return 0
+}
+
+function formatLive(s: LiveSnapshot): string[] {
+  const count = (status: string): number => s.tasks.filter((t) => t.status === status).length
+  const running = count('running')
+  const waiting = count('waiting')
+  const failed = count('failed')
+  const lines = [
+    `run ${s.live.runId} — running ${fmtMs(s.live.elapsedMs)}`,
+    `  $ ${s.live.command}`,
+    `  ${running} running · ${s.tasks.length - running - waiting} ended${failed > 0 ? ` · ${failed} failed` : ''} · ${waiting} waiting`,
+    '',
+  ]
+  const width = Math.max(...s.tasks.map((t) => t.status.length), 7)
+  const idWidth = Math.max(...s.tasks.map((t) => t.taskId.length), 0)
+  const now = s.live.startedAt + s.live.elapsedMs
+  for (const t of s.tasks) {
+    const ms =
+      t.durationMs !== null ? t.durationMs : t.startedAt !== null ? now - t.startedAt : null
+    lines.push(
+      `  ${t.status.padEnd(width)}  ${ms === null ? t.taskId : `${t.taskId.padEnd(idWidth)}  ${fmtMs(ms)}`}`,
+    )
+  }
+  if (s.warnings.length > 0) {
+    lines.push('', '  warnings', ...s.warnings.flatMap((w) => w.split('\n').map((l) => `    ${l}`)))
+  }
+  return lines
+}
+
+/** One followed event as a line: a task's output prefixed by its id, an end, a warning. */
+function formatLiveEvent(e: WireEvent): string {
+  switch (e.kind) {
+    case 'task:stdout':
+    case 'task:stderr':
+      return e.chunk
+        .replace(/\n$/, '')
+        .split('\n')
+        .map((l) => `${e.taskId} │ ${l}\n`)
+        .join('')
+    case 'task:complete':
+      return `${outcomeWord(e.outcome)}  ${e.outcome.taskId}  ${fmtMs(e.outcome.durationMs)}\n`
+    case 'run:status':
+      return 'warn' in e ? `warn  ${Bun.stripANSI(e.line)}\n` : ''
+    default:
+      return ''
+  }
+}
+
 const fmtWhen = (ms: number): string => new Date(ms).toISOString()
 
 const fmtMs = (ms: number): string => formatElapsed(ms, true)
@@ -283,7 +561,7 @@ const fmtMs = (ms: number): string => formatElapsed(ms, true)
 /**
  * What an executed task used — its peak RSS and its CPU parallelism (CPU
  * time over wall time) — as the runner recorded them. This is the number
- * `@vzn/vx-schedule-history` reserves from, so the replay shows it where
+ * `@vzn/vx-history` reserves from, so the replay shows it where
  * a developer can read it; a hit spent nothing and shows nothing.
  */
 function fmtUsage(t: {
@@ -304,13 +582,21 @@ function fmtUsage(t: {
  * their exit stands for, the sandbox's violation count, a skip's blocker.
  * Older rows carry none and read as before.
  */
-function reasonParts(t: RunSummaryRow): string {
+function reasonParts(
+  t: RunSummaryRow,
+  skippedHere: ReadonlySet<string>,
+  inputMoved: string | undefined,
+): string {
   const parts: string[] = []
   if (t.status === 'failed') {
     if (t.notReady !== null) {
       parts.push(
         `never ready: ${t.notReady === 'timeout' ? 'timed out' : t.notReady === 'exited' ? 'exited' : 'spawn failed'}`,
       )
+    } else if (inputMoved !== undefined) {
+      // `inputStability.severity: 'error'` forced the exit; the run keeps
+      // the input with the failure's output, not in the row.
+      parts.push(`${inputMoved === '' ? 'an input' : inputMoved} changed during the run`)
     } else if (t.timedOut === true) {
       parts.push('timed out')
     } else {
@@ -321,27 +607,41 @@ function reasonParts(t: RunSummaryRow): string {
       parts.push(`${t.sandboxViolations} sandbox violation${t.sandboxViolations === 1 ? '' : 's'}`)
     }
   } else if (t.status === 'skipped' && t.blockedBy !== null) {
-    parts.push(`after ${t.blockedBy} failed`)
+    // A blocker that is itself a skip is a platform skip: a failure's
+    // dependants name the failure, never a skip between.
+    parts.push(
+      skippedHere.has(t.blockedBy)
+        ? `after ${t.blockedBy} skipped: ${OTHER_PLATFORM}`
+        : `after ${t.blockedBy} failed`,
+    )
+  } else if (t.status === 'skipped' && t.exitCode === 0) {
+    // Exit 0 with no blocker is a platform skip; a fail-fast skip records 1.
+    parts.push(OTHER_PLATFORM)
   }
+  // The run's own row said `flaky - 2 attempts`: a pass that needed a
+  // retry is the one sign of a flaky task a replay can give.
+  if (t.attempts !== null && t.attempts > 1) parts.push(`${t.attempts} attempts`)
   if (t.remoteError !== null) parts.push(`remote \u2717 ${t.remoteError}`)
   return parts.map((p) => `  ${p}`).join('')
 }
 
+const OTHER_PLATFORM = 'needs another platform'
+
 /** Hit rows shown before the rest fold — the slowest restores. */
 const HITS_SHOWN = 16
 
 /**
  * The steps the run did not wait on (`vx:prefetch`), which its own output
- * never showed (M, 2026-10-16): here for debugging, marked `internal`.
+ * never showed (2026-10-16): here for debugging, marked `internal`.
  */
-function formatStepRows(steps: readonly RunStep[]): string[] {
+function formatStepRows(steps: readonly RunStep[], c: ColorSupport): string[] {
   if (steps.length === 0) return []
   const idW = Math.max(...steps.map((s) => s.id.length), 4)
   return [
     '',
     ...steps.map(
       (s) =>
-        `  ${(s.ok ? 'success' : 'failed').padEnd(17)} ${s.id.padEnd(idW)}  ${fmtMs(s.durationMs).padStart(8)}  internal`,
+        `  ${paint(s.ok ? SUCCESS : ERROR, (s.ok ? 'success' : 'failed').padEnd(17), c)} ${paint('', s.id.padEnd(idW), c, { bold: true })}  ${paint('', `${fmtMs(s.durationMs).padStart(8)}  internal`, c, { dim: true })}`,
     ),
   ]
 }
@@ -355,7 +655,12 @@ function formatStepRows(steps: readonly RunStep[]): string[] {
  * row tells. `--format json` lists every row.
  */
 
-export function formatTaskRows(tasks: readonly RunSummaryRow[]): string[] {
+export function formatTaskRows(
+  tasks: readonly RunSummaryRow[],
+  c: ColorSupport = { enabled: false },
+  /** Task id → the input that moved under it, from the run's kept failures. */
+  inputMoved: ReadonlyMap<string, string> = new Map(),
+): string[] {
   if (tasks.length === 0) return []
   const failed = tasks.filter((t) => t.status === 'failed')
   const hits = tasks.filter((t) => t.status !== 'failed' && t.cacheHit === true)
@@ -368,6 +673,9 @@ export function formatTaskRows(tasks: readonly RunSummaryRow[]): string[] {
   const at = (t: (typeof ordered)[number]): string =>
     t.placement !== null ? `@${t.placement}` : ''
   const idW = Math.max(...ordered.map((t) => `${t.project}#${t.task}${at(t)}`.length), 4)
+  const skippedHere = new Set(
+    tasks.filter((t) => t.status === 'skipped').map((t) => `${t.project}#${t.task}`),
+  )
   const lines = ['']
   for (const t of ordered) {
     const id = `${t.project}#${t.task}${at(t)}`
@@ -383,15 +691,26 @@ export function formatTaskRows(tasks: readonly RunSummaryRow[]): string[] {
         : t.cacheHit === true && t.restored !== null
           ? outcomeWord({ status: t.status as 'cache-hit', restored: t.restored })
           : t.status
+    const hue = t.status === 'failed' ? ERROR : t.status === 'skipped' ? '' : SUCCESS
     lines.push(
-      `  ${status.padEnd(17)} ${id.padEnd(idW)}  ${fmtMs(t.durationMs).padStart(8)}` +
-        `${t.hash !== '' ? `  ${t.hash}` : ''}${t.cached === false ? '  no-cache' : ''}${fmtUsage(t)}` +
-        reasonParts(t),
+      `  ${paint(hue, status.padEnd(17), c, { dim: hue === '' })} ${ui.inline(ui.id(id), c)}${' '.repeat(idW - id.length)}  ${fmtMs(t.durationMs).padStart(8)}` +
+        paint(
+          '',
+          `${t.hash !== '' ? `  ${t.hash}` : ''}${t.cached === false ? '  no-cache' : ''}${fmtUsage(t)}` +
+            reasonParts(t, skippedHere, inputMoved.get(`${t.project}#${t.task}`)),
+          c,
+          { dim: true },
+        ),
     )
   }
   if (folded) {
     lines.push(
-      `  … +${hits.length - HITS_SHOWN} more cache hits (the ${HITS_SHOWN} slowest restores shown) — vx last --format json lists every row`,
+      paint(
+        '',
+        `  … +${hits.length - HITS_SHOWN} more cache hit${hits.length - HITS_SHOWN === 1 ? '' : 's'} (the ${HITS_SHOWN} slowest restores shown) — vx last --format json lists every row`,
+        c,
+        { dim: true },
+      ),
     )
   }
   return lines
@@ -438,22 +757,43 @@ export function formatRunList(
     >
     id: string
   }[],
+  c: ColorSupport = { enabled: false },
 ): string[] {
   const rows = runs.map(({ inv, id }) => ({
     head: `${inv.exitOk ? 'ok    ' : 'FAILED'} ${fmtWhen(inv.startedAt)}`,
     id,
-    counts:
-      `${inv.taskCount} task${inv.taskCount === 1 ? '' : 's'} · ${hitsLine(inv)}` +
-      (inv.failedCount > 0 ? ` · ${inv.failedCount} failed` : ''),
+    counts: `${inv.taskCount} task${inv.taskCount === 1 ? '' : 's'} · ${hitsLine(inv)}`,
+    failed: inv.failedCount > 0 ? ` · ${inv.failedCount} failed` : '',
     ms: fmtMs(inv.totalDurationMs),
     command: inv.command,
   }))
   const idW = Math.max(...rows.map((r) => r.id.length))
-  const countsW = Math.max(...rows.map((r) => r.counts.length))
+  const countsW = Math.max(...rows.map((r) => r.counts.length + r.failed.length))
   const msW = Math.max(...rows.map((r) => r.ms.length))
   return rows.map(
     (r) =>
-      `${r.head}  ${r.id.padEnd(idW)}  ${r.counts.padEnd(countsW)}  ${r.ms.padStart(msW)}  $ ${r.command}`,
+      `${paint(r.head.startsWith('ok') ? SUCCESS : ERROR, r.head.slice(0, 6), c)}${paint('', r.head.slice(6), c, { dim: true })}  ${paint('', r.id.padEnd(idW), c, { bold: true })}  ${paint('', r.counts, c, { dim: true })}${paint(ERROR, r.failed, c)}${paint('', `${' '.repeat(countsW - r.counts.length - r.failed.length)}  ${r.ms.padStart(msW)}  $`, c, { dim: true })} ${r.command}`,
+  )
+}
+
+/**
+ * A bare task name as `--log` reads it: the one project that ran it, the
+ * cwd's among several (as `vx why` picks), else refused naming them. It
+ * read as an id and said "no recorded run of build" for a task that ran.
+ */
+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 {
+      project: string
+    }[]
+  ).map((r) => `${r.project}#${task}`)
+  if (ids.length <= 1) return ids[0] ?? task
+  const here = await findCwdProject(process.cwd())
+  if (here !== null && ids.includes(`${here}#${task}`)) return `${here}#${task}`
+  throw new UserError(
+    `vx last: "${task}" ran in ${ids.length} projects — pick one:\n${ids.map((id) => `  ${id}`).join('\n')}`,
+    'VX_E_AMBIGUOUS',
   )
 }
 
@@ -462,6 +802,7 @@ export async function lastCmd(args: readonly string[]): Promise<number> {
   if (parsed.error !== undefined) throw new UserError(`vx last: ${parsed.error}`, 'VX_E_USAGE')
 
   const root = await findWorkspaceRoot(process.cwd())
+  if (parsed.live === true) return await printLive(root, parsed.follow === true, parsed.format)
   const cacheDir = await cliCacheDir(root, parsed.cacheDir)
   const cache = Cache.inspect(cacheDir)
   try {
@@ -471,9 +812,12 @@ export async function lastCmd(args: readonly string[]): Promise<number> {
     // nothing, while `--list --failed` past green runs said there were none.
     const noRuns = (): boolean => listInvocations(db, { limit: 1 }).length === 0
 
+    if (parsed.sql !== undefined) return printQuery(db, parsed.sql, parsed.format)
+
     if (parsed.stats === true) {
       const branch = currentBranch(root, undefined, parsed.branch)
-      return await printStats(db, parsed.task, parsed.format, branch)
+      const task = parsed.task === undefined ? undefined : await rootSpelled(root, parsed.task)
+      return await printStats(db, task, parsed.format, branch)
     }
 
     if (parsed.log !== undefined) {
@@ -481,10 +825,18 @@ export async function lastCmd(args: readonly string[]): Promise<number> {
         parsed.runId === undefined
           ? undefined
           : (resolveRunId(db, parsed.runId, 'vx last') ?? parsed.runId)
-      const log = taskLog(cacheDir, db, parsed.log, runId)
+      const log = taskLog(
+        cacheDir,
+        db,
+        await bareTaskId(db, await rootSpelled(root, parsed.log)),
+        runId,
+      )
       if (log === null) {
+        // The id's form is hinted only when it lacks one: a task that
+        // never ran was told how to spell a task id.
         throw new UserError(
-          `vx last: no recorded run of ${parsed.log}${parsed.runId === undefined ? '' : ` in run ${parsed.runId}`} (a task id is project#task)`,
+          `vx last: no recorded run of ${parsed.log}${parsed.runId === undefined ? '' : ` in run ${parsed.runId}`}${parsed.log.includes('#') ? '' : ' (a task id is project#task)'}`,
+          'VX_E_NO_HISTORY',
         )
       }
       if (parsed.format === 'json') {
@@ -492,11 +844,27 @@ 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.
+        const [project, task] = splitTaskId(log.taskId)
+        const cached =
+          log.status !== 'failed' &&
+          (
+            db
+              .query('SELECT cached FROM runs WHERE run_id = ? AND project = ? AND task = ?')
+              .get(log.runId, project, task) as { cached: number | null } | null
+          )?.cached === 1
         sayNotice(
           'info',
           'vx last',
-          `${log.taskId} ended ${log.status}. vx keeps output only for failed and cached tasks`,
+          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`,
         )
+      } else if (log.output === '') {
+        sayNotice('info', 'vx last', `${log.taskId} ended ${log.status} and printed nothing`)
       }
       process.stdout.write(log.output)
       return 0
@@ -518,6 +886,7 @@ export async function lastCmd(args: readonly string[]): Promise<number> {
       }
       const lines = formatRunList(
         invocations.map((inv) => ({ inv, id: shortRunId(db, inv.runId) })),
+        detectColors(process.stdout),
       )
       process.stdout.write(`${lines.join('\n')}\n`)
       return 0
@@ -539,11 +908,13 @@ export async function lastCmd(args: readonly string[]): Promise<number> {
       throw new UserError(
         noRuns()
           ? 'vx last: no recorded runs yet — run something first'
-          : 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',
+          : parsed.runId?.includes('#') === true
+            ? `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_E_NO_HISTORY',
       )
     }
@@ -567,27 +938,48 @@ export async function lastCmd(args: readonly string[]): Promise<number> {
             }
       })
       const steps = runSteps(cacheDir, inv.runId)
+      const warnings = runWarnings(cacheDir, inv.runId)
       process.stdout.write(
-        `${JSON.stringify({ invocation: inv, tasks, ...(steps.length > 0 ? { steps } : {}) })}\n`,
+        `${JSON.stringify({
+          invocation: inv,
+          tasks,
+          ...(steps.length > 0 ? { steps } : {}),
+          ...(warnings.length > 0 ? { warnings } : {}),
+        })}\n`,
       )
       return 0
     }
 
+    const c = detectColors(process.stdout)
+    const dim = (s: string): string => paint('', s, c, { dim: true })
     const lines: string[] = []
-    lines.push(`run ${inv.runId} — ${inv.exitOk ? 'ok' : 'FAILED'}`)
-    lines.push(`  $ ${inv.command}`)
     lines.push(
-      `  ${fmtWhen(inv.startedAt)} · ${fmtMs(inv.totalDurationMs)}` +
-        `${inv.branch !== null ? ` · ${inv.branch}` : ''}` +
-        `${inv.commitSha !== null ? ` @ ${inv.commitSha.slice(0, 8)}${inv.dirty === true ? '+dirty' : ''}` : ''}` +
-        `${inv.ci ? ` · CI${inv.ciProvider !== null ? ` (${inv.ciProvider})` : ''}` : ''}`,
+      `${paint('', 'run', c, { bold: true })} ${paint('', inv.runId, c, { bold: true })} ${dim('—')} ${inv.exitOk ? paint(SUCCESS, 'ok', c) : paint(ERROR, 'FAILED', c)}`,
+    )
+    lines.push(`  ${dim('$')} ${paint('', inv.command, c, { bold: true })}`)
+    lines.push(
+      dim(
+        `  ${fmtWhen(inv.startedAt)} · ${fmtMs(inv.totalDurationMs)}` +
+          `${inv.branch !== null ? ` · ${inv.branch}` : ''}` +
+          `${inv.commitSha !== null ? ` @ ${inv.commitSha.slice(0, 8)}${inv.dirty === true ? '+dirty' : ''}` : ''}` +
+          `${inv.ci ? ` · CI${inv.ciProvider !== null ? ` (${inv.ciProvider})` : ''}` : ''}`,
+      ),
     )
     lines.push(
-      `  ${inv.taskCount} task${inv.taskCount === 1 ? '' : 's'} · ${hitsLine(inv)}` +
-        `${inv.failedCount > 0 ? ` · ${inv.failedCount} failed` : ''}`,
+      dim(`  ${inv.taskCount} task${inv.taskCount === 1 ? '' : 's'} · ${hitsLine(inv)}`) +
+        `${inv.failedCount > 0 ? paint(ERROR, ` · ${inv.failedCount} failed`, c) : ''}`,
     )
-    lines.push(...formatTaskRows(detail?.tasks ?? []))
-    lines.push(...formatStepRows(runSteps(cacheDir, inv.runId)))
+    const moved = new Map<string, string>()
+    if (inv.failedCount > 0) {
+      for (const f of runFailures(cacheDir, db, inv.runId)?.tasks ?? [])
+        if (f.inputMoved !== undefined) moved.set(f.taskId, f.inputMoved)
+    }
+    lines.push(...formatTaskRows(detail?.tasks ?? [], c, moved))
+    lines.push(...formatStepRows(runSteps(cacheDir, inv.runId), c))
+    const warnings = runWarnings(cacheDir, inv.runId)
+    if (warnings.length > 0) {
+      lines.push('', '  warnings', ...warnings.flatMap((w) => w.split('\n').map((l) => `    ${l}`)))
+    }
     // The next command after reading a failed run, with the arguments the
     // run forwarded to the tasks that got them (a failure under `-- --shard
     // 2` is that shard's); a dependency never got them, so its line has none.
@@ -599,9 +991,11 @@ export async function lastCmd(args: readonly string[]): Promise<number> {
       for (const withArgs of [false, true]) {
         const ids = failed
           .filter((t) => t.forwarded === withArgs)
-          .map((t) => `${t.project}#${t.task}`)
+          .map((t) => shellQuote(`${t.project}#${t.task}`))
         if (ids.length > 0)
-          rerun.push(`  re-run what failed: vx run ${ids.join(' ')}${withArgs ? args : ''}`)
+          rerun.push(
+            `  ${dim('re-run what failed:')} ${paint('', `vx run ${ids.join(' ')}${withArgs ? args : ''}`, c, { bold: true })}`,
+          )
       }
       lines.push('', ...rerun)
     }