@vzn/vx 0.0.18 → 0.0.22

package/src/cli/prune.ts

@@ -1,291 +0,0 @@
-// `vx prune <project> [--out-dir <dir>] [--docker]` — emit a self-contained
-// SUBSET of the workspace containing one project and its transitive
-// workspace dependencies, for Docker builds (Turbo `turbo prune` parity,
-// comparison gap #10).
-//
-// What lands in the output:
-//   <out>/               the pruned workspace (or <out>/full/ with --docker)
-//     package.json         root manifest, copied as-is
-//     pnpm-workspace.yaml  REWRITTEN to the exact subset dirs (a glob that
-//                          matches dirs absent from the subset would make
-//                          pnpm error on install)
-//     <lockfile>           copied UNPRUNED — pnpm/bun/npm/yarn all tolerate
-//                          a superset lockfile; real lockfile pruning is a
-//                          per-format project (Turbo ships a crate per
-//                          format) and a wrong pruned lockfile is worse
-//                          than a big correct one. Documented, deliberate.
-//     vx.workspace.*       copied when present, together with any WORKSPACE
-//                          package it imports (a plugin lives in the subset
-//                          or `vx run` cannot load the config at all)
-//     .npmrc / .nvmrc      copied when present
-//     <pkg dirs>           full source of the project + every transitive
-//                          workspace dep (node_modules / .git / .vx / .turbo
-//                          excluded)
-//   <out>/json/          with --docker: manifests only (root files + each
-//                          package's package.json) — COPY this layer first
-//                          so `pnpm install` caches independently of source
-//                          edits, then COPY full/ and build.
-//
-// Boundaries note: a package dir is copied WHOLE (minus the exclusions).
-// vx's own nested-project input exclusions do not apply here — prune
-// reproduces the tree, it does not hash it.
-//
-// RUNNABILITY IS NOT GUARANTEED, and this deliberately does not claim it.
-// A config may import any path it likes; only imports that name a workspace
-// PACKAGE can be resolved and pulled in. A relative import escaping its own
-// package dir (`../../src/index.ts`, the shape this repo's own dogfooding
-// configs use) reaches a file prune never copies, and no subset short of the
-// whole tree would contain it. Those are reported at prune time — a warning
-// the user reads now beats a module-not-found inside a docker build.
-// The import scan is STATIC and deliberately simple: it sees `from '…'`,
-// `import '…'` and `import('…')`, and nothing computed.
-
-import { cp, mkdir, stat, writeFile } from 'node:fs/promises'
-import path from 'node:path'
-import {
-  buildPackageGraph,
-  findWorkspaceRoot,
-  loadWorkspace,
-  listProjects,
-} from '../workspace/index.js'
-import { UserError } from '../util/index.js'
-
-interface PruneWorkspaceArgs {
-  project?: string
-  outDir: string
-  docker: boolean
-  error?: string
-}
-
-export function parsePruneWorkspaceArgs(args: readonly string[]): PruneWorkspaceArgs {
-  const out: PruneWorkspaceArgs = { outDir: 'out', docker: false }
-  for (let i = 0; i < args.length; i++) {
-    const a = args[i]!
-    if (a === '--out-dir' || a.startsWith('--out-dir=')) {
-      const v = a === '--out-dir' ? args[++i] : a.slice('--out-dir='.length)
-      if (v === undefined || v === '') return { ...out, error: 'invalid --out-dir: empty' }
-      out.outDir = v
-      continue
-    }
-    if (a === '--docker') {
-      out.docker = true
-      continue
-    }
-    if (a.startsWith('-')) return { ...out, error: `unknown flag: ${a}` }
-    if (out.project !== undefined) return { ...out, error: `unexpected argument: ${a}` }
-    out.project = a
-  }
-  return out
-}
-
-const COPY_EXCLUDES = new Set(['node_modules', '.git', '.vx', '.turbo'])
-
-/** Root-level files worth carrying into the subset, when they exist. */
-const ROOT_FILES = ['package.json', '.npmrc', '.nvmrc']
-const WORKSPACE_CONFIGS = [
-  'vx.workspace.ts',
-  'vx.workspace.mts',
-  'vx.workspace.js',
-  'vx.workspace.mjs',
-]
-const LOCKFILES = ['pnpm-lock.yaml', 'bun.lock', 'bun.lockb', 'package-lock.json', 'yarn.lock']
-
-async function exists(p: string): Promise<boolean> {
-  return stat(p).then(
-    () => true,
-    () => false,
-  )
-}
-
-async function copyDirFiltered(src: string, dest: string): Promise<void> {
-  await cp(src, dest, {
-    recursive: true,
-    filter: (source) => !COPY_EXCLUDES.has(path.basename(source)),
-  })
-}
-
-const PROJECT_CONFIGS = ['vx.config.ts', 'vx.config.mts', 'vx.config.js', 'vx.config.mjs']
-/** `from '…'`, `import '…'`, `import('…')`. Static specifiers only. */
-const SPECIFIER_RE = /(?:from|import)\s*\(?\s*['"]([^'"]+)['"]/g
-
-async function readImports(dir: string, names: readonly string[]): Promise<string[]> {
-  for (const f of names) {
-    const p = path.join(dir, f)
-    if (!(await exists(p))) continue
-    const text = await Bun.file(p).text()
-    return [...text.matchAll(SPECIFIER_RE)].map((m) => m[1]!)
-  }
-  return []
-}
-
-export async function pruneWorkspaceCmd(args: readonly string[]): Promise<number> {
-  const parsed = parsePruneWorkspaceArgs(args)
-  if (parsed.error !== undefined) throw new UserError(`vx prune: ${parsed.error}`)
-  if (parsed.project === undefined) {
-    throw new UserError('vx prune: <project> required (e.g. vx prune @acme/api)')
-  }
-
-  const root = await findWorkspaceRoot(process.cwd())
-  const workspace = await loadWorkspace(root)
-  const projects = await listProjects(workspace)
-  const byName = new Map(projects.map((p) => [p.name, p]))
-
-  const target = byName.get(parsed.project)
-  if (target === undefined) {
-    const names = [...byName.keys()].sort()
-    const q = parsed.project.toLowerCase()
-    const near = names.filter((n) => n.toLowerCase().includes(q)).slice(0, 3)
-    throw new UserError(
-      `vx prune: no project named "${parsed.project}"` +
-        (near.length > 0 ? ` — did you mean ${near.join(', ')}?` : ''),
-    )
-  }
-
-  const graph = buildPackageGraph(projects)
-  const names = new Set([target.name, ...graph.transitiveDeps(target.name)])
-
-  // The workspace config runs BEFORE any task, so a plugin it imports from a
-  // workspace package is as load-bearing as a package dependency — without it
-  // `vx run` in the container fails to load the config at all. Pull those in
-  // (with their own dep closure). The root member is the one that cannot be:
-  // copying it would mean copying the whole tree, so it is reported instead.
-  const projectFor = (spec: string): (typeof projects)[number] | undefined =>
-    projects.find((p) => spec === p.name || spec.startsWith(`${p.name}/`))
-  const uncopyable = new Set<string>()
-  for (const spec of await readImports(root, WORKSPACE_CONFIGS)) {
-    const owner = projectFor(spec)
-    if (owner === undefined || names.has(owner.name)) continue
-    if (owner.dir === root) {
-      uncopyable.add(`${owner.name} (the workspace root itself)`)
-      continue
-    }
-    names.add(owner.name)
-    for (const d of graph.transitiveDeps(owner.name)) names.add(d)
-  }
-
-  const subset = [...names].map((n) => byName.get(n)!).sort((a, b) => a.name.localeCompare(b.name))
-
-  const outAbs = path.resolve(process.cwd(), parsed.outDir)
-  // Three shapes that would eat their own tail: the out dir IS the root
-  // (overwrites the workspace), CONTAINS the root (copies land above the
-  // repo), or sits INSIDE a package being copied (cp would recurse into
-  // its own output). A root-level ./out is fine — only package dirs are
-  // copied wholesale, never the root itself.
-  if (outAbs === root || root.startsWith(outAbs + path.sep)) {
-    throw new UserError('vx prune: --out-dir must not be, or contain, the workspace root')
-  }
-  for (const p of subset) {
-    if (outAbs === p.dir || outAbs.startsWith(p.dir + path.sep)) {
-      throw new UserError(
-        `vx prune: --out-dir is inside ${p.name}, which is being copied — pick a path outside the pruned packages`,
-      )
-    }
-  }
-  const fullDir = parsed.docker ? path.join(outAbs, 'full') : outAbs
-  const jsonDir = path.join(outAbs, 'json')
-  await mkdir(fullDir, { recursive: true })
-  if (parsed.docker) await mkdir(jsonDir, { recursive: true })
-
-  const rels = subset.map((p) => path.relative(root, p.dir).split(path.sep).join('/'))
-  // pnpm-workspace.yaml rewritten to the exact subset — globs that match
-  // nothing in the subset make installs fail.
-  const workspaceYaml = `packages:\n${rels.map((r) => `  - "${r}"\n`).join('')}`
-
-  // package.json's `workspaces` is where bun/npm/yarn read membership, and it
-  // needs the SAME rewrite as pnpm-workspace.yaml for the same reason — except
-  // the failure is sharper: a GLOB matching nothing is tolerated, but an entry
-  // naming an exact dir that the subset does not contain is fatal
-  // (`bun install` → `error: Workspace not found "packages/b"`, exit 1), so the
-  // emitted context would not install at all. A `.` entry is kept when it was
-  // there: it names the root package, whose manifest is copied.
-  const rewriteRootManifest = async (dest: string): Promise<boolean> => {
-    const src = path.join(root, 'package.json')
-    if (!(await exists(src))) return false
-    let pkg: Record<string, unknown>
-    try {
-      pkg = JSON.parse(await Bun.file(src).text()) as Record<string, unknown>
-    } catch {
-      return false // unparseable: copy it verbatim rather than lose it
-    }
-    const field = pkg['workspaces']
-    const list = Array.isArray(field)
-      ? field
-      : typeof field === 'object' && field !== null && Array.isArray((field as never)['packages'])
-        ? ((field as never)['packages'] as string[])
-        : undefined
-    if (list === undefined) return false
-    const next = (list as string[]).includes('.') ? ['.', ...rels] : [...rels]
-    pkg['workspaces'] = Array.isArray(field) ? next : { ...(field as object), packages: next }
-    await writeFile(path.join(dest, 'package.json'), `${JSON.stringify(pkg, null, 2)}\n`)
-    return true
-  }
-
-  const emitRoots = async (dest: string): Promise<void> => {
-    await writeFile(path.join(dest, 'pnpm-workspace.yaml'), workspaceYaml)
-    const manifestWritten = await rewriteRootManifest(dest)
-    for (const f of [...ROOT_FILES, ...WORKSPACE_CONFIGS, ...LOCKFILES]) {
-      if (f === 'package.json' && manifestWritten) continue
-      const src = path.join(root, f)
-      if (await exists(src)) await cp(src, path.join(dest, f))
-    }
-  }
-
-  await emitRoots(fullDir)
-  for (const [i, p] of subset.entries()) {
-    await copyDirFiltered(p.dir, path.join(fullDir, rels[i]!))
-  }
-
-  if (parsed.docker) {
-    await emitRoots(jsonDir)
-    for (const [i, p] of subset.entries()) {
-      const pkgJson = path.join(p.dir, 'package.json')
-      if (await exists(pkgJson)) {
-        const destDir = path.join(jsonDir, rels[i]!)
-        await mkdir(destDir, { recursive: true })
-        await cp(pkgJson, path.join(destDir, 'package.json'))
-      }
-    }
-  }
-
-  // Every copied config is re-read to report what the subset canNOT satisfy:
-  // a relative import reaching outside the copied dirs, or a workspace package
-  // that is not here. Copied root files (the manifest, the lockfile, the
-  // workspace config) count as present — a config importing one of those is
-  // fine, and flagging it would be a false alarm.
-  const copiedRootFiles = new Set([...ROOT_FILES, ...WORKSPACE_CONFIGS, ...LOCKFILES])
-  const escapes: string[] = []
-  for (const p of subset) {
-    for (const spec of await readImports(p.dir, PROJECT_CONFIGS)) {
-      if (spec.startsWith('.')) {
-        const resolved = path.resolve(p.dir, spec)
-        const inSubset = subset.some(
-          (q) => resolved === q.dir || resolved.startsWith(q.dir + path.sep),
-        )
-        const isCopiedRootFile =
-          path.dirname(resolved) === root && copiedRootFiles.has(path.basename(resolved))
-        if (!inSubset && !isCopiedRootFile) {
-          escapes.push(`${p.name}: ${spec} resolves outside the pruned subset`)
-        }
-        continue
-      }
-      const owner = projectFor(spec)
-      if (owner !== undefined && !subset.includes(owner)) {
-        escapes.push(`${p.name}: imports ${owner.name}, which is not in the subset`)
-      }
-    }
-  }
-
-  process.stdout.write(
-    `pruned ${subset.length} package${subset.length === 1 ? '' : 's'} for ${target.name} → ${parsed.outDir}${parsed.docker ? ' (docker layout: json/ + full/)' : ''}\n` +
-      subset.map((p) => `  ${p.name}\n`).join(''),
-  )
-  for (const u of uncopyable) {
-    process.stderr.write(
-      `vx prune: WARNING the workspace config imports ${u} — it cannot be copied into a subset, so \`vx run\` inside the container will not load it\n`,
-    )
-  }
-  for (const e of escapes) {
-    process.stderr.write(`vx prune: WARNING ${e}\n`)
-  }
-  return 0
-}

package/src/orchestrator/missing-plugin.ts

@@ -1,9 +0,0 @@
-/** Shown by every "no <capability> plugin declared" error. */
-export const MISSING_PLUGIN_HINT = `vx runs nothing it was not told to. Declare the plugins in vx.workspace.ts:
-
-  import { defineWorkspace } from '@vzn/vx'
-  import { localExecutorPlugin } from '@vzn/vx/plugins/local-executor'
-  import { localCachePlugin } from '@vzn/vx/plugins/local-cache'
-  export default defineWorkspace({ plugins: [localExecutorPlugin(), localCachePlugin()] })
-
-Put a remote executor or cache plugin BEFORE the local one to prefer it.`

package/src/orchestrator/resources.ts

@@ -1,45 +0,0 @@
-// Resolve `exec.resources` declarations into the absolute per-task costs the
-// scheduler's 2-D admission gate packs against. Pure; the loader has already
-// validated every form (this module trusts internal code), so an unparseable
-// value can't reach it from a real config.
-//
-// The declared units are CPU CORES and MEGABYTES — the same numbers on this
-// machine and on a remote worker, which is why they are also what
-// `TaskPlacement.resources` hands an executor verbatim. Percent forms were
-// removed on 2026-08-30: a percentage names a fraction of THIS run's budget,
-// and an executor placing the task on someone else's machine has no way to
-// mean anything by it.
-
-import type { ResourceCost, TaskNode } from '../graph/index.js'
-
-const BYTES_PER_MB = 1024 * 1024
-
-/** `cpus` → CPU units. Absent → 0 = reserve nothing. */
-export function resolveCpu(v: number | undefined): number {
-  return v ?? 0
-}
-
-/** `memory` (megabytes) → bytes, which is what the budget axis counts. */
-export function resolveMem(v: number | undefined): number {
-  return v === undefined ? 0 : v * BYTES_PER_MB
-}
-
-/**
- * Resolve the whole graph's declared reservations, OMITTING zero-cost
- * tasks: an empty map means "no reservations declared", the single gate
- * the scheduler (and run.ts's option threading) keys off to keep every
- * current run byte-identical.
- */
-export function resolveResourceCosts(
-  nodes: ReadonlyMap<string, TaskNode>,
-): Map<string, ResourceCost> {
-  const out = new Map<string, ResourceCost>()
-  for (const node of nodes.values()) {
-    const declared = node.config.exec?.resources
-    if (declared === undefined) continue
-    const cpu = resolveCpu(declared.cpus)
-    const mem = resolveMem(declared.memory)
-    if (cpu > 0 || mem > 0) out.set(node.id, { cpu, mem })
-  }
-  return out
-}

package/src/orchestrator/verify.ts

@@ -1,174 +0,0 @@
-// Cache-correctness verification (Phase 1: determinism). Pure helpers for the
-// `vx run --verify` hook in execute-task.ts: content-fingerprint a task's
-// output tree (mtime-independent) and diff two runs' trees, so a task whose
-// outputs are NOT a pure function of its declared inputs — a non-hermetic task
-// whose cache entry would replay arbitrary past bytes — is caught and named.
-// See docs/design/cache-correctness-2026-07.md.
-
-import path from 'node:path'
-import type { OutputFingerprint, TaskOutcome, VerifyVerdict } from '../graph/index.js'
-import { xxh3hex } from '../util/index.js'
-
-/** An output file to fingerprint: absolute path + a stable, run-independent
- *  key (project-relative, or `workspace-outputs/<rel-to-root>` for workspace
- *  outputs — matching the cache artifact's namespace so the two never collide). */
-export interface OutputRef {
-  abs: string
-  key: string
-}
-
-/** Build the fingerprint key set from a task's resolved output paths. */
-export function outputRefs(
-  projectDir: string,
-  outputFiles: readonly string[],
-  workspaceRoot: string,
-  workspaceOutputFiles: readonly string[],
-): OutputRef[] {
-  const rel = (from: string, abs: string): string =>
-    path.relative(from, abs).split(path.sep).join('/')
-  return [
-    ...outputFiles.map((abs) => ({ abs, key: rel(projectDir, abs) })),
-    ...workspaceOutputFiles.map((abs) => ({
-      abs,
-      key: `workspace-outputs/${rel(workspaceRoot, abs)}`,
-    })),
-  ]
-}
-
-/** Content-fingerprint an output tree: key → xxh3 of the file's BYTES, read
- *  unconditionally from disk. Deliberately NOT `Cache.hashFile`: its
- *  mtime+size memo would return attempt 1's digest for a re-run output with
- *  equal size and mtime (e.g. a build that normalizes mtimes — standard
- *  reproducible-build practice), silently proving a divergent task
- *  deterministic. fp1/fp2 are only ever compared to each other, so any
- *  content hash works — and the proof must not trust a cache. */
-export async function hashOutputTree(refs: readonly OutputRef[]): Promise<Map<string, string>> {
-  const out = new Map<string, string>()
-  for (const r of refs) {
-    out.set(r.key, xxh3hex(new Uint8Array(await Bun.file(r.abs).arrayBuffer())))
-  }
-  return out
-}
-
-/** Per-file map cap on a shipped fingerprint (~40 KB at the cap). The tree
- *  digest always folds ALL entries, so detection never depends on the map. */
-const FP_MAX_FILES = 500
-
-/** Roll an output-tree fingerprint map into the shippable `OutputFingerprint`
- *  payload (Phase 4, cross-machine diff): a tree digest over ALL sorted
- *  entries folded `key\0hash\n` (\0 boundaries so parts can't alias), plus
- *  the first-`cap` pairs — deterministic truncation, so two machines'
- *  truncated maps cover the same key subset and stay diffable. */
-export function foldFingerprint(fp: Map<string, string>, cap = FP_MAX_FILES): OutputFingerprint {
-  const keys = [...fp.keys()].sort()
-  let folded = ''
-  for (const k of keys) folded += `${k}\0${fp.get(k)!}\n`
-  return {
-    tree: xxh3hex(folded),
-    fileCount: keys.length,
-    files: keys.slice(0, cap).map((k) => [k, fp.get(k)!] as const),
-    ...(keys.length > cap ? { truncated: true } : {}),
-  }
-}
-
-/** The output keys whose content OID differs between two fingerprints
- *  (added, removed, or changed), sorted. */
-export function diffOutputTrees(a: Map<string, string>, b: Map<string, string>): string[] {
-  const changed: string[] = []
-  for (const k of new Set([...a.keys(), ...b.keys()])) {
-    if (a.get(k) !== b.get(k)) changed.push(k)
-  }
-  return changed.sort()
-}
-
-/** Turn a determinism diff into a verdict, honoring the `--verify-allow`
- *  escape hatch (an allowed divergence is reported but never fails the run). */
-export function classifyDeterminism(changed: readonly string[], allowed: boolean): VerifyVerdict {
-  if (changed.length === 0) return { kind: 'proven-deterministic' }
-  return allowed
-    ? { kind: 'allowed-nondeterministic', changed }
-    : { kind: 'nondeterministic', changed }
-}
-
-/** Extract the workspace-relative paths a task read outside its declared inputs
- *  (Phase 2, `--verify=inputs`). A strace-derived violation line carries the
- *  offending absolute path in trailing brackets (`… [/abs/path]`); pull it out,
- *  make it workspace-relative, dedup, and sort. Lines without a bracketed path
- *  (e.g. macOS syscall lines) fall back to the raw line so nothing is lost. */
-export function undeclaredInputPaths(
-  violations: readonly { line: string }[],
-  workspaceRoot: string,
-): string[] {
-  const rels = new Set<string>()
-  for (const v of violations) {
-    // Two wire shapes: Linux strace lines carry `[path]`; macOS
-    // sandbox-exec lines end in a bare absolute path
-    // (`node(123) deny(1) file-read-data /abs/path`). Fall back to the
-    // raw line only when neither parses — a path the user can act on
-    // beats a log line every time.
-    const m = /\[([^\]]+)\]\s*$/.exec(v.line) ?? /\s(\/\S+)\s*$/.exec(v.line)
-    const raw = m ? m[1]! : v.line
-    rels.add(
-      path.isAbsolute(raw) ? path.relative(workspaceRoot, raw).split(path.sep).join('/') : raw,
-    )
-  }
-  return [...rels].sort()
-}
-
-/** The end-of-run `--verify` summary section: a counts line plus a
- *  failures block naming each non-hermetic task and its diverging outputs.
- *  Empty when no task carried a verdict. */
-export function formatVerifySection(outcomes: readonly TaskOutcome[]): string[] {
-  const verdicts = outcomes.filter((o) => o.verify !== undefined)
-  if (verdicts.length === 0) return []
-  let proven = 0
-  let bad = 0
-  let na = 0
-  let notVerified = 0
-  for (const o of verdicts) {
-    switch (o.verify!.kind) {
-      case 'proven-deterministic':
-      case 'proven-complete':
-        proven++
-        break
-      case 'nondeterministic':
-      case 'rerun-failed':
-      case 'undeclared-inputs':
-        bad++
-        break
-      case 'allowed-nondeterministic':
-      case 'no-outputs':
-        na++
-        break
-      case 'not-verified':
-        notVerified++
-        break
-      case 'unverifiable-remote-only':
-        na++
-        break
-    }
-  }
-  const lines = [
-    '',
-    `  Verify:   ${proven} proven · ${bad} unsafe · ${na} n/a · ${notVerified} not-verified`,
-  ]
-  for (const o of outcomes) {
-    const v = o.verify
-    if (v === undefined) continue
-    if (v.kind === 'nondeterministic') {
-      lines.push(`    ✗ ${o.node.id} — nondeterministic`)
-      lines.push(`        changed: ${v.changed.join(', ')}`)
-    } else if (v.kind === 'undeclared-inputs') {
-      lines.push(`    ✗ ${o.node.id} — read undeclared inputs`)
-      if (v.paths.length > 0) lines.push(`        ${v.paths.join(', ')}`)
-      lines.push('        add them to cache.inputs.files / workspaceFiles')
-    } else if (v.kind === 'rerun-failed') {
-      lines.push(`    ✗ ${o.node.id} — verify re-run failed (exit ${v.exitCode})`)
-    } else if (v.kind === 'unverifiable-remote-only') {
-      lines.push(`    ⚠ ${o.node.id} — remote-only: no local execution to prove (unverified)`)
-    } else if (v.kind === 'allowed-nondeterministic') {
-      lines.push(`    ⚠ ${o.node.id} — nondeterministic (allowed)`)
-    }
-  }
-  return lines
-}

