@vzn/vx 0.0.15 → 0.0.18

package/README.md

@@ -3,9 +3,13 @@
 **The fastest way to build a monorepo.**
 
 vx runs your task graph, remembers every result, and never does the
-same work twice. Fully cached runs finish in milliseconds — 144 ms
-across 100 packages, 0.62 s across a 1090-package graph of 3,270
-tasks. Measured, reproducible, on hardware you own.
+same work twice. Fully cached runs finish in milliseconds — 76 ms
+across 46 packages, 559 ms across a 1,090-package graph of 3,270 tasks,
+where Turborepo takes 760 ms and Nx 3.59 s on the identical workspace —
+and a cold build of that graph burns 34 s of CPU in vx, 73 s in Turborepo
+and 114 minutes in Nx.
+Measured, reproducible, on hardware you own
+([benchmarks](docs/benchmarks.md)).
 
 One binary. No daemon. No Node. Nothing to babysit.
 
@@ -15,9 +19,6 @@ architecture, caching, and the full CLI / config reference.
 ```sh
 # From npm — ships the prebuilt standalone binary (no Bun required):
 npm install -g @vzn/vx      # or: pnpm add -g @vzn/vx · bun add -g @vzn/vx
-
-# Or the zero-dependency install script (no Node/npm needed):
-curl -fsSL https://raw.githubusercontent.com/vznjs/vx/main/install.sh | sh
 ```
 
 ```ts
@@ -45,6 +46,7 @@ export default defineProject({
 ```
 
 ```sh
+vx init                   # scaffold vx.workspace.ts + a vx.config.ts per package from scripts
 vx run build              # cwd project + its workspace deps
 vx run test --all         # every project that declares `test`
 vx run ci --affected      # only what changed since origin/HEAD
@@ -52,58 +54,6 @@ vx watch lint             # re-run on file changes
 vx run build --dry        # show the plan, don't execute
 ```
 
-## Beyond a task runner — what shipped in the 2026-06 platform arc
-
-vx now ships an **open platform**, not just a CLI. Every surface
-below is built into the binary; no external services required.
-
-```sh
-vx mcp                                    # Model Context Protocol server (stdio)
-                                          # — Claude Code / Cursor / Continue.dev talk to vx as a typed tool
-
-npm i -g @vzn/vx-cloud                    # the service CLI — also a standalone binary, no Bun
-vx-cloud serve --ui --open                # team backend + embedded dashboard (token-authenticated)
-vx-cloud agent --url https://ci.acme.dev  # join a distributed-execution pool (Nx-Agents-style DTE)
-vx-cloud connect https://ci.acme.dev      # one-URL analytics + remote cache for every `vx run`
-```
-
-### Open platform highlights
-
-- **Provider-neutral core.** `vx` runs tasks and nothing else — the
-  dashboard, remote cache, distribution, and telemetry all arrive via
-  PLUGINS declared in `vx.workspace.ts`. `@vzn/vx-cloud` is the
-  first-party one; anyone can write another against the same seams
-  (backend / cache / telemetry).
-- **MCP for AI agents, twice.** `vx mcp` (stdio, reads your real
-  `cache.db`: `getCacheStats`, `getRunHistory`, `explainCacheKey`,
-  `whyDidThisRerun`) and `POST /mcp` on any `vx-cloud serve` — local
-  or hosted, behind the bearer token.
-- **Provable cache correctness.** `vx run --verify` re-runs each
-  cacheable task and byte-compares outputs; `--verify=inputs` runs it
-  sandboxed against the declared inputs and names any undeclared read.
-  The only runner that PROVES a cache entry safe instead of hoping.
-- **Distributed CI (DTE).** `vx-cloud agent` joins a session-keyed
-  pool; a `vx run` fans tasks out across same-commit agents, outputs
-  propagate through the shared artifact store, and a standing pool
-  multiplexes concurrent runs with fair scheduling.
-- **Remote cache, one URL.** `vx-cloud connect <url>` wires analytics
-  ingest AND a Turborepo-wire-compatible artifact store (HMAC signing,
-  trusted/untrusted tiers derived from the token). Third-party Turbo
-  cache servers work via two env vars.
-- **OTel CI/CD spans.** Declare `otel()` from `@vzn/vx-otel` in
-  `vx.workspace.ts` — OTLP/HTTP traces + metrics with ZERO
-  OpenTelemetry SDK dependency; runs flow to Grafana / Honeycomb /
-  Datadog, including `--verify` hermeticity verdicts as span status.
-- **Dashboard embedded in the `vx-cloud` binary.** Runs, flamegraphs,
-  live run cockpit with the task DAG, per-task logs + artifacts,
-  cache-key diffs ("why did this re-run?"), flaky-task detection.
-  Nothing to build or install; Docker image on ghcr for hosting.
-- **Predictive scheduling.** Opt in with `predictive: true` — the
-  scheduler reads run history and starts the longest expected critical
-  path first.
-
-Each surface lives behind a design doc under `docs/design/`.
-
 ## A cache that actually understands your build
 
 Every task runner caches. vx caches _correctly_ — and stops work
