@vzn/vx 0.0.16 → 0.0.18

package/src/cli/mcp.ts

@@ -1,92 +0,0 @@
-// `vx mcp` — Model Context Protocol server adapter.
-//
-// Exposes vx as a typed tool surface to AI agents (Claude Code, Cursor,
-// Continue.dev, etc.). The MCP envelope is JSON-RPC 2.0 — the same
-// envelope wire-protocol-2026-06.md commits to — so this adapter is a
-// thin mapping layer: MCP tool calls dispatch to internal RPC methods.
-//
-// stdio transport in v1: every relevant agent client runs servers over
-// stdio. Streamable HTTP is a follow-up; the SDK supports both, dispatch
-// is identical, only the transport object changes.
-//
-// Tools exposed:
-//   runTasks(tasks: string[], cwd?: string)
-//   getCacheStats(scope?: 'all' | { project: string })
-//   getRunHistory({ project?, task?, limit? })
-//   explainCacheKey(taskId)
-//   whyDidThisRerun({ runId, taskId })
-//
-// The implementations live in `src/cli/mcp-rpc.ts` so a future WS-side
-// inspector can reuse them without duplicating logic.
-
-import { UserError } from '../util/index.js'
-import { VERSION } from '../version.js'
-import { handleMcpRequest, listMcpTools, type McpToolDef } from './mcp-rpc.js'
-
-export interface McpArgs {
-  /** stdio (default) | http (deferred to a follow-up) */
-  transport: 'stdio'
-}
-
-export function parseMcpArgs(args: readonly string[]): McpArgs {
-  for (const a of args) {
-    if (a === '--http') {
-      throw new UserError('vx mcp --http is not yet implemented; use stdio (default)')
-    }
-    if (a !== '--stdio') {
-      throw new UserError(`vx mcp: unknown flag ${a}`)
-    }
-  }
-  return { transport: 'stdio' }
-}
-
-export async function mcpCmd(args: readonly string[]): Promise<number> {
-  parseMcpArgs(args) // validate flags; defaults to stdio
-  let StdioServerTransport: any
-  let McpServer: any
-  try {
-    const sdkServer = await import('@modelcontextprotocol/sdk/server/index.js')
-    const sdkStdio = await import('@modelcontextprotocol/sdk/server/stdio.js')
-    McpServer = (sdkServer as { Server: any }).Server
-    StdioServerTransport = (sdkStdio as { StdioServerTransport: any }).StdioServerTransport
-  } catch {
-    throw new UserError(
-      `vx mcp requires @modelcontextprotocol/sdk to be installed. ` +
-        `Add it to your package.json or install with: bun add @modelcontextprotocol/sdk`,
-    )
-  }
-
-  const server = new McpServer(
-    { name: 'vx', version: VERSION },
-    { capabilities: { tools: {}, resources: {} } },
-  )
-
-  // Tool listing
-  const sdkTypes = await import('@modelcontextprotocol/sdk/types.js')
-  server.setRequestHandler(
-    (sdkTypes as { ListToolsRequestSchema: any }).ListToolsRequestSchema,
-    async () => ({
-      tools: listMcpTools().map((t: McpToolDef) => ({
-        name: t.name,
-        description: t.description,
-        inputSchema: t.inputSchema,
-      })),
-    }),
-  )
-
-  // Tool call dispatch
-  server.setRequestHandler(
-    (sdkTypes as { CallToolRequestSchema: any }).CallToolRequestSchema,
-    async (req: { params: { name: string; arguments?: unknown } }) => {
-      const result = await handleMcpRequest(req.params.name, req.params.arguments)
-      return {
-        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-      }
-    },
-  )
-
-  const transport = new StdioServerTransport()
-  await server.connect(transport)
-  await new Promise(() => undefined) // run until stdin closes
-  return 0
-}

package/src/orchestrator/devframe-surface.ts

