@vzn/vx 0.0.651 → 0.0.652

package/src/cache/run-history.ts

@@ -48,21 +48,22 @@ const RUN_COLUMNS = [
   'flaky_failures',
 ]
 
-const INSERT_RUNS = `INSERT INTO runs(${RUN_COLUMNS.join(', ')}) VALUES `
-const RUN_TUPLE = `(${RUN_COLUMNS.map(() => '?').join(', ')})`
-
-/** An INSERT of `n` `runs` rows. */
-function insertRunsSql(n: number): string {
-  return INSERT_RUNS + Array(n).fill(RUN_TUPLE).join(', ')
+/**
+ * An INSERT of `n` `runs` rows over the columns `kept` names (indexes into
+ * `RUN_COLUMNS`); a column it leaves out is NULL, as no `runs` column has
+ * a default.
+ */
+function insertRunsSql(kept: readonly number[], n: number): string {
+  const tuple = `(${kept.map(() => '?').join(', ')})`
+  return `INSERT INTO runs(${kept.map((i) => RUN_COLUMNS[i]).join(', ')}) VALUES ${Array(n).fill(tuple).join(', ')}`
 }
 
 /**
- * Rows per INSERT: as many as stay within 999 bound variables, the oldest
- * default ceiling, read off the column count (33 rows were sized for 30
- * columns and bound 1,023 at 31). A statement per row was 8.7 ms of 1,000
- * rows, 40 at a time 6.4 (2026-10-03).
+ * Bound variables per INSERT: within 999, the oldest default ceiling. A
+ * statement per row was 8.7 ms of 1,000 rows, 40 at a time 6.4
+ * (2026-10-03).
  */
-const RUNS_PER_INSERT = Math.floor(999 / RUN_COLUMNS.length)
+const VARIABLES_PER_INSERT = 999
 
 /** Rows per `task_durations` INSERT: 7 variables each, under 999. */
 const DURATIONS_PER_INSERT = 140
@@ -152,6 +153,21 @@ export class RunHistory {
       .immediate()
   }
 
+  /**
+   * Hits written while the run goes on (history-stream.ts): their rows and
+   * the flaky record's first hit of a key. A hit times nothing, so it
+   * leaves no `task_durations` row; IMMEDIATE, as `recordRunBundle` says.
+   */
+  recordHits(runs: readonly RunRecord[]): void {
+    if (runs.length === 0) return
+    this.db
+      .transaction(() => {
+        this.insertRuns(runs)
+        this.insertOutcomes(runs)
+      })
+      .immediate()
+  }
+
   /** One `task_durations` row per executed success, as if run alone: what a forecast reads. */
   private insertDurations(runs: readonly RunRecord[], source: string, sha: string | null): void {
     const done = runs.filter(
@@ -209,7 +225,13 @@ export class RunHistory {
     }
   }
 
-  /** `runs` as few INSERTs; each distinct forward-args list digested once. */
+  /**
+   * `runs` as few INSERTs; each distinct forward-args list digested once.
+   * Only the columns some row fills are bound: a hit leaves half of them
+   * NULL, and binding 18 of 36 took the 8,002 rows of a warm run from
+   * 31.7 to 24.0 ms alone, the whole record stage 86.8 to 83.3 ms (median
+   * of 15 interleaved runs, 2026-11-06).
+   */
   private insertRuns(runs: readonly RunRecord[]): void {
     const digests = new Map<string, string>()
     const digest = (value: string): string => {
@@ -217,12 +239,19 @@ export class RunHistory {
       if (d === undefined) digests.set(value, (d = this.digestValue(value)))
       return d
     }
-    for (let i = 0; i < runs.length; i += RUNS_PER_INSERT) {
-      const block = runs.slice(i, i + RUNS_PER_INSERT)
+    const bound = runs.map((r) => bindRun(r, digest))
+    const filled = RUN_COLUMNS.map(() => false)
+    for (const row of bound)
+      for (let c = 0; c < row.length; c++) if (row[c] !== null) filled[c] = true
+    const kept: number[] = []
+    for (let c = 0; c < filled.length; c++) if (filled[c]) kept.push(c)
+    const perInsert = Math.floor(VARIABLES_PER_INSERT / kept.length)
+    for (let i = 0; i < bound.length; i += perInsert) {
+      const block = bound.slice(i, i + perInsert)
       const params: SQLQueryBindings[] = []
-      for (const r of block) for (const v of bindRun(r, digest)) params.push(v)
+      for (const row of block) for (const c of kept) params.push(row[c] as SQLQueryBindings)
       // `query` caches by text: one statement for every full block.
-      this.db.query(insertRunsSql(block.length)).run(...params)
+      this.db.query(insertRunsSql(kept, block.length)).run(...params)
     }
   }
 
@@ -287,7 +316,7 @@ export class RunHistory {
   }
 }
 
-/** Bind a RunRecord to one `RUN_TUPLE`'s positional parameters, in `RUN_COLUMNS` order. */
+/** A RunRecord as one value per `RUN_COLUMNS` entry, in its order. */
 function bindRun(run: RunRecord, digestValue: (v: string) => string): SQLQueryBindings[] {
   return [
     // The ONE place the no-key sentinel is applied, so the column's

package/src/cache/schema.ts

@@ -6,6 +6,9 @@
 
 import type { Database, SQLQueryBindings } from 'bun:sqlite'
 
+/** SQLite's file-control opcode (sqlite3.h). */
+export const SQLITE_FCNTL_PERSIST_WAL = 10
+
 /**
  * A statement prepared on its first `run` or `get`. A warm run executes few
  * of the index's statements, and preparing every one at the open cost each
@@ -84,7 +87,7 @@ export function createTables(db: Database, store: 'main' | 'store' = 'main'): vo
       -- v23: attempts a retried task took (>1); NULL for a once-run task.
       -- The direct within-run flaky signal.
       attempts            INTEGER,
-      -- v25: 1 when the task declared a cache block, 0 when it runs every
+      -- v25: 1 when the task declared cache: true, 0 when it runs every
       -- time by design; NULL on rows older than the column.
       cached              INTEGER,
       -- v27: why a task failed or was skipped, as the run's own footer

package/src/cli/cache.ts

@@ -105,7 +105,7 @@ interface PruneArgs {
   format?: 'pretty' | 'json'
   /** `--cache-dir`: prune the cache a run with the same flag uses. */
   cacheDir?: string
-  /** `--global`: clear every repository's store under `~/.vx`. */
+  /** `--global`: clear every workspace's store under `~/.vx`. */
   global?: boolean
   error?: string
 }
@@ -181,7 +181,7 @@ export function parsePruneArgs(args: readonly string[]): PruneArgs {
   }
   if (out.global === true && (out.olderThanMs !== undefined || out.maxBytes !== undefined)) {
     return {
-      error: `--global clears every repository's store and takes no --older-than or --max-size${seeHelp('cache')}`,
+      error: `--global clears every workspace's store and takes no --older-than or --max-size${seeHelp('cache')}`,
     }
   }
   if (out.global === true && out.cacheDir !== undefined) {

package/src/cli/help.ts

@@ -204,9 +204,9 @@ export function helpText(pluginCommands: readonly string[] = []): string {
     'Cache management:',
     '  vx cache clean --older-than 30d     Evict entries last accessed > 30 days ago.',
     '  vx cache clean --max-size 1G        Keep total cache under 1 GB (LRU eviction).',
-    "  vx cache clean                      Clear .vx/cache and this repo's store",
+    "  vx cache clean                      Clear .vx/cache and this workspace's store",
     '                                      ~/.vx/<id>/cache.',
-    "      --global                        Clear every repo's store under ~/.vx.",
+    "      --global                        Clear every workspace's store under ~/.vx.",
     '      --dry                           Say what the policy would reap; delete nothing.',
     '      --format <fmt>                  pretty (default) | json.',
     '      --cache-dir <path>              The cache a run with the same flag uses (why,',

package/src/cli/index.ts

@@ -6,6 +6,7 @@ import { checkSettingsEnv } from '../settings.js'
 import { CORE_VERBS, flagHint, printHelp, refuse, refusedWord, seeHelp } from './help.js'
 import {
   errorDocument,
+  hasControl,
   hideEnvFromTasks,
   isFsRefusal,
   isOutOfFds,
@@ -30,6 +31,7 @@ const plugins = () => import('./plugin-commands.js')
 export async function run(argv: readonly string[]): Promise<number> {
   refuseLossyArgs(argv)
   const [command, ...rest] = argv
+  if (command !== undefined) refuseControlArgs(command, rest)
   await hideEnvFromTasks()
 
   // `vx <verb> --help` is the universal reflex, and every verb answered
@@ -69,6 +71,28 @@ function refuseLossyArgs(argv: readonly string[]): void {
   )
 }
 
+/**
+ * No core verb's argument holds a control character, and a refusal echoing
+ * one raw broke its headline at a newline. A forwarded one (after `--`) is
+ * the task's, a `--sql` query may span lines, and a plugin verb owns its own.
+ */
+function refuseControlArgs(command: string, rest: readonly string[]): void {
+  if (!(CORE_VERBS as readonly string[]).includes(command)) return
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i]!
+    if (a === '--') return
+    if (a === '--sql') {
+      i++
+      continue
+    }
+    if (a.startsWith('--sql=') || !hasControl(a)) continue
+    throw new UserError(
+      `argument ${i + 2} (${JSON.stringify(a)}) holds a control character, which no \`vx ${command}\` argument takes`,
+      'VX_E_USAGE',
+    )
+  }
+}
+
 /**
  * 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

package/src/cli/info.ts

@@ -97,7 +97,7 @@ function infoReport(f: InfoFacts): ui.Block {
       'cache store',
       f.cacheStore === null
         ? 'none: the cache dir holds the entries'
-        : `${tildePath(f.cacheStore)} (${formatBytes(f.cacheStoreBytes ?? 0)}, shared by this repo's checkouts)`,
+        : `${tildePath(f.cacheStore)} (${formatBytes(f.cacheStoreBytes ?? 0)}, shared by this workspace's checkouts)`,
     ],
     ['cache versions', `keys ${f.cacheVersion} · index schema ${f.schemaVersion}`],
     ['cache entries', describeEntries(f)],

package/src/cli/last.ts

@@ -433,6 +433,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 +466,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 +530,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
 }