package/src/plugins/local-cache/index.ts

@@ -1,11 +0,0 @@
-// Core's cache as a plugin: the `.vx/cache` handle the host opened (the run
-// index + the local artifact store). Declared like any other cache layer;
-// put a remote layer BEFORE it to look there first.
-
-import type { VxPlugin } from '@vzn/vx'
-
-export const LOCAL_CACHE_PLUGIN = 'vx/local-cache'
-
-export function localCachePlugin(): VxPlugin {
-  return { name: LOCAL_CACHE_PLUGIN, cache: (ctx) => ctx.localCache }
-}

package/src/plugins/local-executor/index.ts

@@ -1,45 +0,0 @@
-// Core's executor as a plugin: spawn the task's command in-process, exactly
-// the `runCommand` / `runSandboxed` call the orchestrator used to make
-// directly. Imports core only through the public `@vzn/vx` surface so this
-// directory can become its own package unchanged.
-
-import { runCommand, runSandboxed, type TaskExecutor, type VxPlugin } from '@vzn/vx'
-
-export const LOCAL_EXECUTOR_PLUGIN = 'vx/local-executor'
-
-/** The executor itself — for tests and for plugins that wrap local execution. */
-export function localExecutor(): TaskExecutor {
-  return {
-    name: 'local',
-    async execute(req) {
-      const common = {
-        command: req.command,
-        cwd: req.cwd,
-        env: req.env,
-        forwardArgs: req.forwardArgs,
-        onStdout: req.onStdout,
-        onStderr: req.onStderr,
-        capture: req.capture,
-        ...(req.liveChildren !== undefined ? { liveChildren: req.liveChildren } : {}),
-        ...(req.timeoutMs !== undefined ? { timeoutMs: req.timeoutMs } : {}),
-      }
-      if (req.sandbox === undefined) {
-        const res = await runCommand(common)
-        return { ...res, violations: [] }
-      }
-      return await runSandboxed({
-        ...common,
-        baseAllowRead: req.sandbox.baseAllowRead,
-        baseAllowWrite: req.sandbox.baseAllowWrite,
-        baseDenyRead: req.sandbox.baseDenyRead,
-        config: req.sandbox.config,
-        settleOnCleanExit: req.sandbox.settleOnCleanExit,
-      })
-    },
-  }
-}
-
-/** Declare in vx.workspace.ts: `plugins: [localExecutorPlugin(), …]`. Accepts every task. */
-export function localExecutorPlugin(): VxPlugin {
-  return { name: LOCAL_EXECUTOR_PLUGIN, executor: () => localExecutor() }
-}