@@ -1,74 +0,0 @@
-// The devframe surface for a vx run: one definition that exposes the run
-// as a live streaming channel (`vx:events`, the raw WireEvent feed) plus a
-// patch-synced shared state (`vx:run`, the reduced RunState aggregate).
-// A host adapter (dev server / MCP — see cli wiring) mounts this same
-// definition; this module owns only the translation from our in-process
-// event bus into devframe's streaming + shared-state primitives.
-//
-// devframe is touched ONLY through type-only imports here, so core `vx`
-// never gains a runtime dependency on it — the host that actually boots a
-// devframe server imports the runtime adapter dynamically and is the
-// optional, opt-in path. See docs/design/event-stream-2026-06.md.
-
-import type { DevframeDefinition, DevframeNodeContext, RpcStreamingChannel } from 'devframe'
-import { VERSION } from '../version.js'
-import { toWireEvent, type EventBus, type WireEvent } from './events.js'
-import { initRunState, reduce, type RunState } from './run-state.js'
-
-// Type the `vx:run` shared-state key so `ctx.rpc.sharedState.get` is
-// checked against our aggregate shape.
-declare module 'devframe' {
-  interface DevframeRpcSharedStates {
-    'vx:run': RunState
-  }
-}
-
-export interface VxSurfaceOptions {
-  /** Stream id for the run's event feed. One run → one stream. */
-  streamId?: string
-}
-
-/**
- * Build a devframe definition that mirrors a single run's bus onto
- * devframe's wire. `setup` runs at host boot (before the run emits), so
- * it subscribes to the bus, forwards every event onto the `vx:events`
- * stream, and folds it into the `vx:run` shared state. The host syncs
- * both to any connected client (web SPA, MCP resource).
- */
-export function createVxSurface(bus: EventBus, options: VxSurfaceOptions = {}): DevframeDefinition {
-  const streamId = options.streamId ?? 'run'
-  return {
-    id: 'vx',
-    name: 'vx',
-    version: VERSION,
-    async setup(ctx: DevframeNodeContext) {
-      const channel: RpcStreamingChannel<WireEvent> = ctx.rpc.streaming.create('vx:events')
-      const stream = channel.start({ id: streamId })
-      const state = await ctx.rpc.sharedState.get('vx:run', { initialValue: initRunState() })
-
-      // Local snapshot fed to `reduce`; the shared state is updated by
-      // assigning the new snapshot onto its draft (pure reduce → diffable
-      // patch). Kept beside the shared state rather than read back from it
-      // so reduction never depends on devframe's immutable accessors.
-      let snapshot = initRunState()
-      // `run()` emits `run:end` more than once (the normal end + a `finally`
-      // safety call) plus summary `run:status` lines AFTER the first
-      // `run:end`. Once the stream is closed, ignore everything — writing
-      // to a closed stream throws (StreamClosedError), and the run is over.
-      let closed = false
-
-      bus.subscribe((event) => {
-        if (closed) return
-        stream.write(toWireEvent(event))
-        snapshot = reduce(snapshot, event)
-        state.mutate((draft) => {
-          Object.assign(draft, snapshot)
-        })
-        if (event.kind === 'run:end') {
-          stream.close()
-          closed = true
-        }
-      })
-    },
-  }
-}

package/src/orchestrator/predict.ts

