@vzn/vx 0.0.638 → 0.0.639

package/src/cli/help.ts

@@ -171,12 +171,6 @@ export function helpText(pluginCommands: readonly string[] = []): string {
     "      --timeout <duration>        A task's time limit (30s, 10m), for tasks",
     '                                  without their own exec.timeout. A task past it',
     '                                  is killed and fails.',
-    '      --kill-grace <duration>     How long a task that ignores SIGTERM gets',
-    '                                  before SIGKILL (default 2s).',
-    "      --teardown-timeout <duration>  The bound on each plugin's end-of-run flush",
-    '                                  (default 3s).',
-    '      --ready-notice <duration>   When vx says a persistent task still waits for',
-    '                                  readyWhen (default 10s).',
     '      --continue[=<mode>]         What a failed task takes down: never | deps-ok',
     '                                  (default, skips its dependents) | always (bare',
     '                                  form; dependents run, never save).',
@@ -190,18 +184,9 @@ export function helpText(pluginCommands: readonly string[] = []): string {
     'Planning (for run — skips execution):',
     "      --dry[=text|json]    Print the task graph and each task's predicted hit",
     '                           or miss.',
-    '      --graph[=<path>]     Emit Graphviz DOT (stdout if no path).',
     '',
     'Artifacts (for run):',
-    '      --format <fmt>        pretty (default) | json: print the --summarize',
-    '                            document on stdout when the run ends; every other',
-    '                            line goes to stderr.',
-    '      --summarize[=<path>]  Write per-run JSON to <cacheDir>/runs/<run_id>.json.',
     '      --profile[=<path>]    Write Chrome-trace JSON (default profile.json).',
-    '      --report[=markdown]   Print a markdown run report to stdout after the run.',
-    '      --report-file <path>  Append that report to <path> ($GITHUB_STEP_SUMMARY).',
-    '      --tag <k=v>           Label this invocation (repeatable); recorded on its',
-    '                            history row.',
     '',
     'Extensions (plugins):',
     '  vx core runs tasks in-process and nothing else. A dashboard, remote',
@@ -223,12 +208,11 @@ export function helpText(pluginCommands: readonly string[] = []): string {
     'Watch mode:',
     '  vx watch <task>            Initial run, then re-run on filesystem changes.',
     '                             Uses the same flags as `vx run` except --dry /',
-    '                             --graph / --summarize / --profile / --report /',
-    '                             --report-file / --verbosity (they plan or report',
-    '                             one run), plus --poll (watch.poll: poll instead of',
-    '                             the OS watcher). Press Ctrl+C to stop. Cache means most',
-    '                             re-runs are near-zero cost (cache hits restore',
-    '                             outputs + replay logs).',
+    '                             --profile / --verbosity (they plan or report one',
+    '                             run), plus --poll (watch.poll: poll instead of',
+    '                             the OS watcher). Press Ctrl+C to stop.',
+    '                             Cache means most re-runs are near-zero cost',
+    '                             (cache hits restore outputs + replay logs).',
     '',
     'Cache management:',
     '  vx cache clean --older-than 30d     Evict entries last accessed > 30 days ago.',
@@ -402,16 +386,7 @@ export function documentedFlags(verb: string, text = helpText()): string[] {
  * The `vx run` flags `vx watch` refuses: each plans or reports ONE run
  * (`watchRefusal` in watch.ts, held to this list by a test).
  */
-export const WATCH_REFUSED_FLAGS: readonly string[] = [
-  '--dry',
-  '--graph',
-  '--summarize',
-  '--profile',
-  '--report',
-  '--report-file',
-  '--verbosity',
-  '--format',
-]
+export const WATCH_REFUSED_FLAGS: readonly string[] = ['--dry', '--profile', '--verbosity']
 
 /**
  * The flags one verb accepts: those on its own Usage line, and for a verb

package/src/cli/info.ts

@@ -4,7 +4,8 @@
 // from the orchestrator's `collectInfo` (doctor.ts); this file parses the flags and renders the rows.
 
 import os from 'node:os'
-import { collectInfo, type FlakyTask, type InfoFacts } from '../orchestrator/index.js'
+import { collectInfo, type InfoFacts } from '../orchestrator/index.js'
+import { type FlakyTask } from '../history/index.js'
 import { flagHint, formatValue, refuse, refusedWord, seeHelp } from './help.js'
 import { namedCacheDir, parseCacheDirFlag, warnToStderr } from './workspace-config.js'
 import { formatBytes } from './format.js'

package/src/cli/last.ts

@@ -9,21 +9,23 @@ import { Cache } from '../cache/index.js'
 import { formatBytes } from './format.js'
 import { flagHint, formatValue, seeHelp } from './help.js'
 import {
-  currentBranch,
-  exitSignal,
   type FailureMode,
   getInvocation,
   getRun,
   type InvocationDetail,
   listInvocations,
   LocalHistoryProvider,
-  outcomeWord,
   type RunSummaryRow,
+} from '../history/index.js'
+import {
+  currentBranch,
+  exitSignal,
   resolveRunId,
   runFailures,
   shortRunId,
   taskLog,
 } from '../orchestrator/index.js'
+import { outcomeWord } from '../report/index.js'
 import { formatElapsed, refusal, splitTaskId, UserError, sayNotice, ui } from '../util/index.js'
 import { findWorkspaceRoot } from '../workspace/index.js'
 import { cliCacheDir, parseCacheDirFlag } from './workspace-config.js'
@@ -319,6 +321,7 @@ function reasonParts(t: RunSummaryRow): string {
   } else if (t.status === 'skipped' && t.blockedBy !== null) {
     parts.push(`after ${t.blockedBy} failed`)
   }
+  if (t.remoteError !== null) parts.push(`remote \u2717 ${t.remoteError}`)
   return parts.map((p) => `  ${p}`).join('')
 }
 

package/src/cli/plan-format.ts

@@ -1,4 +1,4 @@
-// Formatters for `--dry-run` (human / JSON) and `--graph` (DOT).
+// Formatters for `--dry` (human / JSON).
 
 import type { AffectedReason, CacheStatus, RunPlan } from '../orchestrator/index.js'
 import { formatElapsed, maskedCommand } from '../util/index.js'
@@ -9,7 +9,7 @@ import { formatElapsed, maskedCommand } from '../util/index.js'
  * task with recorded history also shows its typical duration (~p50).
  *
  *   would run:
- *     ◉  @vzn/vx#lint       cache hit (local)        abc12345
+ *     ✓  @vzn/vx#lint       cache hit (local)        abc12345
  *     ↓  @vzn/vx#test       cache hit (remote)       def67890
  *     ▶  @vzn/vx#build      cache miss — would exec  fedcba98  ~1.20s
  *
@@ -33,7 +33,7 @@ export function formatPlanText(plan: RunPlan): string {
   for (const t of real) {
     // `@noop`: the run succeeds it without running, whatever its key says.
     const skipped = t.executor === 'noop'
-    const sym = skipped ? '∅' : symbolFor(t.cacheStatus)
+    const sym = skipped ? '·' : symbolFor(t.cacheStatus)
     const desc = skipped ? 'noop — would not run' : describe(t.cacheStatus)
     const shortHash = t.hash ? t.hash.slice(0, 8) : ''
     const executes = !skipped && (t.cacheStatus === 'miss' || t.cacheStatus === 'no-cache')
@@ -186,52 +186,16 @@ export function formatPlanJson(plan: RunPlan, affectedBase?: string): string {
   )
 }
 
-/**
- * Render the task graph as a Graphviz DOT document. Includes group
- * nodes — they're real nodes in the graph (just not real units of
- * work), and a `--graph` consumer wants to see the whole structure.
- *
- * Layout: `rankdir=LR`. Node fillcolor varies by predicted cache
- * status so a quick visual scan tells you which boxes get to skip
- * actual work.
- */
-export function formatGraphDot(plan: RunPlan): string {
-  const lines: string[] = ['digraph TaskGraph {', '  rankdir=LR;', '  node [shape=box];']
-  for (const t of plan.tasks) {
-    const color = dotColor(t.cacheStatus)
-    lines.push(
-      `  ${dotString(t.node.id)} [label=${dotString(`${t.node.id}\n${t.hash.slice(0, 8)}`)}, style="filled", fillcolor="${color}"];`,
-    )
-  }
-  for (const t of plan.tasks) {
-    for (const dep of t.deps) {
-      lines.push(`  ${dotString(dep)} -> ${dotString(t.node.id)};`)
-    }
-  }
-  lines.push('}')
-  return lines.join('\n') + '\n'
-}
-
-/**
- * A DOT double-quoted ID. A task name is any object key in a config, so
- * `"`, `\` and a newline are all reachable; unescaped they end the
- * string early and the document stops parsing. `\n` is DOT's own line
- * break inside a label.
- */
-function dotString(s: string): string {
-  return `"${s.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\r?\n/g, '\\n')}"`
-}
-
 function symbolFor(s: CacheStatus): string {
   switch (s) {
     case 'hit-local':
-      return '◉'
+      return '✓'
     case 'hit-remote':
       return '↓'
     case 'miss':
       return '▶'
     case 'no-cache':
-      return '·'
+      return '∅'
     case 'group':
       return '○'
     case 'not-started':
@@ -255,20 +219,3 @@ function describe(s: CacheStatus): string {
       return 'not started (unneeded)'
   }
 }
-
-function dotColor(s: CacheStatus): string {
-  switch (s) {
-    case 'hit-local':
-      return '#bbf7d0' // green-200
-    case 'hit-remote':
-      return '#bae6fd' // sky-200
-    case 'miss':
-      return '#fed7aa' // orange-200
-    case 'no-cache':
-      return '#e5e7eb' // gray-200
-    case 'group':
-      return '#f5d0fe' // fuchsia-200
-    case 'not-started':
-      return '#ffffff'
-  }
-}

package/src/cli/plugin-commands.ts

@@ -7,7 +7,7 @@
 // reports an unknown command as it always did. Core's verbs are matched
 // before this is asked, so a plugin cannot shadow `run`.
 
-import type { CachePolicy, PluginCache, PluginCacheRemote } from '../cache/index.js'
+import type { CachePolicy, PluginCache, ResolvedRemote } from '../cache/index.js'
 import type { WorkspaceConfig } from '../config.js'
 import type { VxPlugin, PluginCommand, CommandContext } from '../orchestrator/index.js'
 import { cacheScopeEnvError, findWorkspaceRoot, isCacheScope } from '../workspace/index.js'
@@ -151,7 +151,7 @@ async function verbCache(
     'open',
     await ws.storeRoot,
   )
-  const remotes: PluginCacheRemote[] = []
+  const remotes: ResolvedRemote[] = []
   await resolveCache(ws.plugins, {
     workspaceRoot: ws.workspaceRoot,
     cacheDir: ws.cacheDir,

package/src/cli/run.ts

@@ -1,18 +1,14 @@
-import { appendFileSync, mkdirSync } from 'node:fs'
-import path from 'node:path'
 import { isatty } from 'node:tty'
 import { cacheScopeError, findWorkspaceRoot, isCacheScope } from '../workspace/index.js'
 import { translateForeign } from './foreign-flags.js'
-import { flagHint, formatValue, refuse, seeHelp } from './help.js'
+import { flagHint, refuse, seeHelp } from './help.js'
 import {
   planRun,
-  formatRunReportMarkdown,
-  projectOutcome,
   run as runOrchestrator,
   shellQuote,
   type RunOptions,
 } from '../orchestrator/index.js'
-import type { ContinueMode, TaskOutcome } from '../graph/index.js'
+import type { ContinueMode } from '../graph/index.js'
 import {
   applyCacheFlags,
   type CacheFlags,
@@ -25,7 +21,7 @@ import { affectedFilterFor, findCwdSelection, pickTask, resolveFilters } from '.
 import { nxTargetHint, taskNamesHere } from './task-verb.js'
 import { parseDecimalInt, sayNotice, sayLine } from '../util/index.js'
 import { kindHint, parseSettingValue, type Setting, SETTINGS, settingRefusal } from '../settings.js'
-import { formatGraphDot, formatPlanJson, formatPlanText } from './plan-format.js'
+import { formatPlanJson, formatPlanText } from './plan-format.js'
 
 export interface RunArgs {
   /** Failure propagation (`--continue[=never|deps-ok|always]`). */
@@ -71,10 +67,6 @@ export interface RunArgs {
   forwardArgs: string[]
   verbosity: number
   dry: 'text' | 'json' | undefined
-  /** `--format json`: the run's result document on stdout, every other line on stderr. */
-  format: 'pretty' | 'json'
-  graph: string | undefined
-  summarize: string | undefined
   profile: string | undefined
   /**
    * `--affected[=<base>]`. When undefined the flag wasn't passed.
@@ -82,16 +74,6 @@ export interface RunArgs {
    * `defaultAffectedBase`). Any other string is an explicit git ref.
    */
   affected: string | undefined
-  /** `--tag k=v` pairs (repeatable). Empty key is a parse error. */
-  tags: Record<string, string>
-  /** `--report[=markdown]`. Undefined when the flag wasn't passed. */
-  report: 'markdown' | undefined
-  /**
-   * `--report-file=<path>`. Undefined when the flag wasn't passed. Writes
-   * the same markdown as `--report`, but to a file — because redirecting
-   * vx's stdout captures the whole run log, not just the report.
-   */
-  reportFile: string | undefined
   error?: string
 }
 
@@ -130,9 +112,6 @@ const SETTING_OPTIONS = [
   ['run.timeout', 'timeout'],
   ['run.retries', 'retries'],
   ['run.outputLogs', 'outputLogs'],
-  ['run.killGrace', 'killGrace'],
-  ['run.teardownTimeout', 'teardownTimeout'],
-  ['run.readyNotice', 'readyNotice'],
   ['cache.download', 'download'],
 ] as const satisfies readonly (readonly [string, keyof RunOptions])[]
 
@@ -150,14 +129,8 @@ export function parseRunArgs(rawArgs: readonly string[], verb: 'run' | 'watch' =
     forwardArgs: [],
     verbosity: 0,
     dry: undefined,
-    format: 'pretty',
-    graph: undefined,
-    summarize: undefined,
     profile: undefined,
     affected: undefined,
-    tags: {},
-    report: undefined,
-    reportFile: undefined,
   }
 
   // A Turbo or Nx spelling becomes vx's, or a refusal naming vx's.
@@ -301,58 +274,18 @@ export function parseRunArgs(rawArgs: readonly string[], verb: 'run' | 'watch' =
         return { ...out, error: `--dry must be text or json (got ${fmt})` }
       }
       out.dry = fmt
-    } else if (a === '--format' || a?.startsWith('--format=')) {
-      const f = formatValue(a === '--format' ? before[++i] : a.slice('--format='.length), verb)
-      if (typeof f !== 'string') return { ...out, error: f.error }
-      out.format = f
-    } else if (a === '--graph') {
-      out.graph = ''
-    } else if (a?.startsWith('--graph=')) {
-      out.graph = a.slice('--graph='.length)
-    } else if (a === '--summarize') {
-      out.summarize = ''
-    } else if (a?.startsWith('--summarize=')) {
-      out.summarize = a.slice('--summarize='.length)
     } else if (a === '--profile') {
       out.profile = 'profile.json'
     } else if (a?.startsWith('--profile=')) {
       // An optional-value flag: an empty `=` means "no value given", so it
       // takes the same documented default as the bare form. Resolving ''
       // against cwd would name the cwd DIRECTORY and die with EISDIR after
-      // the whole run — and `--summarize=` already degrades to its default.
+      // the whole run.
       out.profile = a.slice('--profile='.length) || 'profile.json'
     } else if (a === '--affected') {
       out.affected = ''
     } else if (a?.startsWith('--affected=')) {
       out.affected = a.slice('--affected='.length)
-    } else if (a === '--tag' || a?.startsWith('--tag=')) {
-      const raw = a === '--tag' ? before[++i] : a.slice('--tag='.length)
-      if (raw === undefined) return { ...out, error: `${a} requires a value (k=v)` }
-      // Split on the FIRST `=` so values may contain `=` (e.g. a URL).
-      const eq = raw.indexOf('=')
-      if (eq <= 0) return { ...out, error: `--tag must be k=v (got ${raw})` }
-      out.tags[raw.slice(0, eq)] = raw.slice(eq + 1)
-    } else if (a === '--report-file' || a?.startsWith('--report-file=')) {
-      const v = a === '--report-file' ? before[++i] : a.slice('--report-file='.length)
-      if (v === undefined || v === '') return { ...out, error: `--report-file requires a path` }
-      // Same reasoning as --cache-dir: a path is an arbitrary string, so
-      // nothing about its shape rejects a swallowed flag. A path starting
-      // with `-` needs the `=` form.
-      if (a === '--report-file' && v.startsWith('-')) {
-        return {
-          ...out,
-          error: `--report-file requires a path (got flag ${v}; a path that starts with - needs --report-file=${v})`,
-        }
-      }
-      out.reportFile = v
-    } else if (a === '--report') {
-      out.report = 'markdown'
-    } else if (a?.startsWith('--report=')) {
-      const fmt = a.slice('--report='.length)
-      if (fmt !== 'markdown') {
-        return { ...out, error: `--report must be markdown (got ${fmt})` }
-      }
-      out.report = fmt
     } else if (verb === 'watch' && a === '--poll') {
       out.poll = true
     } else if (a !== undefined && settingFlagOf(a) !== undefined) {
@@ -400,39 +333,10 @@ export function parseRunArgs(rawArgs: readonly string[], verb: 'run' | 'watch' =
   out.cache = applyCacheFlags(cachePolicy, flags)
   if (!cacheFlag && envSpec === undefined) out.cacheFlags = flags
 
-  if (out.dry !== undefined && out.graph !== undefined) {
-    return { ...out, error: '--dry and --graph are mutually exclusive' }
-  }
-  // Every flag that promises a file or a section about the run: the
-  // planning branch returns before any of them is written, and
-  // `--report-file="$GITHUB_STEP_SUMMARY" --dry` exited 0 having written
-  // nothing (item 992).
-  const needsRun =
-    out.summarize !== undefined ||
-    out.profile !== undefined ||
-    out.report !== undefined ||
-    out.reportFile !== undefined
-  const runOnly = '--summarize / --profile / --report / --report-file need a real run'
-  if (out.dry !== undefined && needsRun) {
-    return { ...out, error: `--dry skips execution; ${runOnly}` }
-  }
-  if (out.graph !== undefined && needsRun) {
-    return { ...out, error: `--graph skips execution; ${runOnly}` }
-  }
-  if (out.format === 'json') {
-    // Each of these prints something else on stdout, which the document owns.
-    if (out.dry !== undefined)
-      return { ...out, error: '--format json runs the tasks; --dry=json prints the plan' }
-    if (out.graph === '')
-      return {
-        ...out,
-        error: '--format json and --graph both print on stdout; give --graph a file',
-      }
-    if (out.report === 'markdown')
-      return {
-        ...out,
-        error: '--format json and --report=markdown both print on stdout; use --report-file',
-      }
+  // A profile is about a run: the planning branch returns before it is
+  // written (item 992).
+  if (out.dry !== undefined && out.profile !== undefined) {
+    return { ...out, error: '--dry skips execution; --profile needs a real run' }
   }
   return out
 }
@@ -619,10 +523,7 @@ export async function resolveRunOptions(
   for (const [path, field] of SETTING_OPTIONS) {
     if (parsed.settings[path] !== undefined) Object.assign(opts, { [field]: parsed.settings[path] })
   }
-  if (parsed.summarize !== undefined) opts.summarize = parsed.summarize
-  if (parsed.format === 'json') opts.json = true
   if (parsed.profile !== undefined) opts.profile = parsed.profile
-  if (Object.keys(parsed.tags).length > 0) opts.tags = parsed.tags
 
   return opts
 }
@@ -646,7 +547,7 @@ export async function runCmd(args: readonly string[]): Promise<number> {
   if (tasks.length === 0) {
     // A JSON answer is for a program, which cannot pick from a menu: an
     // agent on a pty waited at the picker forever.
-    const forProgram = parsed.format === 'json' || parsed.dry === 'json'
+    const forProgram = parsed.dry === 'json'
     if (!process.stdin.isTTY || forProgram) {
       const names = await taskNamesHere(cwd)
       const shown = (names ?? []).slice(0, TASKS_SHOWN)
@@ -710,17 +611,17 @@ export async function runCmd(args: readonly string[]): Promise<number> {
     ...args.map(shellQuote),
   ].join(' ')
 
-  // Planning paths short-circuit execution. Both build the full task
-  // graph + probe the cache; the difference is just the formatter.
-  if (parsed.dry !== undefined || parsed.graph !== undefined) {
+  // Planning short-circuits execution: the full task graph + a cache probe.
+  if (parsed.dry !== undefined) {
     const plan = await planRun(opts)
+    // Refused as a run refuses: `--dry=json` gets the error document.
     if (plan.unresolvedTasks !== undefined && plan.unresolvedTasks.length > 0) {
-      sayNotice(
-        'error',
-        'vx run',
+      return refuse(
+        'run',
+        args,
         `no projects declare task(s): ${plan.unresolvedTasks.join(', ')}.${plan.unresolvedHint ?? ''}`,
+        'VX_E_UNKNOWN_TASK',
       )
-      return 1
     }
     if (plan.tasks.length === 0) {
       // The run's own line: a dry run that guessed from the scope alone
@@ -733,27 +634,14 @@ export async function runCmd(args: readonly string[]): Promise<number> {
         sayNotice('info', 'vx run', `no affected project declares task(s): ${tasks.join(', ')}`)
         return 0
       }
-      sayNotice('error', 'vx run', `no projects declare task(s): ${tasks.join(', ')}`)
-      return 1
+      return refuse(
+        'run',
+        args,
+        `no projects declare task(s): ${tasks.join(', ')}`,
+        'VX_E_UNKNOWN_TASK',
+      )
     }
-    if (parsed.graph !== undefined) {
-      const out = formatGraphDot(plan)
-      if (parsed.graph === '') {
-        process.stdout.write(out)
-      } else {
-        // The graph is the command's one product, so a path it cannot write
-        // is exit 1, said in one line as the other output paths say theirs:
-        // a directory or an unreachable path printed a raw stack (item 993).
-        const target = path.resolve(cwd, parsed.graph)
-        try {
-          await Bun.write(target, out)
-        } catch (err) {
-          const message = err instanceof Error ? err.message : String(err)
-          sayNotice('error', 'vx run', `failed to write graph to ${target}: ${message}`)
-          return 1
-        }
-      }
-    } else if (parsed.dry === 'json') {
+    if (parsed.dry === 'json') {
       process.stdout.write(formatPlanJson(plan, scopeOut.affectedBase))
     } else {
       process.stdout.write(formatPlanText(plan))
@@ -761,25 +649,6 @@ export async function runCmd(args: readonly string[]): Promise<number> {
     return 0
   }
 
-  // The report prints above the footer: nothing prints below it (owner).
-  // Rendered once, however many sinks asked for it; a kept server's crash
-  // after the footer re-renders the file's copy (C-53).
-  const wantsReport = parsed.report === 'markdown' || parsed.reportFile !== undefined
-  let reported: { outcomes: readonly TaskOutcome[]; md: string } | undefined
-  if (wantsReport) {
-    opts.beforeFooter = (outcomes, ok) => {
-      reported = {
-        outcomes,
-        md: formatRunReportMarkdown({ ok, outcomes: outcomes.map(projectOutcome) }),
-      }
-      // `--report` writes stdout. The report ITSELF is machine-clean, but
-      // stdout is not vx's alone — the status logger writes there too, so
-      // `--report=markdown >> "$GITHUB_STEP_SUMMARY"` captures every frame,
-      // meter bar and `::group::` command above the table. `--report-file`
-      // is the redirect-free form.
-      return parsed.report === 'markdown' ? reported.md : ''
-    }
-  }
   // A run executes in THIS process, always. Where an individual task's
   // command runs is the `executor` capability's business (per task, with
   // the scheduler, cache, retries and telemetry unchanged above it); there
@@ -789,37 +658,6 @@ export async function runCmd(args: readonly string[]): Promise<number> {
     const unknown = summary.refused.startsWith('no projects declare')
     return refuse('run', args, summary.refused, unknown ? 'VX_E_UNKNOWN_TASK' : 'VX_E_REFUSED')
   }
-  if (wantsReport) {
-    const md =
-      reported?.outcomes === summary.outcomes
-        ? reported.md
-        : formatRunReportMarkdown({
-            ok: summary.ok,
-            outcomes: summary.outcomes.map(projectOutcome),
-          })
-    if (parsed.reportFile !== undefined) {
-      const target = path.resolve(cwd, parsed.reportFile)
-      try {
-        // APPEND, not overwrite: the flag exists for `$GITHUB_STEP_SUMMARY`,
-        // which GitHub documents as append-only and which other steps in the
-        // same job also write to. Truncating it would silently destroy their
-        // content, and would make replacing the documented `>>` recipe a
-        // behaviour change rather than a drop-in.
-        // Its directory made first, as `--summarize`, `--profile` and
-        // `--graph` make theirs: `nr/r.md` failed alone of the four (item 993).
-        // Sync: on a Ctrl-C the signal path exits once stdout drains, and
-        // an awaited write lost the race every time (E-23).
-        mkdirSync(path.dirname(target), { recursive: true })
-        appendFileSync(target, md)
-      } catch (err) {
-        // Same contract as --summarize / --profile: the run already
-        // happened, so a write failure is reported, not fatal.
-        const message = err instanceof Error ? err.message : String(err)
-        sayNotice('warn', 'vx run', `failed to write report to ${target}: ${message}`)
-      }
-    }
-  }
-  if (summary.json !== undefined) process.stdout.write(`${JSON.stringify(summary.json)}\n`)
   return summary.ok ? 0 : 1
 }
 

package/src/cli/show.ts

@@ -169,6 +169,12 @@ export async function showCmd(args: readonly string[]): Promise<number> {
   const projects = await loadCliProjects(root, metas, scope, { closure: true })
 
   if (parsed.target === undefined) {
+    if (metas.length === 0)
+      sayNotice(
+        'info',
+        'vx show',
+        'no projects: no directory holds a vx.config — run `vx init` to write them, then `vx lock`',
+      )
     const shown = metas.filter((m) => inSelection(m.name))
     process.stdout.write(renderList(root, shown, projects, parsed.format, colorsOut()))
     return 0