@@ -138,14 +88,10 @@ with the invariant that keeps it valid —
   `--verify=inputs` sandboxes it against the declared inputs and fails
   loud naming any undeclared read (completeness). No other runner can
   prove a cache entry safe.
-- **Signed artifacts.** HMAC signing on the remote-cache wire; with a
-  key configured, unsigned or tampered artifacts are rejected and the
-  task simply re-runs. A poisoned cache can't reach your machines.
-- **Cache trust tiers.** The server derives trusted/untrusted from the
-  bearer token — a fork-PR artifact can never feed a trusted build.
-- **Corruption can't go live.** Artifacts are validated before they
-  enter the store (zstd-bomb and oversize downloads refused); bad
-  bytes degrade to a cache miss, never a crash.
+- **Corruption can't go live.** A remote artifact is verified against
+  its content digest and validated before it enters the store
+  (zstd-bomb and oversize downloads refused); bad bytes degrade to a
+  cache miss, never a wrong hit and never a crash.
 - **Clean exits.** SIGINT/SIGTERM reap every child process — no
   orphaned dev servers in CI.
 - **Readiness you can bound.** Persistent tasks gate downstream work
@@ -183,33 +129,59 @@ TypeScript config with real imports · task graph with `^task`
 resolution that bridges packages without the task · multi-task runs
 with one shared graph · pnpm-style filters and `--affected` ·
 watch mode · `--dry` / `--graph` plans · persistent dev servers ·