@@ -1,106 +0,0 @@
-// Predictive scheduling — use HistoryTable to compute expected
-// remaining critical-path duration per node. Replaces the scheduler's
-// graph-counter heuristic priority for runs that opt in via
-// defineWorkspace({ predictive: true }) (predictive-execution-2026-06.md
-// Phase B + architecture-review-2026-06.md §8.4).
-//
-// Pure functions; no side effects; tested standalone. The scheduler
-// reads the priorities at queue time, picks the max.
-
-import type { TaskNode } from '../graph/index.js'
-import type { HistoryTable } from './history.js'
-
-/** Default duration when neither task history nor workspace median exists. */
-const DEFAULT_DURATION_MS = 1000
-
-/**
- * For each node, the expected remaining critical-path duration (its own
- * p50 + the max over its dependents). Cache hits are NOT modeled as
- * zero-cost here because predicting cache state requires knowing the
- * key + probing the layer — the run-time scheduler can flip the
- * priority once a hit is observed; the upfront estimate is "what if
- * everything ran."
- */
-export function computePredictedPriorities(
-  nodes: readonly TaskNode[],
-  history: HistoryTable,
-): ReadonlyMap<string, number> {
-  // Workspace-median fallback: across every history entry that has a
-  // p50, pick the median of those p50s. If history is sparse, fall
-  // back to DEFAULT_DURATION_MS.
-  const p50s: number[] = []
-  for (const h of history.values()) {
-    if (h.p50DurationMs !== undefined) p50s.push(h.p50DurationMs)
-  }
-  p50s.sort((a, b) => a - b)
-  const workspaceMedian =
-    p50s.length > 0
-      ? (p50s[Math.floor(p50s.length / 2)] ?? DEFAULT_DURATION_MS)
-      : DEFAULT_DURATION_MS
-
-  // Build a reverse-adjacency map so we can resolve dependents per
-  // node in O(1). The TaskNode graph carries dependsOn (upstream); we
-  // invert.
-  const dependentsOf = buildDependentsIndex(nodes)
-  const ownDuration = (n: TaskNode): number => {
-    const h = history.get(n.id)
-    return h?.p50DurationMs ?? workspaceMedian
-  }
-
-  // Memoized topo-DP. visit[id] = the expected critical path FROM this
-  // node down to a leaf. We compute bottom-up using a stack-based
-  // walker — iterative to avoid V8 stack-frame ceilings on deep graphs.
-  const memo = new Map<string, number>()
-  const nodeById = new Map<string, TaskNode>(nodes.map((n) => [n.id, n]))
-
-  const stack: TaskNode[] = nodes.slice()
-  // First pass: ensure deepest-first ordering via post-order traversal.
-  const order: TaskNode[] = []
-  const visited = new Set<string>()
-  while (stack.length > 0) {
-    const top = stack[stack.length - 1]!
-    if (visited.has(top.id)) {
-      stack.pop()
-      continue
-    }
-    const deps = dependentsOf.get(top.id) ?? []
-    let pushed = false
-    for (const d of deps) {
-      const n = nodeById.get(d)
-      if (n && !visited.has(n.id) && !stack.includes(n)) {
-        stack.push(n)
-        pushed = true
-        break
-      }
-    }
-    if (!pushed) {
-      visited.add(top.id)
-      order.push(top)
-      stack.pop()
-    }
-  }
-
-  for (const n of order) {
-    const own = ownDuration(n)
-    let downstream = 0
-    for (const dep of dependentsOf.get(n.id) ?? []) {
-      const d = memo.get(dep) ?? 0
-      if (d > downstream) downstream = d
-    }
-    memo.set(n.id, own + downstream)
-  }
-
-  return memo
-}
-
-function buildDependentsIndex(nodes: readonly TaskNode[]): Map<string, string[]> {
-  const out = new Map<string, string[]>()
-  for (const n of nodes) {
-    for (const upstreamId of n.deps) {
-      const list = out.get(upstreamId)
-      if (list) list.push(n.id)
-      else out.set(upstreamId, [n.id])
-    }
-  }
-  return out
-}

package/src/orchestrator/protocol.ts

