@rigkit/cli 0.2.6 → 0.2.8

package/src/cli.ts

@@ -1,12 +1,12 @@
 #!/usr/bin/env bun
-import { existsSync } from "node:fs";
+import { existsSync, rmSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
-import chalk from "chalk";
-import { Command, CommanderError } from "commander";
+import { Command, CommanderError, Option } from "commander";
 import inquirer from "inquirer";
-import ora from "ora";
+import * as ui from "./ui.ts";
 import {
   getOrStartRuntime,
+  defaultRigkitHome,
   type RuntimeClient,
 } from "@rigkit/runtime-client";
 import {
@@ -20,15 +20,11 @@ import {
   type CmuxHostCapabilityHandler,
 } from "@rigkit/provider-cmux/host";
 import { DEFAULT_CONFIG_FILE, discoverProjectConfigs, resolveConfigPaths, PROJECT_PACKAGE_NAME } from "./project.ts";
-import {
-  materializeGithubProject,
-  splitGithubProjectTarget,
-  type GithubProjectTarget,
-} from "./remote-project.ts";
 import { RIGKIT_CLI_VERSION } from "./version.ts";
 import { initProject, normalizeMachineName, type InitProjectResult } from "./init.ts";
 import { openExternalTarget } from "./interaction.ts";
 import { createRunPresenter, type RunPresenter } from "./run-presenter.ts";
+import { createRunLogger, type RunLogger } from "./run-logger.ts";
 import {
   completeRig,
   formatCompletionItems,
@@ -39,7 +35,7 @@ import {
 import { generateWorkspaceName } from "./workspace-name.ts";
 
 type GlobalOptions = {
-  project?: string;
+  chdir?: string;
   config?: string;
   state?: string;
   json: boolean;
@@ -75,6 +71,12 @@ type ListOptions = {
   target?: string;
 };
 
+type CacheClearOptions = {
+  local: boolean;
+  global: boolean;
+  all: boolean;
+};
+
 type PackageManager = "npm" | "bun" | "pnpm" | "skip";
 
 type InitInstallResult = {
@@ -149,10 +151,46 @@ const CLI_HOST_CAPABILITIES: Array<{ id: string; schemaHash?: string }> = [
   ...(capability.schemaHash ? { schemaHash: capability.schemaHash } : {}),
 }));
 
+const TERRAFORM_STYLE_GLOBAL_OPTIONS = new Set(["chdir", "config", "state", "json", "help", "version"]);
+const STATIC_COMMANDS = new Set([
+  "init",
+  "plan",
+  "apply",
+  "create",
+  "rm",
+  "run",
+  "ls",
+  "cache",
+  "projects",
+  "doctor",
+  "version",
+  "help",
+  "completion",
+]);
+
 if (process.argv[2] === "__complete") {
   runCompletionEndpoint(process.argv.slice(3)).catch(handleCliError);
 } else {
-  runCli(process.argv).catch(handleCliError);
+  runCli(normalizeCliArgv(process.argv)).catch(handleCliError);
+}
+
+function normalizeCliArgv(argv: string[]): string[] {
+  const normalized = argv.slice();
+  for (let index = 2; index < normalized.length; index += 1) {
+    const arg = normalized[index]!;
+    if (arg === "--") break;
+    if (!arg.startsWith("-")) {
+      if (STATIC_COMMANDS.has(arg)) break;
+      continue;
+    }
+
+    const match = /^-([A-Za-z][A-Za-z0-9-]*)(=.*)?$/.exec(arg);
+    if (!match) continue;
+    const name = match[1]!;
+    if (!TERRAFORM_STYLE_GLOBAL_OPTIONS.has(name)) continue;
+    normalized[index] = `--${name}${match[2] ?? ""}`;
+  }
+  return normalized;
 }
 
 async function runCli(argv: string[]): Promise<void> {
@@ -160,15 +198,23 @@ async function runCli(argv: string[]): Promise<void> {
   program
     .name("rig")
     .description("Rigkit workflow CLI")
-    .usage("[options] <command>")
+    .usage("[global options] <command> [args]")
     .version(RIGKIT_CLI_VERSION, "-v, --version", "Show Rigkit CLI version")
     .showHelpAfterError()
     .exitOverride()
     .argument("[command]")
-    .option("-C, --project <project>", `Project directory containing ${DEFAULT_CONFIG_FILE}`)
-    .option("--config <config>", "Exact config file to load")
-    .option("--state <state>", "Local runtime state database path")
-    .option("--json", "Print machine-readable JSON where supported")
+    .addOption(new Option("--chdir <dir>", `Switch to a directory containing ${DEFAULT_CONFIG_FILE} before running the command`).hideHelp())
+    .addOption(new Option("--config <file>", "Config file to load, relative to -chdir when set").hideHelp())
+    .addOption(new Option("--state <file>", "Local runtime state database path").hideHelp())
+    .addOption(new Option("--json", "Print machine-readable JSON where supported").hideHelp())
+    .addHelpText("after", [
+      "",
+      "Global Options:",
+      "  -chdir=DIR    Switch to a directory containing rig.config.ts before running the command",
+      "  -config=FILE  Config file to load, relative to -chdir when set",
+      "  -state=FILE   Local runtime state database path",
+      "  -json         Print machine-readable JSON where supported",
+    ].join("\n"))
     .action(async (command?: string) => {
       if (command) program.error(`unknown command '${command}'`);
       await runHelp(makeInvocation(rootOptions(program)));
@@ -225,6 +271,23 @@ async function runCli(argv: string[]): Promise<void> {
       });
     });
 
+  program
+    .command("rm [workspace]")
+    .description("Remove one workspace, several via multi-select, or every workspace")
+    .option("-y, --yes", "Remove without confirmation")
+    .option("--all", "Remove every workspace in this project")
+    .option("--json", "Print machine-readable JSON")
+    .action(async (workspace: string | undefined, options: { yes?: boolean; all?: boolean; json?: boolean }) => {
+      await runRemove(
+        makeInvocation(rootOptions(program), options.json),
+        {
+          workspace,
+          yes: Boolean(options.yes),
+          all: Boolean(options.all),
+        },
+      );
+    });
+
   program
     .command("run <workspace> <operation> [args...]")
     .description("Run a workspace operation")
@@ -247,6 +310,47 @@ async function runCli(argv: string[]): Promise<void> {
       await runList(makeInvocation(rootOptions(program), options.json), { target });
     });
 
+  const cache = program
+    .command("cache")
+    .description("Inspect and clear Rigkit cache");
+
+  cache
+    .command("ls")
+    .description("List cache entries for the selected project config")
+    .option("--json", "Print machine-readable JSON")
+    .action(async (options: { json?: boolean }) => {
+      await runCacheList(makeInvocation(rootOptions(program), options.json));
+    });
+
+  cache
+    .command("clear")
+    .description("Clear cache entries")
+    .option("--local", "Clear local cache entries for the selected config")
+    .option("--global", "Clear global cache fragments")
+    .option("--all", "With --global, clear every global fragment without loading a config")
+    .option("--json", "Print machine-readable JSON")
+    .action(async (options: { local?: boolean; global?: boolean; all?: boolean; json?: boolean }) => {
+      await runCacheClear(makeInvocation(rootOptions(program), options.json), {
+        local: Boolean(options.local),
+        global: Boolean(options.global),
+        all: Boolean(options.all),
+      });
+    });
+
+  cache
+    .command("invalidate [step]")
+    .description("Invalidate cached task outputs so they re-run on next plan/apply")
+    .option("--all", "Invalidate every cached task in this project's workflow")
+    .option("-y, --yes", "Skip confirmation when invalidating --all")
+    .option("--json", "Print machine-readable JSON")
+    .action(async (step: string | undefined, options: { all?: boolean; yes?: boolean; json?: boolean }) => {
+      await runCacheInvalidate(makeInvocation(rootOptions(program), options.json), {
+        step,
+        all: Boolean(options.all),
+        yes: Boolean(options.yes),
+      });
+    });
+
   program
     .command("projects")
     .description("Discover Rigkit projects below the current directory")
@@ -291,13 +395,13 @@ async function runCli(argv: string[]): Promise<void> {
 
 function rootOptions(program: Command): GlobalOptions {
   const options = program.opts<{
-    project?: string;
+    chdir?: string;
     config?: string;
     state?: string;
     json?: boolean;
   }>();
   return {
-    project: options.project,
+    chdir: options.chdir,
     config: options.config,
     state: options.state,
     json: Boolean(options.json),
@@ -362,11 +466,25 @@ function parseCompletionEndpointArgs(args: string[]): CompletionOptions & { word
   return { ...options, words };
 }
 
+// Errors already rendered to the user (via printRunFailure or similar) carry
+// this sentinel so handleCliError doesn't re-print the message a second time.
+class DisplayedCliError extends Error {
+  readonly displayed = true as const;
+  constructor(message: string) {
+    super(message);
+    this.name = "DisplayedCliError";
+  }
+}
+
 function handleCliError(error: unknown): void {
   if (error instanceof CommanderError) {
     process.exitCode = error.exitCode;
     return;
   }
+  if (error instanceof DisplayedCliError) {
+    process.exitCode = 1;
+    return;
+  }
   console.error(error instanceof Error ? error.message : String(error));
   process.exitCode = 1;
 }
@@ -413,8 +531,7 @@ async function resolveInitAnswers(
   }
 
   if (!jsonMode) {
-    console.log(chalk.bold("Initialize Rigkit"));
-    console.log(chalk.dim("This creates a project folder with rig.config.ts, package.json, and local ignore rules."));
+    console.log(`${ui.bold("rig")} ${ui.dim("· initialize")}`);
     console.log("");
   }
 
@@ -443,10 +560,10 @@ function canPrompt(): boolean {
 function resolveInitProjectPaths(invocation: CliInvocation, name: string): { projectDir: string; configPath: string } {
   const options = invocation.global;
   if (options.config) {
-    throw new Error(`rig init does not support --config. Use -C/--project to choose the parent directory.`);
+    throw new Error(`rig init does not support -config. Use -chdir to choose the parent directory.`);
   }
 
-  const parentDir = resolve(process.cwd(), options.project ?? ".");
+  const parentDir = resolve(process.cwd(), options.chdir ?? ".");
   const projectDir = resolve(parentDir, name);
   return {
     projectDir,
@@ -540,35 +657,8 @@ async function runPackageManagerInstall(
   }
 
   const command = packageManagerInstallCommand(packageManager);
-  if (!jsonMode && process.stderr.isTTY) {
-    const spinner = ora({
-      text: `installing ${command.join(" ")}`,
-      stream: process.stderr,
-    }).start();
-    const proc = Bun.spawn(command, {
-      cwd: projectDir,
-      stdin: "inherit",
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-    const [exitCode, stdout, stderr] = await Promise.all([
-      proc.exited,
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
-    ]);
-    if (exitCode !== 0) {
-      spinner.fail(`${command.join(" ")} failed`);
-      if (stdout) process.stdout.write(stdout);
-      if (stderr) process.stderr.write(stderr);
-      throw new Error(`${command.join(" ")} failed with exit code ${exitCode}`);
-    }
-    spinner.succeed(`installed ${command.join(" ")}`);
-    return { packageManager, command: command.join(" "), skipped: false, reported: true };
-  }
-
   if (!jsonMode) {
-    console.log("");
-    console.log(`${chalk.cyan("installing")} ${command.join(" ")}`);
+    process.stderr.write(`${ui.accent(ui.sym.active)} ${ui.dim(`$ ${command.join(" ")}`)}\n`);
   }
 
   const proc = Bun.spawn(command, {
@@ -587,31 +677,43 @@ async function runPackageManagerInstall(
 }
 
 function printInitResult(result: InitProjectResult, install: InitInstallResult): void {
+  console.log(`${ui.ok(ui.sym.ok)} ${ui.bold(result.name)} ${ui.dim("ready")}`);
   console.log("");
-  console.log(`${chalk.green("Rigkit initialized")} ${chalk.bold(result.name)}`);
-  printInitLine(result.created.config ? "created" : "updated", result.configPath);
-  printInitLine(result.created.env ? "created" : result.updated.envApiKey ? "updated" : "kept", result.envPath);
-  printInitLine(result.created.envExample ? "created" : "kept", result.envExamplePath);
-  printInitLine(result.created.packageJson ? "created" : result.updated.packageJson ? "updated" : "kept", result.packageJsonPath);
-  printInitLine(result.created.gitignore ? "created" : result.updated.gitignore ? "updated" : "kept", result.gitignorePath);
 
+  const fileLines = [
+    ui.fileStatus(initStatus(result.created.config, false), shortPath(result.configPath)),
+    ui.fileStatus(initStatus(result.created.env, result.updated.envApiKey), shortPath(result.envPath)),
+    ui.fileStatus(initStatus(result.created.envExample, false), shortPath(result.envExamplePath)),
+    ui.fileStatus(initStatus(result.created.packageJson, result.updated.packageJson), shortPath(result.packageJsonPath)),
+    ui.fileStatus(initStatus(result.created.gitignore, result.updated.gitignore), shortPath(result.gitignorePath)),
+  ];
   if (result.updated.sdkDependency) {
-    console.log(`${chalk.green("pinned")} ${PROJECT_PACKAGE_NAME}@${RIGKIT_CLI_VERSION}`);
+    fileLines.push(ui.fileStatus("pinned", `${PROJECT_PACKAGE_NAME}@${RIGKIT_CLI_VERSION}`));
   }
+  for (const line of fileLines) console.log(line);
 
-  if (install.skipped) {
-    console.log(`${chalk.dim("install")} skipped`);
-  } else if (install.command && !install.reported) {
-    console.log(`${chalk.green("installed")} ${install.command}`);
+  if (!install.skipped && install.command && !install.reported) {
+    console.log(ui.fileStatus("created", install.command));
   }
 
   console.log("");
-  console.log(chalk.bold("Next steps"));
-  console.log(`  cd ${displayProjectDir(result.projectDir)}`);
+  console.log(ui.bold("Next"));
+  console.log(ui.hint(`cd ${displayProjectDir(result.projectDir)}`));
   if (install.skipped) {
-    console.log(`  ${detectInstallCommand(result.packageJsonPath)}`);
+    console.log(ui.hint(detectInstallCommand(result.packageJsonPath)));
   }
-  console.log("  rig plan");
+  console.log(ui.hint("rig plan"));
+}
+
+function initStatus(created: boolean, updated: boolean): ui.FileStatus {
+  if (created) return "created";
+  if (updated) return "updated";
+  return "kept";
+}
+
+function shortPath(path: string): string {
+  const rel = relative(process.cwd(), path);
+  return rel && !rel.startsWith("..") ? rel : path;
 }
 
 function displayProjectDir(projectDir: string): string {
@@ -619,11 +721,6 @@ function displayProjectDir(projectDir: string): string {
   return path && !path.startsWith("..") ? path : projectDir;
 }
 
-function printInitLine(status: "created" | "updated" | "kept", path: string): void {
-  const color = status === "kept" ? chalk.dim : status === "updated" ? chalk.yellow : chalk.green;
-  console.log(`${color(status.padEnd(7))} ${path}`);
-}
-
 function detectInstallCommand(packageJsonPath: string): string {
   const projectDir = dirname(packageJsonPath);
   if (existsSync(join(projectDir, "bun.lock")) || existsSync(join(projectDir, "bun.lockb"))) return "bun install";
@@ -654,24 +751,17 @@ async function runProjectOperation(
   args: string[],
   options: RunOptions,
 ): Promise<void> {
-  const remote = splitGithubProjectTarget(args);
-  if ((options.all || options.discover) && remote.target) {
-    throw new Error(`Remote GitHub project targets cannot be combined with --all or --discover`);
-  }
-
   if (options.all || options.discover) {
-    await runDiscoveredProjectOperation(invocation, requestedOperation, remote.args, { all: options.all });
+    await runDiscoveredProjectOperation(invocation, requestedOperation, args, { all: options.all });
     return;
   }
 
-  const runtime = remote.target
-    ? await loadGithubRuntime(invocation, remote.target)
-    : await loadRuntime(invocation);
+  const runtime = await loadRuntime(invocation);
   const { operation, parsed, result } = await executeRuntimeOperation(
     invocation,
     runtime,
     requestedOperation,
-    remote.args,
+    args,
   );
 
   if (wantsJson(invocation)) {
@@ -680,6 +770,9 @@ async function runProjectOperation(
   }
 
   await renderOperationResult(operation, result, parsed.hostOptions);
+  if (operation.createsWorkspace && isWorkspaceRecord(result)) {
+    await printWorkspaceNextSteps(runtime, result.name);
+  }
   printInteractiveOutputGap(invocation);
 }
 
@@ -724,6 +817,123 @@ async function runWorkspaceOperation(
   printInteractiveOutputGap(invocation);
 }
 
+async function runRemove(
+  invocation: CliInvocation,
+  options: { workspace?: string; yes: boolean; all: boolean },
+): Promise<void> {
+  if (options.workspace && options.all) {
+    throw new Error(`rig rm accepts either a workspace name or --all, not both`);
+  }
+
+  if (options.workspace) {
+    await runRemoveWorkspaceOperation(invocation, options.workspace, { yes: options.yes });
+    return;
+  }
+
+  const runtime = await loadRuntime(invocation);
+  const workspaces = await runtime.control.workspaces()
+    .then((response) => response.workspaces as WorkspaceRecord[])
+    .catch(() => []);
+  if (workspaces.length === 0) {
+    if (wantsJson(invocation)) {
+      printJson({ removed: [] });
+      return;
+    }
+    console.log(ui.dim("no workspaces"));
+    return;
+  }
+
+  let targets: string[];
+  if (options.all) {
+    if (!options.yes && !wantsJson(invocation) && canPrompt()) {
+      const confirmed = await promptHostConfirm({
+        message: `Remove all ${workspaces.length} workspaces?`,
+        defaultValue: false,
+      });
+      if (!confirmed) throw new Error("Remove cancelled");
+    } else if (!options.yes && !canPrompt()) {
+      throw new Error(`rig rm --all needs --yes when not running in an interactive terminal`);
+    }
+    targets = workspaces.map((workspace) => workspace.name);
+  } else {
+    if (wantsJson(invocation) || !canPrompt()) {
+      throw new Error(`rig rm needs a workspace name or --all when not running in an interactive terminal`);
+    }
+    targets = await promptWorkspaceRemoveSelection(workspaces);
+    if (targets.length === 0) throw new Error("Nothing selected");
+  }
+
+  const removed: string[] = [];
+  for (const name of targets) {
+    await runRemoveWorkspaceOperation(invocation, name, { yes: true });
+    removed.push(name);
+  }
+  if (wantsJson(invocation)) printJson({ removed });
+}
+
+async function promptWorkspaceRemoveSelection(
+  workspaces: ReadonlyArray<Pick<WorkspaceRecord, "name" | "workflow">>,
+): Promise<string[]> {
+  const answers = await inquirer.prompt<{ names: string[] }>([{
+    type: "checkbox",
+    name: "names",
+    message: "Select workspaces to remove",
+    choices: workspaces.map((workspace) => ({
+      name: workspace.name,
+      value: workspace.name,
+      description: workspace.workflow ? `workflow ${workspace.workflow}` : undefined,
+    })),
+  }]);
+  return answers.names;
+}
+
+async function runRemoveWorkspaceOperation(
+  invocation: CliInvocation,
+  workspaceName: string,
+  options: { yes: boolean },
+): Promise<void> {
+  const runtime = await loadRuntime(invocation);
+  const manifest = await readRuntimeOperations(runtime);
+  const operation = (manifest.workspaceOperations ?? []).find((item) => item.id === "remove");
+  if (!operation) {
+    throw new Error(`This project does not define a removable workspace.`);
+  }
+
+  const workspaces = await runtime.control.workspaces()
+    .then((response) => response.workspaces as WorkspaceRecord[])
+    .catch(() => []);
+  if (!workspaces.some((workspace) => workspace.name === workspaceName)) {
+    throw new Error(`This project does not have a workspace named "${workspaceName}".`);
+  }
+
+  if (!options.yes && !wantsJson(invocation) && canPrompt()) {
+    const confirmed = await promptHostConfirm({
+      message: `Remove workspace ${workspaceName}?`,
+      defaultValue: false,
+    });
+    if (!confirmed) throw new Error("Remove cancelled");
+    options = { yes: true };
+  }
+
+  const parsed = parseOperationArgs(operation, options.yes ? ["--yes"] : []);
+  enforceHostOnlyBooleanGuards(operation, parsed);
+
+  const result = await runRuntimeOperation<unknown>(
+    runtime,
+    `${workspaceName}/remove`,
+    parsed.input,
+    { renderEvents: !wantsJson(invocation) },
+  );
+
+  if (wantsJson(invocation)) {
+    printJson(result);
+    return;
+  }
+
+  await renderOperationResult(operation, result, parsed.hostOptions);
+  printInteractiveOutputGap(invocation);
+}
+
 async function runDiscoveredProjectOperation(
   invocation: CliInvocation,
   requestedOperation: string,
@@ -731,7 +941,7 @@ async function runDiscoveredProjectOperation(
   options: { all: boolean },
 ): Promise<void> {
   const projects = discoverProjectConfigs({
-    project: invocation.global.project,
+    chdir: invocation.global.chdir,
     config: invocation.global.config,
   });
   if (projects.length === 0) {
@@ -740,7 +950,7 @@ async function runDiscoveredProjectOperation(
   if (!options.all && projects.length > 1) {
     throw new Error([
       "Multiple Rigkit projects found.",
-      "Use `rig projects` to list candidates, pass -C/--project or --config to select one, or pass --all to run every discovered project.",
+      "Use `rig projects` to list candidates, pass -chdir or -config to select one, or pass --all to run every discovered project.",
       ...projects.map((project) => `- ${project.configPath}`),
     ].join("\n"));
   }
@@ -758,7 +968,7 @@ async function runDiscoveredProjectOperation(
     const runtime = await getOrStartRuntime({
       projectDir: project.projectDir,
       configPath: project.configPath,
-      statePath: invocation.global.state ? resolve(process.cwd(), invocation.global.state) : undefined,
+      statePath: invocation.global.state ? resolveGlobalPath(invocation, invocation.global.state) : undefined,
     });
     const { operation, parsed, result } = await executeRuntimeOperation(
       invocation,
@@ -774,7 +984,7 @@ async function runDiscoveredProjectOperation(
 
     if (!wantsJson(invocation)) {
       if (projects.length > 1) {
-        console.log(chalk.bold(displayProjectDir(project.projectDir)));
+        console.log(ui.bold(displayProjectDir(project.projectDir)));
       }
       await renderOperationResult(operation, result, parsed.hostOptions);
       printInteractiveOutputGap(invocation);
@@ -788,7 +998,7 @@ async function runDiscoveredProjectOperation(
 
 async function runProjects(invocation: CliInvocation): Promise<void> {
   const projects = discoverProjectConfigs({
-    project: invocation.global.project,
+    chdir: invocation.global.chdir,
     config: invocation.global.config,
   });
   if (wantsJson(invocation)) {
@@ -796,13 +1006,14 @@ async function runProjects(invocation: CliInvocation): Promise<void> {
     return;
   }
   if (projects.length === 0) {
-    console.log("No Rigkit projects found.");
+    console.log(ui.dim("no Rigkit projects found"));
     return;
   }
-  printTable(["project", "config"], projects.map((project) => [
-    project.projectDir,
-    project.configPath,
-  ]));
+  const rows = projects.map((project) => [
+    { text: project.projectDir, style: ui.bold },
+    { text: project.configPath, style: ui.dim },
+  ]);
+  console.log(ui.columns(["project", "config"], rows));
 }
 
 async function runList(invocation: CliInvocation, options: ListOptions): Promise<void> {
@@ -837,6 +1048,123 @@ async function runList(invocation: CliInvocation, options: ListOptions): Promise
   printConfig(project);
 }
 
+async function runCacheList(invocation: CliInvocation): Promise<void> {
+  const runtime = await loadRuntime(invocation);
+  const cache = await runtime.control.cache();
+  if (wantsJson(invocation)) {
+    printJson(cache);
+    return;
+  }
+  printCacheEntries(cache.entries);
+}
+
+async function runCacheClear(invocation: CliInvocation, options: CacheClearOptions): Promise<void> {
+  if (options.all && !options.global) {
+    throw new Error(`rig cache clear --all must be combined with --global`);
+  }
+  if (options.local && options.global && !options.all) {
+    throw new Error(`Choose --local or --global, not both`);
+  }
+
+  if (options.global && options.all) {
+    if (invocation.global.chdir || invocation.global.config || invocation.global.state) {
+      throw new Error(`rig cache clear --global --all cannot be combined with -chdir, -config, or -state`);
+    }
+    const fragmentRoot = join(defaultRigkitHome(), "fragments");
+    rmSync(fragmentRoot, { recursive: true, force: true });
+    if (wantsJson(invocation)) {
+      printJson({ ok: true, deleted: null, scope: "global-all", fragmentRoot });
+      return;
+    }
+    console.log(`Cleared global fragment cache at ${fragmentRoot}`);
+    return;
+  }
+
+  const scope = options.local ? "local" : options.global ? "global" : "all";
+  const runtime = await loadRuntime(invocation);
+  const result = await runtime.control.clearCache({ scope });
+  if (wantsJson(invocation)) {
+    printJson(result);
+    return;
+  }
+  console.log(`Cleared ${result.deleted} cache ${result.deleted === 1 ? "entry" : "entries"}.`);
+}
+
+type CacheInvalidateOptions = {
+  step?: string;
+  all: boolean;
+  yes: boolean;
+};
+
+async function runCacheInvalidate(invocation: CliInvocation, options: CacheInvalidateOptions): Promise<void> {
+  if (options.step && options.all) {
+    throw new Error(`rig cache invalidate accepts either a step or --all, not both`);
+  }
+
+  const runtime = await loadRuntime(invocation);
+  let targets: string[] = [];
+
+  if (options.step) {
+    targets = [options.step];
+  } else if (options.all) {
+    if (!options.yes && !wantsJson(invocation) && canPrompt()) {
+      const confirmed = await promptHostConfirm({
+        message: "Invalidate every cached task in this project?",
+        defaultValue: false,
+      });
+      if (!confirmed) throw new Error("Invalidate cancelled");
+    } else if (!options.yes && !canPrompt()) {
+      throw new Error(`rig cache invalidate --all needs --yes when not running in an interactive terminal`);
+    }
+    targets = []; // empty = engine invalidates everything for the workflow
+  } else {
+    // Interactive: multi-select among currently-valid cache entries.
+    const cache = await runtime.control.cache();
+    const candidates = cache.entries
+      .filter((entry) => !entry.invalidated && entry.scope === "local")
+      .map((entry) => ({ path: entry.nodePath || entry.nodeName, workflow: entry.workflow }));
+    if (candidates.length === 0) {
+      if (wantsJson(invocation)) {
+        printJson({ ok: true, invalidated: 0 });
+        return;
+      }
+      console.log(ui.dim("no valid cache entries to invalidate"));
+      return;
+    }
+    if (wantsJson(invocation) || !canPrompt()) {
+      throw new Error(`rig cache invalidate needs a step name or --all when not running in an interactive terminal`);
+    }
+    const picked = await promptCacheInvalidateSelection(candidates);
+    if (picked.length === 0) throw new Error("Nothing selected");
+    targets = picked;
+  }
+
+  const result = await runtime.control.invalidateCache({ nodePaths: targets });
+  if (wantsJson(invocation)) {
+    printJson(result);
+    return;
+  }
+  console.log(
+    `${ui.ok(ui.sym.ok)} invalidated ${result.invalidated} cache ${result.invalidated === 1 ? "entry" : "entries"}`,
+  );
+}
+
+async function promptCacheInvalidateSelection(
+  candidates: Array<{ path: string; workflow: string }>,
+): Promise<string[]> {
+  const answers = await inquirer.prompt<{ paths: string[] }>([{
+    type: "checkbox",
+    name: "paths",
+    message: "Select tasks to invalidate",
+    choices: candidates.map((c) => ({
+      name: c.path,
+      value: c.path,
+      description: c.workflow ? `workflow ${c.workflow}` : undefined,
+    })),
+  }]);
+  return answers.paths;
+}
+
 async function executeRuntimeOperation(
   invocation: CliInvocation,
   runtime: RuntimeClient,
@@ -1069,7 +1397,9 @@ async function renderOperationResult(
   }
 
   if (operation.createsWorkspace && isWorkspaceRecord(result)) {
-    console.log(result.name);
+    // Only emit the bareword name when stdout is piped, so scripts can do
+    // `name=$(rig create)` while TTY users aren't shown a redundant line.
+    if (!process.stdout.isTTY) console.log(result.name);
     return;
   }
 
@@ -1085,7 +1415,7 @@ async function renderOperationResult(
   }
 
   if (isWorkspaceRecord(result)) {
-    console.log(result.name);
+    if (!process.stdout.isTTY) console.log(result.name);
     return;
   }
 
@@ -1104,12 +1434,12 @@ async function runDoctor(invocation: CliInvocation, options: DoctorOptions): Pro
       printJson(diagnostics);
       return;
     }
-    printTable(["key", "value"], [
+    console.log(ui.kvList([
       ["cli", diagnostics.cliVersion],
       ["binary", diagnostics.binary ?? ""],
       ["node", diagnostics.node],
       ["bun", diagnostics.bun ?? ""],
-    ]);
+    ]));
     return;
   }
 
@@ -1137,7 +1467,7 @@ async function runDoctor(invocation: CliInvocation, options: DoctorOptions): Pro
     return;
   }
 
-  printTable(["key", "value"], [
+  console.log(ui.kvList([
     ["cli", RIGKIT_CLI_VERSION],
     ["project", project.projectDir],
     ["config", project.configPath],
@@ -1150,7 +1480,7 @@ async function runDoctor(invocation: CliInvocation, options: DoctorOptions): Pro
     ["protocol", runtimeInfo.protocolHash],
     ["state", project.statePath ?? ""],
     ["expires", health.expiresAt ?? runtime.handle.expiresAt ?? ""],
-  ]);
+  ]));
 }
 
 async function runVersion(invocation: CliInvocation): Promise<void> {
@@ -1172,8 +1502,10 @@ async function runHelp(invocation: CliInvocation): Promise<void> {
         { name: "plan", description: "Plan project workflow changes" },
         { name: "apply", description: "Apply project workflow changes" },
         { name: "create", description: "Create a workspace" },
+        { name: "rm", description: "Remove a workspace" },
         { name: "run", description: "Run a workspace operation" },
         { name: "ls", description: "List project workspaces" },
+        { name: "cache", description: "Inspect and clear Rigkit cache" },
         { name: "projects", description: "Discover Rigkit projects below the current directory" },
         { name: "doctor", description: "Show Rigkit runtime diagnostics" },
         { name: "version", description: "Show Rigkit CLI version" },
@@ -1182,30 +1514,37 @@ async function runHelp(invocation: CliInvocation): Promise<void> {
     });
     return;
   }
+  const cmd = (name: string, description: string): string =>
+    `  ${ui.bold(name.padEnd(10))}  ${description}`;
+  const opt = (flag: string, description: string): string =>
+    `  ${ui.bold(flag.padEnd(12))}  ${description}`;
+
   console.log([
-    `rig ${RIGKIT_CLI_VERSION}`,
+    `${ui.bold("rig")} ${ui.dim(RIGKIT_CLI_VERSION)}`,
     "",
-    "Usage:",
-    "  rig [options] <command>",
+    ui.dim("Usage:"),
+    `  ${ui.accent(ui.sym.prompt)} rig [global options] <command> [args]`,
     "",
-    "Commands:",
-    "  help        Show Rigkit CLI help",
-    "  init        Initialize a Rigkit project",
-    "  plan        Plan project workflow changes",
-    "  apply       Apply project workflow changes",
-    "  create      Create a workspace",
-    "  run         Run a workspace operation",
-    "  ls          List project workspaces",
-    "  projects    Discover Rigkit projects below the current directory",
-    "  doctor      Show Rigkit runtime diagnostics",
-    "  version     Show Rigkit CLI version",
-    "  completion  Generate shell completion script",
+    ui.dim("Commands:"),
+    cmd("help",       "Show Rigkit CLI help"),
+    cmd("init",       "Initialize a Rigkit project"),
+    cmd("plan",       "Plan project workflow changes"),
+    cmd("apply",      "Apply project workflow changes"),
+    cmd("create",     "Create a workspace"),
+    cmd("rm",         "Remove a workspace"),
+    cmd("run",        "Run a workspace operation"),
+    cmd("ls",         "List project workspaces"),
+    cmd("cache",      "Inspect and clear Rigkit cache"),
+    cmd("projects",   "Discover Rigkit projects below the current directory"),
+    cmd("doctor",     "Show Rigkit runtime diagnostics"),
+    cmd("version",    "Show Rigkit CLI version"),
+    cmd("completion", "Generate shell completion script"),
     "",
-    "Options:",
-    "  -C, --project <dir>  Project directory containing rig.config.ts",
-    "  --config <file>      Exact config file to load",
-    "  --state <file>       Local runtime state database path",
-    "  --json               Print machine-readable JSON where supported",
+    ui.dim("Options:"),
+    opt("-chdir=DIR",   "Switch to a directory containing rig.config.ts before running the command"),
+    opt("-config=FILE", "Config file to load, relative to -chdir when set"),
+    opt("-state=FILE",  "Local runtime state database path"),
+    opt("-json",        "Print machine-readable JSON where supported"),
   ].join("\n"));
 }
 
@@ -1214,50 +1553,6 @@ async function loadRuntime(invocation: CliInvocation): Promise<RuntimeClient> {
   return await getOrStartRuntime(engineOptions);
 }
 
-async function loadGithubRuntime(invocation: CliInvocation, target: GithubProjectTarget): Promise<RuntimeClient> {
-  if (invocation.global.project || invocation.global.config || invocation.global.state) {
-    throw new Error(`Remote GitHub project targets cannot be combined with -C/--project, --config, or --state`);
-  }
-
-  await confirmGithubProjectTarget(target);
-  const project = await materializeGithubProject(target);
-  if (!wantsJson(invocation)) {
-    console.error(`github ${target.owner}/${target.repo}@${project.commitSha.slice(0, 12)}`);
-  }
-  return await getOrStartRuntime({
-    projectDir: project.projectDir,
-    configPath: project.configPath,
-    statePath: project.statePath,
-    source: {
-      kind: "github",
-      target: target.raw,
-      repoUrl: project.repoUrl,
-      ref: project.ref,
-      commitSha: project.commitSha,
-    },
-  });
-}
-
-async function confirmGithubProjectTarget(target: GithubProjectTarget): Promise<void> {
-  if (process.env.RIGKIT_TRUST_REMOTE_CONFIGS === "1") return;
-  const repo = `https://github.com/${target.owner}/${target.repo}`;
-  const ref = target.ref ? ` at ${target.ref}` : "";
-  const message = `Run and install dependencies for ${repo}${ref}?`;
-
-  if (!canPrompt()) {
-    throw new Error(
-      `Remote GitHub project ${target.raw} executes code on this machine. ` +
-        `Run from an interactive terminal or set RIGKIT_TRUST_REMOTE_CONFIGS=1 to allow it explicitly.`,
-    );
-  }
-
-  console.error("");
-  console.error(chalk.yellow("Remote Rigkit configs execute code on this machine."));
-  console.error(`Project: ${repo}${ref}`);
-  const allowed = await promptHostConfirm({ message, defaultValue: false });
-  if (!allowed) throw new Error(`Remote GitHub project denied`);
-}
-
 async function readRuntimeProject(runtime: RuntimeClient): Promise<EngineProjectInfo> {
   return await runtime.control.project() as EngineProjectInfo;
 }
@@ -1276,14 +1571,33 @@ async function runRuntimeOperation<T>(
   let presenter: RunPresenter | undefined = options.renderEvents
     ? createRunPresenter(operation)
     : undefined;
+  const logger: RunLogger | undefined = createRunLogger({
+    projectDir: runtime.handle.projectDir,
+    operation,
+    daemonStderrPath: runtime.paths.runtimeLogPath,
+  });
+  if (logger) {
+    logger.append({ type: "run.started", runId: started.runId, operation, input });
+  }
   let result: T | undefined;
   let failure: Error | undefined;
+  let failureCode: string | undefined;
+  let activeNodePath: string | undefined;
 
   const handleEvent = async (
     event: unknown,
     respond?: (id: string, response: unknown) => void | Promise<void>,
     sendSession?: (message: unknown) => void | Promise<void>,
   ) => {
+    logger?.append(event);
+    if (isRecord(event)) {
+      if (event.type === "node.started" && typeof event.nodePath === "string") {
+        activeNodePath = event.nodePath;
+      }
+      if (event.type === "node.completed" && event.nodePath === activeNodePath) {
+        activeNodePath = undefined;
+      }
+    }
     if (isHostRequestEvent(event)) {
       const suspendPresenter = hostRequestNeedsTerminal(event);
       if (suspendPresenter) presenter?.pause();
@@ -1331,6 +1645,9 @@ async function runRuntimeOperation<T>(
         ? event.error.message
         : "Runtime operation failed";
       failure = new Error(message);
+      failureCode = isRecord(event.error) && typeof event.error.code === "string"
+        ? event.error.code
+        : undefined;
       presenter?.render({ ...event, type: "run.failed" });
       return;
     }
@@ -1379,14 +1696,85 @@ async function runRuntimeOperation<T>(
     }
   } finally {
     presenter?.close();
+    if (logger) {
+      logger.finish({
+        status: failure ? "failed" : "completed",
+        error: failure,
+        result,
+      });
+      logger.close();
+    }
     uninstallRunCancelHandler();
   }
 
-  if (failure) throw failure;
+  if (failure) {
+    printRunFailure({
+      operation,
+      node: activeNodePath,
+      code: failureCode,
+      message: failure.message,
+      logPath: logger?.path,
+    });
+    throw new DisplayedCliError(failure.message);
+  }
   if (result === undefined) throw new Error(`Runtime operation ${operation} finished without a result`);
   return result;
 }
 
+function printRunFailure(input: {
+  operation: string;
+  node: string | undefined;
+  code: string | undefined;
+  message: string;
+  logPath: string | undefined;
+}): void {
+  const pairs: Array<[string, string]> = [];
+  if (input.node) pairs.push(["node", input.node]);
+  if (input.code) pairs.push(["code", ui.bold(input.code)]);
+  pairs.push(["reason", input.message]);
+
+  process.stderr.write("\n");
+  process.stderr.write(`${ui.err(ui.sym.err)} ${ui.bold(`${input.operation} failed`)}\n`);
+  process.stderr.write(`${ui.kvList(pairs)}\n`);
+  if (input.logPath) {
+    process.stderr.write("\n");
+    process.stderr.write(`${ui.dim("full log")}  ${shortPath(input.logPath)}\n`);
+    process.stderr.write(`${ui.dim("        ")}  ${ui.dim("daemon stderr appended on failure")}\n`);
+  }
+}
+
+// After a successful `rig create`, list the workspace's available operations so
+// the user doesn't have to guess what to do next. TTY-only — JSON consumers and
+// pipes get clean output.
+async function printWorkspaceNextSteps(runtime: RuntimeClient, workspaceName: string): Promise<void> {
+  if (!process.stderr.isTTY) return;
+
+  let manifest: RuntimeOperationManifest;
+  try {
+    manifest = await readRuntimeOperations(runtime);
+  } catch {
+    return;
+  }
+
+  const ops = (manifest.workspaceOperations ?? []).filter((op) => op.id !== "remove");
+  const invocations: Array<{ command: string; description: string }> = ops.map((op) => ({
+    command: `rig run ${workspaceName} ${op.id}`,
+    description: op.description ?? op.title ?? "",
+  }));
+  invocations.push({ command: `rig rm ${workspaceName}`, description: "Remove this workspace" });
+
+  const commandWidth = invocations.reduce((max, item) => Math.max(max, item.command.length), 0);
+
+  process.stderr.write("\n");
+  process.stderr.write(`${ui.bold("Next")}\n`);
+  for (const item of invocations) {
+    const command = `${ui.bold("rig")}${item.command.slice("rig".length)}`;
+    const padding = " ".repeat(Math.max(0, commandWidth - item.command.length));
+    const tail = item.description ? `  ${ui.dim(item.description)}` : "";
+    process.stderr.write(`${ui.dim(ui.sym.arrow)} ${command}${padding}${tail}\n`);
+  }
+}
+
 let uninstallActiveRunCancelHandler: (() => void) | undefined;
 
 function installRunCancelHandler(session: { send(message: unknown): void; close(code?: number, reason?: string): void }): void {
@@ -1418,13 +1806,17 @@ function resolveEngineOptions(invocation: CliInvocation): { projectDir: string;
   return {
     projectDir: paths.projectDir,
     configPath: paths.configPath,
-    statePath: options.state ? resolve(process.cwd(), options.state) : undefined,
+    statePath: options.state ? resolveGlobalPath(invocation, options.state) : undefined,
   };
 }
 
 function resolveCommandConfigPaths(invocation: CliInvocation): { projectDir: string; configPath: string } {
   const options = invocation.global;
-  return resolveConfigPaths({ project: options.project, config: options.config });
+  return resolveConfigPaths({ chdir: options.chdir, config: options.config });
+}
+
+function resolveGlobalPath(invocation: CliInvocation, path: string): string {
+  return resolve(process.cwd(), invocation.global.chdir ?? ".", path);
 }
 
 type HostRequestEvent = {
@@ -1798,15 +2190,21 @@ async function confirmHostCommand(input: {
     throw new Error(`Host command requires confirmation in an interactive terminal`);
   }
 
-  console.error("");
-  console.error(chalk.yellow("This Rigkit config is asking to run a command on this machine."));
-  console.error(`${chalk.bold("Command:")} ${input.argv.map(shellDisplay).join(" ")}`);
-  console.error(`${chalk.bold("Mode:")} ${input.mode}`);
-  if (input.cwd) console.error(`${chalk.bold("cwd:")} ${input.cwd}`);
+  const pairs: Array<[string, string]> = [
+    ["command", input.argv.map(shellDisplay).join(" ")],
+    ["mode", input.mode],
+  ];
+  if (input.cwd) pairs.push(["cwd", input.cwd]);
   if (input.env && Object.keys(input.env).length > 0) {
-    console.error(`${chalk.bold("env:")} ${Object.keys(input.env).join(", ")}`);
+    pairs.push(["env", Object.keys(input.env).join(", ")]);
   }
-  if (input.reason) console.error(`${chalk.bold("Reason:")} ${input.reason}`);
+  if (input.reason) pairs.push(["reason", input.reason]);
+
+  console.error("");
+  console.error(`${ui.warn("!")} ${ui.bold("this config wants to run a command on your machine")}`);
+  console.error("");
+  console.error(ui.kvList(pairs));
+  console.error("");
   return await promptHostConfirm({ message: "Allow?", defaultValue: false });
 }
 
@@ -1882,82 +2280,125 @@ function printInteractiveOutputGap(invocation: CliInvocation): void {
 }
 
 function printPlan(plan: WorkflowPlan): void {
-  console.log(`${plan.workflow}: ${plan.cachedNodeCount}/${plan.nodeCount} nodes cached`);
+  console.log(`${ui.bold(plan.workflow)}  ${ui.dim(`${plan.cachedNodeCount}/${plan.nodeCount} cached`)}`);
+  console.log("");
 
   const rows = plan.nodes.map((node) => [
-    String(node.index + 1),
-    node.status,
-    node.path,
-    node.reason ?? "",
+    { text: String(node.index + 1), style: ui.dim },
+    { text: node.status, style: planStatusStyle(node.status) },
+    { text: node.path },
+    { text: node.reason ?? "", style: ui.dim },
   ]);
-  printTable(["#", "status", "node", "reason"], rows);
+  console.log(ui.columns(["#", "status", "node", "reason"], rows));
+}
+
+function planStatusStyle(status: string): (text: string) => string {
+  switch (status) {
+    case "cached":
+    case "skipped":
+      return ui.dim;
+    case "pending":
+      return ui.warn;
+    case "completed":
+    case "ready":
+    case "applied":
+      return ui.ok;
+    case "failed":
+    case "error":
+      return ui.err;
+    default:
+      return ui.accent;
+  }
 }
 
 function printWorkspaces(
   workspaces: ReadonlyArray<Pick<WorkspaceRecord, "name" | "workflow" | "createdAt">>,
 ): void {
   if (workspaces.length === 0) {
-    console.log("No workspaces.");
+    console.log(ui.dim("no workspaces"));
     return;
   }
 
-  printTable(
-    ["name", "workflow", "created", "age"],
-    workspaces.map((workspace) => [
-      workspace.name,
-      workspace.workflow,
-      workspace.createdAt,
-      formatWorkspaceAge(workspace.createdAt),
-    ]),
-  );
+  const rows = workspaces.map((workspace) => [
+    { text: workspace.name, style: ui.bold },
+    { text: workspace.workflow },
+    { text: workspace.createdAt, style: ui.dim },
+    formatWorkspaceAge(workspace.createdAt),
+  ]);
+  console.log(ui.columns(["name", "workflow", "created", "age"], rows));
 }
 
-function formatWorkspaceAge(createdAt: string): string {
+function formatWorkspaceAge(createdAt: string): { text: string; style: (text: string) => string } {
   const createdTime = Date.parse(createdAt);
-  if (Number.isNaN(createdTime)) return chalk.dim("unknown");
+  if (Number.isNaN(createdTime)) return { text: "unknown", style: ui.dim };
 
   const ageMs = Math.max(0, Date.now() - createdTime);
   const minute = 60 * 1000;
   const hour = 60 * minute;
   const day = 24 * hour;
-  const label = ageMs < hour
+  const text = ageMs < hour
     ? `${Math.max(1, Math.floor(ageMs / minute))}m`
     : ageMs < day
       ? `${Math.floor(ageMs / hour)}h`
       : `${Math.floor(ageMs / day)}d`;
 
-  if (ageMs < day) return chalk.green(label);
-  if (ageMs <= 3 * day) return chalk.yellow(label);
-  return chalk.red(label);
+  if (ageMs < day) return { text, style: ui.ok };
+  if (ageMs <= 3 * day) return { text, style: ui.warn };
+  return { text, style: ui.dim };
 }
 
 function printSnapshots(snapshots: SnapshotRecord[]): void {
   if (snapshots.length === 0) {
-    console.log("No snapshots.");
+    console.log(ui.dim("no snapshots"));
     return;
   }
 
-  printTable(
-    ["run", "workflow", "node", "snapshot", "created"],
-    snapshots.map((snapshot) => [
-      snapshot.id,
-      snapshot.workflow,
-      snapshot.nodePath,
-      typeof snapshot.metadata.snapshotId === "string" ? snapshot.metadata.snapshotId : "",
-      snapshot.createdAt,
-    ]),
-  );
+  const rows = snapshots.map((snapshot) => [
+    { text: snapshot.id, style: ui.dim },
+    { text: snapshot.workflow },
+    { text: snapshot.nodePath, style: ui.bold },
+    { text: typeof snapshot.metadata.snapshotId === "string" ? snapshot.metadata.snapshotId : "" },
+    { text: snapshot.createdAt, style: ui.dim },
+  ]);
+  console.log(ui.columns(["run", "workflow", "node", "snapshot", "created"], rows));
+}
+
+function printCacheEntries(entries: ReadonlyArray<{
+  scope: "local" | "global";
+  workflow: string;
+  nodePath: string;
+  nodeName: string;
+  createdAt: string;
+  invalidated: boolean;
+  fragmentHash?: string;
+}>): void {
+  if (entries.length === 0) {
+    console.log(ui.dim("no cache entries"));
+    return;
+  }
+
+  const rows = entries.map((entry) => [
+    { text: entry.scope, style: ui.dim },
+    { text: entry.workflow },
+    { text: entry.nodePath || entry.nodeName, style: ui.bold },
+    {
+      text: entry.invalidated ? "invalidated" : "valid",
+      style: entry.invalidated ? ui.warn : ui.ok,
+    },
+    { text: entry.fragmentHash ? entry.fragmentHash.slice(0, 19) : "", style: ui.dim },
+    { text: entry.createdAt, style: ui.dim },
+  ]);
+  console.log(ui.columns(["scope", "workflow", "node", "status", "fragment", "created"], rows));
 }
 
 function printConfig(info: EngineProjectInfo): void {
-  const rows = [
+  console.log(ui.kvList([
     ["config", info.configPath],
     ["project", info.projectDir],
-    ["state", info.statePath],
-    ["workflow", info.workflow?.name ?? "(not loaded)"],
+    ["state", info.statePath ?? ""],
+    ["workflow", info.workflow?.name ?? ui.dim("(not loaded)")],
     ["providers", info.workflow?.providers.join(", ") ?? ""],
-  ];
-  printTable(["key", "value"], rows);
+  ]));
 }
 
 function normalizeListTarget(target: string | undefined): "workspaces" | "snapshots" | "config" {
@@ -1969,62 +2410,85 @@ function normalizeListTarget(target: string | undefined): "workspaces" | "snapsh
   throw new Error(`Unknown ls target ${target}. Expected workspaces, snapshots, or config.`);
 }
 
-function printTable(headers: string[], rows: string[][]): void {
-  const widths = headers.map((header, index) =>
-    Math.max(header.length, ...rows.map((row) => String(row[index] ?? "").length)),
-  );
-  const format = (row: string[]) =>
-    row.map((value, index) => String(value ?? "").padEnd(widths[index] ?? 0)).join("  ").trimEnd();
-
-  console.log(format(headers));
-  console.log(format(widths.map((width) => "-".repeat(width))));
-  for (const row of rows) console.log(format(row));
-}
-
 function renderEvent(event: DevMachineEvent): void {
+  const write = (line: string) => process.stderr.write(`${line}\n`);
   switch (event.type) {
     case "definition.loaded":
-      console.error(`loaded ${event.workflow}`);
+      write(`${ui.dim(ui.sym.dot)} ${ui.dim(`loaded ${event.workflow}`)}`);
       return;
     case "plan.created":
-      console.error(`plan ${event.workflow}: ${event.cachedNodeCount}/${event.nodeCount} cached`);
+      write(`${ui.accent(ui.sym.active)} ${ui.bold(event.workflow)}  ${ui.dim(`${event.cachedNodeCount}/${event.nodeCount} cached`)}`);
+      return;
+    case "workflow.apply.started":
+      write(`${ui.accent(ui.sym.active)} workflow ${ui.bold(event.workflow)}`);
       return;
+    case "workflow.apply.completed": {
+      const summary = event.nodeCount > 0
+        ? `  ${ui.dim(`${event.cachedNodeCount}/${event.nodeCount} cached`)}`
+        : "";
+      write(`${ui.ok(ui.sym.ok)} ${ui.bold(event.workflow)} ${ui.dim("prepared")}${summary}`);
+      return;
+    }
     case "node.cached":
-      console.error(`node ${event.nodePath} cached`);
+      write(`  ${ui.dim(ui.sym.ok)} ${ui.dim(`${event.nodePath}  cached`)}`);
       return;
     case "vm.created":
-      console.error(event.fromSnapshotId ? `vm ${event.vmId} from ${event.fromSnapshotId}` : `vm ${event.vmId} created`);
+      write(`  ${ui.dim(event.fromSnapshotId ? `vm ${event.vmId} from ${event.fromSnapshotId}` : `vm ${event.vmId} created`)}`);
       return;
     case "node.started":
-      console.error(`node ${event.nodePath}`);
+      write(`  ${ui.accent(ui.sym.active)} ${ui.bold(String(event.nodePath))}`);
       return;
     case "node.completed":
-      console.error(`node ${event.nodePath} completed`);
+      write(`  ${ui.ok(ui.sym.ok)} ${event.nodePath}`);
       return;
     case "command.started":
-      console.error(`command ${event.commandName}`);
+      write(`    ${ui.dim(`$ ${event.commandName}`)}`);
       return;
     case "command.output":
       process.stderr.write(event.data);
       return;
     case "command.completed":
-      console.error(`command ${event.commandName} exited ${event.exitCode}`);
+      if (event.exitCode !== 0) {
+        write(`    ${ui.err(`${event.commandName} exited ${event.exitCode}`)}`);
+      }
       return;
-    case "log.output":
-      process.stderr.write(event.data);
+    case "log.output": {
+      const prefix = event.stream && event.stream !== "info" && event.stream !== "stdout"
+        ? `[${event.stream}] `
+        : "";
+      for (const line of event.data.replace(/\r/g, "").split("\n")) {
+        if (!line) continue;
+        process.stderr.write(`${prefix}${line}\n`);
+      }
       return;
+    }
     case "interaction.awaiting_user":
-      console.error(`interaction ${event.label}`);
-      console.error(`open ${event.url}`);
+      write(`  ${ui.accent(ui.sym.arrow)} waiting on ${ui.bold(event.label)}`);
+      write(`    ${ui.dim(event.url)}`);
       return;
     case "interaction.completed":
-      console.error(`interaction ${event.label} completed`);
+      write(`  ${ui.ok(ui.sym.ok)} ${ui.dim(`${event.label} completed`)}`);
       return;
     case "artifact.created":
-      console.error(`artifact ${event.providerId}:${event.kind}`);
+      write(`    ${ui.dim(`+ ${event.providerId}:${event.kind}`)}`);
+      return;
+    case "workspace.create.started":
+      write(`${ui.accent(ui.sym.active)} creating workspace ${ui.bold(String(event.workspaceName))}`);
       return;
     case "workspace.ready":
-      console.error(`workspace ${event.workspaceId} ready`);
+      write(`${ui.ok(ui.sym.ok)} ${ui.bold(String(event.workspaceId))} ${ui.dim("ready")}`);
+      return;
+    case "workspace.remove.started":
+      write(`${ui.accent(ui.sym.active)} removing workspace ${ui.bold(String(event.workspaceName))}`);
+      return;
+    case "workspace.remove.completed":
+      write(`${ui.ok(ui.sym.ok)} removed ${ui.bold(String(event.workspaceName))}`);
+      return;
+    case "workspace.operation.started":
+      write(`${ui.accent(ui.sym.active)} running ${ui.bold(String(event.operationId))} on ${ui.bold(String(event.workspaceName))}`);
+      return;
+    case "workspace.operation.completed":
+      write(`${ui.ok(ui.sym.ok)} ran ${ui.bold(String(event.operationId))} on ${ui.bold(String(event.workspaceName))}`);
       return;
     default:
       return;