-remote caching via one URL (or two env vars, wire-compatible with
-existing Turbo artifact servers) · retries, timeouts, `--continue`
-modes · per-layer cache control (`--cache=local:r,remote:`) ·
-`vx info`, `--summarize`, `--profile` Chrome traces, `--report` ·
-`vx cache prune` with TTL and size caps · `vx migrate` from
-turbo.json or an Nx graph.
+retries, timeouts, `--continue` modes · per-layer cache control
+(`--cache=local:r,remote:`) · `vx why` explains a re-run from the
+persisted input fingerprints · `vx last` replays a recorded run ·
+`vx prune` cuts a Docker-ready workspace subset · `vx info`,
+`--summarize`, `--profile` Chrome traces, `--report` · `vx cache prune`
+with TTL and size caps · `vx migrate` from turbo.json or an Nx graph.
+
+## A pipeline with seams — plugins decide what happens
+
+Core is the pipeline: discover projects, evaluate configs, build the
+task graph, derive keys, schedule, execute, cache, observe. Plugins
+declared in `vx.workspace.ts` hook each stage, Vite-style, on one
+`VxPlugin` object:
+
+| Stage     | Hook                       | A plugin can…                                               |
+| --------- | -------------------------- | ----------------------------------------------------------- |
+| workspace | `config(ws, ctx)`          | edit the workspace config before it is used                 |
+| project   | `project(config, ctx)`     | add, remove or rewrite a project's tasks (keyed like yours) |
+| graph     | `graph(nodes, ctx)`        | add or drop edges, mark tasks requested                     |
+| key       | `key(task, ctx)`           | fold extra material into the cache key (named in `vx why`)  |
+| schedule  | `schedule(nodes, ctx)`     | decide which ready task runs first                          |
+| execute   | `executor(ctx)`            | decide WHERE a task's command runs (local, a REAPI worker)  |
+| store     | `cache(ctx)`               | decide where artifacts live (local, a shared remote)        |
+| observe   | `telemetry(ctx)` / `setup` | receive every run record, or the raw event bus              |
+| cli       | `commands`                 | add verbs to `vx`                                           |
+
+Core applies **no plugin by default** — even its own local executor and
+cache are plugins your workspace declares, which is what makes "replace
+any part" real rather than promised. First-party plugins:
+[`@vzn/vx-reapi`](packages/vx-reapi) (Bazel Remote Execution API —
+remote cache and remote execution against NativeLink, BuildBuddy,
+Buildbarn or bazel-remote), [`@vzn/vx-otel`](packages/vx-otel)
+(OpenTelemetry traces + metrics + logs, zero SDK deps),
+[`@vzn/vx-github`](packages/vx-github) (Actions job summary + Checks
+API), [`@vzn/vx-mcp`](packages/vx-mcp) (`vx mcp` — a read-only Model
+Context Protocol server for AI coding agents, no SDK), and
+`@vzn/vx/plugins/schedule-history` (order by learned critical path). Nothing distributed ships in this repo; the seams are how you
+build it.
 
 ## How it compares
 
-|                           | vx                                                                    | Turborepo                      | Nx                  |
-| ------------------------- | --------------------------------------------------------------------- | ------------------------------ | ------------------- |
-| Fully cached, 100 pkgs¹   | **144 ms**                                                            | 279 ms                         | 583+ ms             |
-| Config                    | TypeScript, evaluated into the cache key                              | JSON (static)                  | JSON (static)       |
-| Output ownership          | **Strict** — wiped before exec AND restore                            | Additive (stale files survive) | Additive            |
-| Clean-tree hashing        | **Zero reads** (git index OIDs)                                       | git OIDs                       | re-hash / daemon    |
-| Daemon required for speed | **No**                                                                | Optional                       | Yes                 |
-| Artifact signing          | **Hard-fail** on unsigned                                             | Soft                           | No                  |
-| Per-task sandbox          | **Yes** — kernel-level, opt-in                                        | No                             | No                  |
-| Provable cache safety     | **Yes** — `--verify` (determinism) + `--verify=inputs` (completeness) | No                             | No                  |
-| MCP server for AI agents  | **Yes** (`vx mcp` stdio + `POST /mcp` on the serve)                   | No                             | No                  |
-| Distributed CI execution  | **Yes** — OSS, self-hostable (`vx-cloud agent`, Nx-DTE-style)         | No                             | Paid (Nx Cloud DTE) |
-| Dashboard SPA             | **Yes** — embedded in `vx-cloud serve --ui`: runs, logs, DAG, flaky   | No                             | Paid                |
-| Self-hosted cloud         | **Yes** — `vx-cloud` binary or the ghcr Docker image; one stack       | Vercel-only                    | No (proprietary)    |
-| Plugin API                | **Yes** — backend / cache / telemetry seams                           | No                             | Yes (TS-tied)       |
-| Predictive scheduling     | **Yes** (opt-in: `predictive: true`)                                  | No                             | No                  |
-| OTel CI/CD spans          | **Yes** — `otel()` plugin, zero OTel-SDK deps                         | No                             | Paid                |
-| Install                   | **Single binary** — npm or 1 curl line, no Node/Bun needed            | npm + Node                     | npm + Node          |
+|                           | vx                                                                    | Turborepo                      | Nx               |
+| ------------------------- | --------------------------------------------------------------------- | ------------------------------ | ---------------- |
+| Fully cached, 100 pkgs¹   | **144 ms**                                                            | 279 ms                         | 583+ ms          |
+| Config                    | TypeScript, evaluated into the cache key                              | JSON (static)                  | JSON (static)    |
+| Output ownership          | **Strict** — wiped before exec AND restore                            | Additive (stale files survive) | Additive         |
+| Clean-tree hashing        | **Zero reads** (git index OIDs)                                       | git OIDs                       | re-hash / daemon |
+| Daemon required for speed | **No**                                                                | Optional                       | Yes              |
+| Per-task sandbox          | **Yes** — kernel-level, opt-in                                        | No                             | No               |
+| Provable cache safety     | **Yes** — `--verify` (determinism) + `--verify=inputs` (completeness) | No                             | No               |
+| Plugin API                | **Yes** — executor / cache / telemetry seams                          | No                             | Yes (TS-tied)    |
+| OTel CI/CD spans          | **Yes** — `otel()` plugin, zero OTel-SDK deps                         | No                             | Paid             |
+| Install                   | **Single binary** — npm or 1 curl line, no Node/Bun needed            | npm + Node                     | npm + Node       |
 
 ¹ Wall-clock, direct binaries, same machine and workspace — full
 methodology and more scenarios in