@@ -1,156 +0,0 @@
-// The client↔service wire contract. A `vx run` client submits a
-// `RunRequest`; the service streams `WireEvent`s and returns a
-// `RunResult`. Transport-agnostic by design — the same messages travel a
-// local unix/ws hop today or a hosted `wss://` link tomorrow. Pure types +
-// the RunOptions⇄RunRequest mapping; no transport, no execution here.
-
-import type { CachePolicy } from '../cache/index.js'
-import type { ContinueMode } from '../graph/index.js'
-import type { OutcomeView, WireEvent } from './events.js'
-import type { RunOptions } from './options.js'
-
-/**
- * The serializable subset of `RunOptions` a client sends to the service.
- * Omits the non-serializable / host-side fields (`log`, `bus`,
- * `handleSignals`) — those are the service's concern.
- */
-export interface RunRequest {
-  tasks: readonly string[]
-  cwd: string
-  projects?: readonly string[]
-  concurrency?: number
-  cache?: CachePolicy
-  /** `--cache-dir <path>` override (cwd-relative). */
-  cacheDir?: string
-  continueMode?: ContinueMode
-  frozen?: boolean
-  /** Run-level retry default (`--retry <n>`); explicit `exec.retries` wins. */
-  retries?: number
-  /** Run-level task-timeout default (ms); per-task `exec.timeout` wins. */
-  timeout?: number
-  /** Explicit `--memory` budget (bytes) for `exec.resources` packing; the
-   *  default (executing side's os.totalmem()) resolves where tasks run. */
-  memory?: number
-  /** Cache-correctness verification (`--verify`); `allow` as an array (Sets
-   *  don't serialize). `fingerprint` is additive-optional — an old serve
-   *  ignores it, so a delegated `=fingerprint` run against an old serve
-   *  degrades to a harmless no-op verify. */
-  verify?: {
-    determinism: boolean
-    inputs: boolean
-    fingerprint?: boolean
-    allow: readonly string[]
-  }
-  flow?: 'focused' | 'broad'
-  outputLogs?: 'full' | 'errors-only' | 'none'
-  excludeDependencies?: 'all' | readonly string[]
-  forwardArgs?: readonly string[]
-  summarize?: string
-  profile?: string
-  /** Free-form key/value labels from `--tag`, persisted on the invocation row. */
-  tags?: Record<string, string>
-  /** The raw `vx run …` command string, recorded on the invocation row. */
-  command?: string
-}
-
-export interface RunResult {
-  ok: boolean
-  outcomes: OutcomeView[]
-}
-
-/**
- * Where a `vx run` executes. The client submits a serializable
- * `RunRequest` and gets back a `RunResult`; it neither knows nor cares
- * whether the work happened in-process or was delegated to a service.
- * This is the currency of the `backend` plugin capability — part of the
- * public wire contract (it lives here, not in `cli`, so a plugin can
- * reference it without a `cli` import).
- */
-export interface RunBackend {
-  run(request: RunRequest): Promise<RunResult>
-}
-
-/**
- * service → client. The submitter contract: an event stream, a final
- * result, or an error. The distributed-execution variants
- * (`task:assign`/`agent:refused`/`coord:drain`) live in a distribution
- * plugin's protocol module — its WS handler unions this with those.
- */
-export type ServerMessage =
-  | { t: 'event'; event: WireEvent }
-  | { t: 'result'; result: RunResult }
-  | { t: 'error'; message: string }
-
-/**
- * client → service. The submitter contract: a run submission. The
- * agent-side `agent:*` family lives in a distribution plugin's protocol
- * module.
- */
-export type ClientMessage = { t: 'run'; request: RunRequest }
-
-/** Project resolved `RunOptions` down to the serializable request. */
-export function optionsToRequest(options: RunOptions): RunRequest {
-  const req: RunRequest = { tasks: options.tasks, cwd: options.cwd }
-  if (options.projects !== undefined) req.projects = options.projects
-  if (options.concurrency !== undefined) req.concurrency = options.concurrency
-  if (options.cache !== undefined) req.cache = options.cache
-  if (options.cacheDir !== undefined) req.cacheDir = options.cacheDir
-  if (options.continueMode !== undefined) req.continueMode = options.continueMode
-  if (options.frozen !== undefined) req.frozen = options.frozen
-  if (options.retries !== undefined) req.retries = options.retries
-  if (options.timeout !== undefined) req.timeout = options.timeout
-  if (options.memory !== undefined) req.memory = options.memory
-  if (options.verify !== undefined)
-    req.verify = {
-      determinism: options.verify.determinism,
-      inputs: options.verify.inputs,
-      fingerprint: options.verify.fingerprint,
-      allow: [...options.verify.allow],
-    }
-  if (options.flow !== undefined) req.flow = options.flow
-  if (options.outputLogs !== undefined) req.outputLogs = options.outputLogs
-  if (options.excludeDependencies !== undefined)
-    req.excludeDependencies = options.excludeDependencies
-  if (options.forwardArgs !== undefined) req.forwardArgs = options.forwardArgs
-  if (options.summarize !== undefined) req.summarize = options.summarize
-  if (options.profile !== undefined) req.profile = options.profile
-  if (options.tags !== undefined) req.tags = options.tags
-  if (options.command !== undefined) req.command = options.command
-  return req
-}
-
-/**
- * Rebuild `RunOptions` from a request, for the side that actually executes
- * (the local backend, or the service). The caller adds the host-side
- * fields it needs (`bus`, `log`, `handleSignals`).
- */
-export function requestToOptions(request: RunRequest): RunOptions {
-  const options: RunOptions = { cwd: request.cwd, tasks: [...request.tasks] }
-  if (request.projects !== undefined) options.projects = [...request.projects]
-  if (request.concurrency !== undefined) options.concurrency = request.concurrency
-  if (request.cache !== undefined) options.cache = request.cache
-  if (request.cacheDir !== undefined) options.cacheDir = request.cacheDir
-  if (request.continueMode !== undefined) options.continueMode = request.continueMode
-  if (request.frozen !== undefined) options.frozen = request.frozen
-  if (request.retries !== undefined) options.retries = request.retries
-  if (request.timeout !== undefined) options.timeout = request.timeout
-  if (request.memory !== undefined) options.memory = request.memory
-  if (request.verify !== undefined)
-    options.verify = {
-      determinism: request.verify.determinism,
-      inputs: request.verify.inputs,
-      fingerprint: request.verify.fingerprint ?? false,
-      allow: new Set(request.verify.allow),
-    }
-  if (request.flow !== undefined) options.flow = request.flow
-  if (request.outputLogs !== undefined) options.outputLogs = request.outputLogs
-  if (request.excludeDependencies !== undefined) {
-    options.excludeDependencies = request.excludeDependencies
-  }
-  if (request.forwardArgs !== undefined) options.forwardArgs = request.forwardArgs
-  if (request.summarize !== undefined) options.summarize = request.summarize
-  if (request.profile !== undefined) options.profile = request.profile
-  if (request.tags !== undefined) options.tags = request.tags
-  if (request.command !== undefined) options.command = request.command
-  return options
-}

package/src/orchestrator/run-state.ts

@@ -1,145 +0,0 @@
-// The derived run aggregate — the single view-model every surface holds.
-// Raw RunEvents are the source of truth; this reduces them into the same
-// counters/per-task status the terminal summary already renders, so a
-// web/TUI/MCP surface can render reactively from one place instead of
-// re-deriving. A devframe shared-state holds a RunState and re-reduces on
-// each event; the terminal keeps its own inline counters (byte-identical,
-// untouched). See docs/design/event-stream-2026-06.md.
-
-import { isGroupTask, type TaskStatus } from '../graph/index.js'
-import type { RunEvent } from './events.js'
-
-/** Per-task lifecycle as seen by a surface. */
-export type TaskState = 'running' | TaskStatus
-
-export interface TaskRecord {
-  id: string
-  state: TaskState
-  /** Final duration once complete; absent while running. */
-  durationMs?: number
-  /** True for a persistent task left running after its outcome landed. */
-  persistent?: boolean
-}
-
-/** Cache-miss duration spread — the same numbers the final summary shows. */
-export interface Spread {
-  maxMs: number
-  minMs: number
-  sumMs: number
-  count: number
-}
-
-export interface RunState {
-  total: number
-  done: number
-  failed: number
-  succeeded: number
-  upToDate: number
-  restoredLocal: number
-  restoredRemote: number
-  skipped: number
-  /** Ids currently executing (a worker holds them). */
-  running: string[]
-  /** Per-task records, keyed by id. Group tasks are excluded (no work). */
-  tasks: Record<string, TaskRecord>
-  spread: Spread | null
-}
-
-export function initRunState(total = 0): RunState {
-  return {
-    total,
-    done: 0,
-    failed: 0,
-    succeeded: 0,
-    upToDate: 0,
-    restoredLocal: 0,
-    restoredRemote: 0,
-    skipped: 0,
-    running: [],
-    tasks: {},
-    spread: null,
-  }
-}
-
-/**
- * Fold one event into the aggregate, returning a NEW state (pure — never
- * mutates `prev`, so it's safe to feed a devframe `sharedState.mutate`
- * that diffs old vs new). Mirrors `defaultLogger`'s inline bookkeeping:
- * group tasks (no exec) are ignored, an `aborted` task reverts to pending
- * (freed, never counted), and the spread tracks success+failed only.
- */
-export function reduce(prev: RunState, event: RunEvent): RunState {
-  switch (event.kind) {
-    case 'run:start':
-      return initRunState(event.info.total)
-
-    case 'task:start': {
-      if (isGroupTask(event.node)) return prev
-      const id = event.node.id
-      return {
-        ...prev,
-        running: [...prev.running, id],
-        tasks: { ...prev.tasks, [id]: { id, state: 'running' } },
-      }
-    }
-
-    case 'task:complete': {
-      if (isGroupTask(event.node)) return prev
-      const id = event.node.id
-      const { status, durationMs } = event.outcome
-      const running = prev.running.filter((r) => r !== id)
-
-      // Aborted (killed by a shutdown signal): free the slot, count
-      // nothing, drop the record — the run is tearing down.
-      if (status === 'aborted') {
-        const tasks = { ...prev.tasks }
-        delete tasks[id]
-        return { ...prev, running, tasks }
-      }
-
-      const persistent = event.node.config.exec?.persistent !== undefined && status === 'success'
-      const next: RunState = {
-        ...prev,
-        done: prev.done + 1,
-        running,
-        tasks: {
-          ...prev.tasks,
-          [id]: { id, state: status, durationMs, ...(persistent ? { persistent: true } : {}) },
-        },
-      }
-      switch (status) {
-        case 'success':
-          next.succeeded = prev.succeeded + 1
-          break
-        case 'cache-hit':
-          if (event.outcome.restored === false) next.upToDate = prev.upToDate + 1
-          else next.restoredLocal = prev.restoredLocal + 1
-          break
-        case 'cache-hit-remote':
-          if (event.outcome.restored === false) next.upToDate = prev.upToDate + 1
-          else next.restoredRemote = prev.restoredRemote + 1
-          break
-        case 'failed':
-          next.failed = prev.failed + 1
-          break
-        case 'skipped':
-          next.skipped = prev.skipped + 1
-          break
-      }
-      if (status === 'success' || status === 'failed') {
-        const s = prev.spread
-        next.spread = {
-          maxMs: Math.max(s?.maxMs ?? 0, durationMs),
-          minMs: Math.min(s?.minMs ?? Infinity, durationMs),
-          sumMs: (s?.sumMs ?? 0) + durationMs,
-          count: (s?.count ?? 0) + 1,
-        }
-      }
-      return next
-    }
-
-    // stdout/stderr/status/end carry no aggregate signal.
-    default:
-      return prev
-  }
-}