@@ -259,7 +231,7 @@ Differences to know:
 - vx requires `cache.inputs.files` when caching is enabled (no default `$TURBO_DEFAULT$`).
 - vx defaults caching **off**; opt in per task by adding the `cache` block.
 - Persistent tasks: `persistent: { readyWhen: 'regex' }` (Turbo uses just `persistent: true`).
-- Remote cache: same wire format. Existing `VERCEL_*` / Turbo-cache-server tokens work via `VX_REMOTE_CACHE_TOKEN`.
+- Remote caching is a plugin, not a built-in — connect one and every `vx run` reads through it.
 
 Side-by-side feature matrix + every known gap: [`docs/comparison.md`](./docs/comparison.md).
 
@@ -268,16 +240,16 @@ Side-by-side feature matrix + every known gap: [`docs/comparison.md`](./docs/com
 `bin.ts → cli/index.ts` dispatches subcommands.
 `orchestrator/run.ts:run()` calls `prepareRun()` which discovers the
 workspace, loads configs, builds the package + task graph, opens the
-cache (local SQLite + optional remote layer), and installs plugins
+cache (local SQLite + an optional remote layer), and installs plugins
 from `vx.workspace.ts`. The two-tier scheduler runs the graph in
 topological order with bounded concurrency (confirmed cache hits
 restore ahead of their deps); each task hits the cache (hash → get →
 restore on hit; spawn → save on miss) or short-circuits as a group /
 persistent. Every observation flows through one event bus — the
-terminal renderer subscribes directly, and PLUGINS receive the
+terminal renderer subscribes directly, and plugins receive the
 versioned telemetry contract (`TelemetryRecord` / `RunSummaryRecord`)
-— that's how `otel()` and `cloud()` export without core knowing them.
-Core never imports a plugin; the arrow only points plugin → core.
+— that's how telemetry and cache plugins export without core knowing
+them. Core never imports a plugin; the arrow only points plugin → core.
 Every module has a docs page; every interface is a swappable seam.
 
 Read [`docs/architecture.md`](./docs/architecture.md) for the module
@@ -285,9 +257,8 @@ map; the design record lives under [`docs/design/`](./docs/design/).
 
 ## Documentation
 
-Full technical docs live under [`docs/`](./docs/):
-
-**Core**
+Full technical docs live under [`docs/`](./docs/) and on the
+[documentation site](https://vznjs.github.io/vx/):
 
 - [`docs/architecture.md`](./docs/architecture.md) — module map + data flow
 - [`docs/schema.md`](./docs/schema.md) — every config field
@@ -297,52 +268,42 @@ Full technical docs live under [`docs/`](./docs/):
 - [`docs/comparison.md`](./docs/comparison.md) — Turbo / Nx / vite-task feature matrix
 - [`docs/modules/`](./docs/modules/) — one reference page per source module
 
-**Design + 2026-06 platform arc** (`docs/design/`)
-
-- [`architecture-north-star-2026-06.md`](./docs/design/architecture-north-star-2026-06.md) — the unified vision
-- [`architecture-review-2026-06.md`](./docs/design/architecture-review-2026-06.md) — review + applied checklist
-- [`wire-protocol-2026-06.md`](./docs/design/wire-protocol-2026-06.md) — JSON-RPC 2.0 + OTel envelope (shipped)
-- [`distributed-ci-2026-06.md`](./docs/design/distributed-ci-2026-06.md) — original coordinator/worker (superseded by `vx-cloud agent` DTE — `distributed-execution-2026-07.md`)
-- [`vx-cloud-2026-06.md`](./docs/design/vx-cloud-2026-06.md) — original CF cloud (superseded by the standalone `vx-cloud` service)
-- [`extension-protocol-2026-06.md`](./docs/design/extension-protocol-2026-06.md) — subscriber/inspector/driver/plugin (Phase 1 shipped)
-- [`predictive-execution-2026-06.md`](./docs/design/predictive-execution-2026-06.md) — history-aware scheduling (Phase A-B shipped)
-- [`docs/progress/implementation-log-2026-06.md`](./docs/progress/implementation-log-2026-06.md) — phase-by-phase narrative
+The design record lives under [`docs/design/`](./docs/design/); the
+maintainers' handoff is [`docs/STATUS.md`](./docs/STATUS.md).
 
 ## Status
 
 **Pre-alpha.** The schema is settling; we bump `CACHE_VERSION` rather
-than maintain back-compat. **1,400+ tests (core + packages); CI green
-on every commit**; the project dogfoods itself (`vx run ci`).
-Published on npm: [`@vzn/vx`](https://www.npmjs.com/package/@vzn/vx)
-and `@vzn/vx-cloud`, both as prebuilt standalone binaries.
+than maintain back-compat. **~2,500 core tests plus the package suites; CI green on every commit**;
+the project dogfoods itself (`vx run ci`). Published on npm:
+[`@vzn/vx`](https://www.npmjs.com/package/@vzn/vx) (a prebuilt standalone
+binary).
 
 Production readiness for the **core task runner**: the semantics are
-solid. The main operational rough edge is Windows (unsupported).
-
-Production readiness for the **platform layer**:
-
-| Surface                                        | Maturity                         | Notes                                                            |
-| ---------------------------------------------- | -------------------------------- | ---------------------------------------------------------------- |
-| Core task runner + caching                     | **production-ready**             | dogfooded continuously; 1,150+ core tests, all green             |
-| `vx run --verify` (provable cache correctness) | **shippable**                    | determinism + input-completeness proofs; CI-gate recipe in docs  |
-| `vx mcp` + serve `POST /mcp`                   | **shippable**                    | live cache.db tools (stdio); serve-hosted MCP behind the bearer  |
-| `vx-cloud serve` (ingest + dashboard + /v8)    | **shippable**                    | token-auth, multi-workspace, artifact store, ghcr image          |
-| `vx-cloud agent` distributed execution         | **shippable for self-hosted CI** | session-keyed DTE, shared pools, fair multi-run scheduling       |
-| Plugin API (backend / cache / telemetry)       | **shippable**                    | crash-isolated; `cloud()` + `otel()` are ordinary plugins        |
-| Predictive scheduling                          | **shippable as opt-in**          | gated on `predictive: true` + observed data                      |
-| Dashboard SPA (embedded in `vx-cloud`)         | **iterating**                    | runs/logs/DAG/flaky live; data-first entity redesign in progress |
-| OTel export (`@vzn/vx-otel`)                   | **shippable**                    | declare `otel()` in `vx.workspace.ts`; OTLP traces + metrics     |
+solid; it is dogfooded continuously. The main operational rough edge
+is Windows (unsupported).
+
+| Surface                                          | Maturity             | Notes                                                                        |
+| ------------------------------------------------ | -------------------- | ---------------------------------------------------------------------------- |
+| Core task runner + caching                       | **production-ready** | dogfooded continuously; ~2,500 core tests + the package suites, green        |
+| `vx run --verify` (provable cache correctness)   | **shippable**        | determinism + input-completeness proofs; CI-gate recipe in docs              |
+| Plugin pipeline (9 hooks, `commands` included)   | **shippable**        | crash-isolated, re-validated; core's own executor + cache are plugins        |
+| `vx init` / `vx migrate` (scripts, Turbo, Nx)    | **shippable**        | one config per package, TODOs where a source cannot say                      |
+| REAPI remote cache + execution (`@vzn/vx-reapi`) | **shippable**        | Bazel AC + CAS + Execute; NativeLink / BuildBuddy / Buildbarn / bazel-remote |
+| OTel export (`@vzn/vx-otel`)                     | **shippable**        | OTLP traces + metrics + logs, zero SDK deps                                  |
+| GitHub Actions (`@vzn/vx-github`)                | **shippable**        | job summary + Checks API run                                                 |
+| MCP server (`@vzn/vx-mcp`)                       | **shippable**        | `vx mcp` — read-only tools for AI agents, no SDK                             |
 
 ## Development
 
 ```sh
 git clone https://github.com/vznjs/vx && cd vx
 bun install
-bun src/bin.ts run ci          # format-check + lint + test
-bun src/bin.ts run build       # cross-target binaries → dist/
+bun packages/vx/src/bin.ts run ci --all     # lint + test + docs build, every package
+bun packages/vx/src/bin.ts run build --filter @vzn/vx   # cross-target binaries → packages/vx/dist/
 ```
 
-vx is self-hosted: every dev task routes through `bun src/bin.ts run <task>` per the repo's own `vx.config.ts`. No `package.json` scripts; CI invokes vx directly.
+vx is self-hosted: every dev task routes through `bun packages/vx/src/bin.ts run <task>` per each package's own `vx.config.ts`. No `package.json` scripts; CI invokes vx directly. Start with [`docs/STATUS.md`](docs/STATUS.md) — the living handoff — and `CLAUDE.md`.
 
 ## License
 

package/index.ts

@@ -0,0 +1,10 @@
+// Root entry shim. Bun 1.4.0's `--compile` binaries resolve an on-disk
+// package by directory convention (`<pkg>/index.ts`, `<pkg>/<subpath>/index.ts`)
+// and ignore package.json `exports` / `main` (measured 2026-09-03: an
+// entry of `./src/index.ts` resolved to the root `index.ts` regardless of the
+// manifest, and a package with no root file was "not found"). Without this
+// file every `import … from '@vzn/vx'` in a workspace config fails under the
+// standalone binary. The exports map still wins everywhere else and points
+// at the same module, so this is one extra hop for the binary and nothing
+// for anyone else.
+export * from './src/index.js'

package/launcher.mjs

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 // npm launcher for a vx command — the entry a published package's `bin` points
 // at. It execs the prebuilt standalone binary shipped as a per-platform
-// optionalDependency, so end users get the command WITHOUT installing Bun. ONE
-// launcher serves both `@vzn/vx` and `@vzn/vx-cloud`: everything is derived from
-// this package's OWN name, read from the package.json sitting beside this file.
+// optionalDependency, so end users get the command WITHOUT installing Bun.
+// Everything is derived from this package's OWN name, read from the
+// package.json sitting beside this file, so any package built by
+// scripts/build-npm.ts can carry it:
 //
-//   @vzn/vx        → platform pkg @vzn/vx-<key>,        binary `vx`
-//   @vzn/vx-cloud  → platform pkg @vzn/vx-cloud-<key>,  binary `vx-cloud`
+//   @vzn/vx → platform pkg @vzn/vx-<key>, binary `vx`
 //
 // Resolution order:
 //   1. the matching <name>-<platform> optionalDependency's binary (the normal
@@ -26,11 +26,10 @@ const require = createRequire(import.meta.url)
 const here = dirname(fileURLToPath(import.meta.url))
 const pkg = require('./package.json')
 
-// Derive the platform-package prefix + binary basename from this package's name
-// so the same launcher works for @vzn/vx and @vzn/vx-cloud. `base` is the
-// unscoped name (vx / vx-cloud) — the command AND the binary filename inside the
-// platform package. `vxSourceEntry` (a package.json field) is the source-mode
-// entry: `src/bin.ts` for vx, `src/cli/bin.ts` for vx-cloud.
+// Derive the platform-package prefix + binary basename from this package's
+// name. `base` is the unscoped name — the command AND the binary filename
+// inside the platform package. `vxSourceEntry` (a package.json field) is the
+// source-mode entry, `src/bin.ts` by default.
 const name = pkg.name
 const base = name.replace(/^@[^/]+\//, '')
 const sourceEntry = pkg.vxSourceEntry ?? 'src/bin.ts'
@@ -86,7 +85,7 @@ process.stderr.write(
   `${base}: no prebuilt binary for ${key}.\n` +
     `  Supported platforms: ${supported}.\n` +
     `  If your platform should be supported, reinstall so npm fetches the\n` +
-    `  matching ${name}-${key} optionalDependency, or install Bun (>=1.3) to\n` +
+    `  matching ${name}-${key} optionalDependency, or install Bun (>=1.4) to\n` +
     `  run ${base} from source.\n`,
 )
 process.exit(1)

package/package.json

@@ -1,12 +1,24 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.15",
+  "version": "0.0.18",
   "description": "An open, extensible monorepo task runner.",
   "type": "module",
   "exports": {
     ".": {
       "types": "./src/index.ts",
       "import": "./src/index.ts"
+    },
+    "./plugins/local-executor": {
+      "types": "./src/plugins/local-executor/index.ts",
+      "import": "./src/plugins/local-executor/index.ts"
+    },
+    "./plugins/local-cache": {
+      "types": "./src/plugins/local-cache/index.ts",
+      "import": "./src/plugins/local-cache/index.ts"
+    },
+    "./plugins/schedule-history": {
+      "types": "./src/plugins/schedule-history/index.ts",
+      "import": "./src/plugins/schedule-history/index.ts"
     }
   },
   "types": "./src/index.ts",
@@ -17,15 +29,17 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.15",
-    "@vzn/vx-linux-arm64": "0.0.15",
-    "@vzn/vx-darwin-x64": "0.0.15",
-    "@vzn/vx-darwin-arm64": "0.0.15"
+    "@vzn/vx-linux-x64": "0.0.18",
+    "@vzn/vx-linux-arm64": "0.0.18",
+    "@vzn/vx-darwin-x64": "0.0.18",
+    "@vzn/vx-darwin-arm64": "0.0.18"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.56"
   },
   "files": [
+    "index.ts",
+    "plugins",
     "src",
     "launcher.mjs",
     "README.md",

package/plugins/local-cache/index.ts

@@ -0,0 +1,2 @@
+// Subpath shim for Bun's compiled binaries — see ../../index.ts.
+export * from '../../src/plugins/local-cache/index.js'

package/plugins/local-executor/index.ts

@@ -0,0 +1,2 @@
+// Subpath shim for Bun's compiled binaries — see ../../index.ts.
+export * from '../../src/plugins/local-executor/index.js'

package/plugins/schedule-history/index.ts

@@ -0,0 +1,2 @@
+// Subpath shim for Bun's compiled binaries — see ../../index.ts.
+export * from '../../src/plugins/schedule-history/index.js'

package/src/bin.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 import { run } from './cli/index.js'
-import { UserError } from './util/index.js'
+import { isUserError } from './util/index.js'
 
 // Wrapped in an explicit async main so `bun build --compile` accepts
 // the file. The compile target doesn't allow top-level await.
@@ -12,7 +12,7 @@ async function main(): Promise<void> {
     // print the message only; the stack is noise the user can't act
     // on. Everything else gets the full stack so internal bugs are
     // debuggable.
-    if (err instanceof UserError) {
+    if (isUserError(err)) {
       process.stderr.write(`vx: ${err.message}\n`)
     } else {
       const message = err instanceof Error ? (err.stack ?? err.message) : String(err)