package/src/orchestrator/wire-render.ts

@@ -1,92 +0,0 @@
-// The inverse of `wireForwarder`: turn a stream of `WireEvent`s back into
-// `Logger` calls on a concrete renderer. A `vx serve` client feeds the
-// service's event stream through this into a normal `defaultLogger`, so a
-// DELEGATED run renders identically to a local one — the terminal
-// renderer stays completely untouched (it just receives reconstructed
-// node-shaped objects instead of live graph nodes). This file is the
-// whole adapter; it can be rewritten or removed without touching the
-// renderer or the producer side.
-
-import type { TaskNode, TaskOutcome } from '../graph/index.js'
-import type { Logger } from './logger.js'
-import type { OutcomeView, TaskView, WireEvent } from './events.js'
-
-/**
- * Rebuild a node-shaped object from a `TaskView`. The formatters only ever
- * read `id` / `projectName` / `taskName` / `requested` / `surfaced` and
- * `config.exec` (presence ⇒ not a group; `.command`; `.persistent`), so a
- * structural stand-in is indistinguishable from a real `TaskNode` to them.
- */
-function reconstructNode(view: TaskView): TaskNode {
-  const exec = view.isGroup
-    ? undefined
-    : {
-        command: view.command ?? '',
-        ...(view.persistent ? { persistent: { readyWhen: '' } } : {}),
-      }
-  return {
-    id: view.id,
-    projectName: view.project,
-    taskName: view.task,
-    requested: view.requested,
-    surfaced: view.surfaced,
-    config: exec === undefined ? {} : { exec },
-  } as unknown as TaskNode
-}
-
-function reconstructOutcome(view: OutcomeView, node: TaskNode): TaskOutcome {
-  return {
-    node,
-    status: view.status,
-    exitCode: view.exitCode,
-    durationMs: view.durationMs,
-    ...(view.restored !== undefined ? { restored: view.restored } : {}),
-    ...(view.sandboxViolations !== undefined ? { sandboxViolations: view.sandboxViolations } : {}),
-    ...(view.sandboxViolationLines !== undefined
-      ? { sandboxViolationLines: view.sandboxViolationLines }
-      : {}),
-  } as TaskOutcome
-}
-
-/**
- * Build a `WireEvent` consumer that drives `sink` (typically a
- * `defaultLogger`). Stateful: it accumulates the reconstructed nodes from
- * `task:start` so later `task:*` events can resolve their node by id.
- */
-export function createWireRenderer(sink: Logger): (event: WireEvent) => void {
-  const nodes = new Map<string, TaskNode>()
-  return (event) => {
-    switch (event.kind) {
-      case 'run:start':
-        sink.runStart?.(event.info)
-        return
-      case 'task:start': {
-        const node = reconstructNode(event.task)
-        nodes.set(node.id, node)
-        sink.taskStart?.(node)
-        return
-      }
-      case 'task:stdout': {
-        const node = nodes.get(event.taskId)
-        if (node) sink.taskStdout(node, event.chunk)
-        return
-      }
-      case 'task:stderr': {
-        const node = nodes.get(event.taskId)
-        if (node) sink.taskStderr(node, event.chunk)
-        return
-      }
-      case 'task:complete': {
-        const node = nodes.get(event.outcome.taskId)
-        if (node) sink.taskComplete(node, reconstructOutcome(event.outcome, node))
-        return
-      }
-      case 'run:status':
-        sink.status(event.line)
-        return
-      case 'run:end':
-        sink.runEnd?.()
-        return
-    }
-  }
-}