Rename arc run start → arc run (#5)

* arc(01KK7524KNGTPS4090QMF87FJN): implement (success) Arc-Run: 01KK7524KNGTPS4090QMF87FJN Arc-Completed: 2 Arc-Checkpoint: 1ff03c704805dfe8e7c37b37f97bd06dfa0e5dc5 * Fix: restore trailing newlines stripped by previous commit * arc(01KK7524KNGTPS4090QMF87FJN): simplify (success) Arc-Run: 01KK7524KNGTPS4090QMF87FJN Arc-Completed: 3 Arc-Checkpoint: 21771adfd26283a1d1e6b8a123a83a0c4277db48 --------- Co-authored-by: arc <arc@local> Co-authored-by: Arc Assistant <assistant@arc.dev> Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
2026-08-28 05:27:41 +00:00 · 2026-03-08 16:14:50 -04:00 · 2026-03-08 16:14:50 -04:00 · d002aa0b51
commit d002aa0b51
parent c3d23d72e9
35 changed files with 127 additions and 133 deletions
--- a/CLAUDE.md
+++ b/CLAUDE.md
@ -17,4 +17,4 @@ The OpenAPI spec at `docs/api-reference/arc-api.yaml` is the source of truth for

 ## Testing workflows

-When manually testing workflows with `arc run start`, use `--no-retro` to skip the retro step and finish faster.
+When manually testing workflows with `arc run`, use `--no-retro` to skip the retro step and finish faster.
--- a/crates/arc-cli/src/main.rs
+++ b/crates/arc-cli/src/main.rs
@ -49,11 +49,8 @@ enum Command {
    },
    /// Run an agentic coding session
    Exec(arc_agent::cli::AgentArgs),
-    /// Launch and manage workflow runs
-    Run {
-        #[command(subcommand)]
-        command: RunCommand,
-    },
+    /// Launch a workflow run
+    Run(arc_workflows::cli::RunArgs),
    /// Validate a workflow
    Validate(arc_workflows::cli::ValidateArgs),
    /// Parse a DOT file and print its AST
@ -77,14 +74,17 @@ enum Command {
    },
    /// Interactive setup wizard for Arc
    Setup,
+    /// List workflow runs
+    Ps(arc_workflows::cli::runs::RunsListArgs),
+    /// System maintenance commands
+    System {
+        #[command(subcommand)]
+        command: SystemCommand,
+    },
 }

 #[derive(Subcommand)]
-enum RunCommand {
-    /// Launch a workflow from a .dot or .toml task file
-    Start(arc_workflows::cli::RunArgs),
-    /// List workflow runs
-    List(arc_workflows::cli::runs::RunsListArgs),
+enum SystemCommand {
    /// Delete old workflow runs
    Prune(arc_workflows::cli::runs::RunsPruneArgs),
 }
@ -130,13 +130,15 @@ async fn main() -> Result<()> {
    let command_name = match &cli.command {
        Command::Llm { .. } => "llm",
        Command::Exec(_) => "exec",
-        Command::Run { .. } => "run",
+        Command::Run(_) => "run",
        Command::Validate(_) => "validate",
        Command::Parse(_) => "parse",
        Command::Model { .. } => "model",
        Command::Serve(_) => "serve",
        Command::Doctor { .. } => "doctor",
        Command::Setup => "setup",
+        Command::Ps(_) => "ps",
+        Command::System { .. } => "system",
    };

    let config_log_level = if let Command::Serve(ref args) = cli.command {
@ -216,41 +218,33 @@ async fn main() -> Result<()> {
            );
            arc_agent::cli::run_with_args(args).await?
        }
-        Command::Run { command } => match command {
-            RunCommand::Start(mut args) => {
-                let styles: &'static arc_util::terminal::Styles =
-                    Box::leak(Box::new(arc_util::terminal::Styles::detect_stderr()));
-                let server_config = arc_api::server_config::load_server_config(None)?;
-                let cli_config = cli_config::load_cli_config(None)?;
-                args.verbose = args.verbose || cli_config.verbose;
-                let github_app = build_github_app_credentials(&server_config);
+        Command::Run(mut args) => {
+            let styles: &'static arc_util::terminal::Styles =
+                Box::leak(Box::new(arc_util::terminal::Styles::detect_stderr()));
+            let server_config = arc_api::server_config::load_server_config(None)?;
+            let cli_config = cli_config::load_cli_config(None)?;
+            args.verbose = args.verbose || cli_config.verbose;
+            let github_app = build_github_app_credentials(&server_config);

-                let cli_author = cli_config.git.as_ref().map(|g| &g.author);
-                let git_author = arc_workflows::git::GitAuthor::from_options(
-                    cli_author
-                        .and_then(|a| a.name.clone())
-                        .or_else(|| server_config.git.author.name.clone()),
-                    cli_author
-                        .and_then(|a| a.email.clone())
-                        .or_else(|| server_config.git.author.email.clone()),
-                );
+            let cli_author = cli_config.git.as_ref().map(|g| &g.author);
+            let git_author = arc_workflows::git::GitAuthor::from_options(
+                cli_author
+                    .and_then(|a| a.name.clone())
+                    .or_else(|| server_config.git.author.name.clone()),
+                cli_author
+                    .and_then(|a| a.email.clone())
+                    .or_else(|| server_config.git.author.email.clone()),
+            );

-                arc_workflows::cli::run::run_command(
-                    args,
-                    server_config.run_defaults,
-                    styles,
-                    github_app,
-                    git_author,
-                )
-                .await?;
-            }
-            RunCommand::List(args) => {
-                arc_workflows::cli::runs::list_command(&args)?;
-            }
-            RunCommand::Prune(args) => {
-                arc_workflows::cli::runs::prune_command(&args)?;
-            }
-        },
+            arc_workflows::cli::run::run_command(
+                args,
+                server_config.run_defaults,
+                styles,
+                github_app,
+                git_author,
+            )
+            .await?;
+        }
        Command::Validate(args) => {
            let styles = arc_util::terminal::Styles::detect_stderr();
            arc_workflows::cli::validate::validate_command(&args, &styles)?;
@ -288,6 +282,14 @@ async fn main() -> Result<()> {
        Command::Setup => {
            setup::run_setup().await?;
        }
+        Command::Ps(args) => {
+            arc_workflows::cli::runs::list_command(&args)?;
+        }
+        Command::System { command } => match command {
+            SystemCommand::Prune(args) => {
+                arc_workflows::cli::runs::prune_command(&args)?;
+            }
+        },
    }

    Ok(())
--- a/crates/arc-cli/tests/cli.rs
+++ b/crates/arc-cli/tests/cli.rs
@ -420,7 +420,6 @@ fn dry_run_simple() {
    arc()
        .args([
            "run",
-            "start",
            "--dry-run",
            "--auto-approve",
            "../../test/simple.dot",
@ -434,7 +433,6 @@ fn dry_run_branching() {
    arc()
        .args([
            "run",
-            "start",
            "--dry-run",
            "--auto-approve",
            "../../test/branching.dot",
@ -448,7 +446,6 @@ fn dry_run_conditions() {
    arc()
        .args([
            "run",
-            "start",
            "--dry-run",
            "--auto-approve",
            "../../test/conditions.dot",
@ -462,7 +459,6 @@ fn dry_run_parallel() {
    arc()
        .args([
            "run",
-            "start",
            "--dry-run",
            "--auto-approve",
            "../../test/parallel.dot",
@ -476,7 +472,6 @@ fn dry_run_styled() {
    arc()
        .args([
            "run",
-            "start",
            "--dry-run",
            "--auto-approve",
            "../../test/styled.dot",
@ -490,7 +485,6 @@ fn dry_run_legacy_tool() {
    arc()
        .args([
            "run",
-            "start",
            "--dry-run",
            "--auto-approve",
            "../../test/legacy_tool.dot",
@ -548,7 +542,6 @@ fn dry_run_writes_jsonl_and_live_json() {
    arc()
        .args([
            "run",
-            "start",
            "--dry-run",
            "--auto-approve",
            "--logs-dir",
--- a/docs/administration/troubleshooting.mdx
+++ b/docs/administration/troubleshooting.mdx
@ -35,5 +35,5 @@ It checks:
 **Run config validation errors** — Use `--preflight` to validate without executing:

 ```bash
-arc run start run.toml --preflight
+arc run run.toml --preflight
 ```
--- a/docs/core-concepts/how-arc-works.mdx
+++ b/docs/core-concepts/how-arc-works.mdx
@ -15,7 +15,7 @@ Arc has two interfaces, both backed by the same workflow engine:

 | | CLI mode | API mode |
 |---|---|---|
-| **Command** | `arc run start workflow.dot` | `arc serve` |
+| **Command** | `arc run workflow.dot` | `arc serve` |
 | **Best for** | Local development, one-off runs | Production use, web UI, integrations |
 | **Execution** | Immediate, single run | Queued, up to N concurrent runs |
 | **Human-in-the-loop** | Terminal prompts | HTTP endpoints |
@ -36,7 +36,7 @@ You provide three inputs:

 ## Parse and validate

-When you run `arc run start`, Arc:
+When you run `arc run`, Arc:

 1. Parses the DOT file into an in-memory graph of nodes and edges
 2. Validates the graph structure (exactly one start node, one exit node, all edges point to valid nodes)
@ -96,13 +96,13 @@ See [Observability](/execution/observability) for more on querying run data.
 Because Arc checkpoints after every stage, interrupted runs can be resumed from where they left off:

 ```bash
-arc run start --resume path/to/checkpoint.json
+arc run --resume path/to/checkpoint.json
 ```

 Or resume from a git run branch:

 ```bash
-arc run start --run-branch arc/runs/abc123
+arc run --run-branch arc/runs/abc123
 ```

 The engine restores the full context, node visit counts, and retry state, then continues execution from the next node.
--- a/docs/core-concepts/models.mdx
+++ b/docs/core-concepts/models.mdx
@ -75,11 +75,11 @@ Model stylesheets set per-node models inside the workflow graph, but you can als

 ### CLI flags

-Pass `--model` and optionally `--provider` to `arc run start`:
+Pass `--model` and optionally `--provider` to `arc run`:

 ```bash
-arc run start demo/01-hello.dot --model claude-opus-4-6
-arc run start demo/04-pipeline.dot --model gemini-3.1-pro-preview --provider gemini
+arc run demo/01-hello.dot --model claude-opus-4-6
+arc run demo/04-pipeline.dot --model gemini-3.1-pro-preview --provider gemini
 ```

 These flags set the default model for all nodes that don't have an explicit model assigned via a stylesheet.
@ -105,7 +105,7 @@ gemini = ["anthropic", "openai"]
 Then launch with:

 ```bash
-arc run start run.toml
+arc run run.toml
 ```

 The `[llm.fallbacks]` table is optional. It maps each provider to an ordered list of fallback providers to try when the primary is unavailable.
--- a/docs/core-concepts/workflows.mdx
+++ b/docs/core-concepts/workflows.mdx
@ -3,7 +3,7 @@ title: "Workflows"
 description: "Core workflow concepts in Arc"
 ---

-A workflow is a directed graph that defines a repeatable process for AI agents, shell commands, and human decisions. Unlike a DAG (directed acyclic graph), an Arc workflow can and often does include loops — for example, implement-test-fix cycles that repeat until tests pass. You write workflows in [Graphviz DOT](/reference/dot-language), check them into version control, and run them with `arc run start`.
+A workflow is a directed graph that defines a repeatable process for AI agents, shell commands, and human decisions. Unlike a DAG (directed acyclic graph), an Arc workflow can and often does include loops — for example, implement-test-fix cycles that repeat until tests pass. You write workflows in [Graphviz DOT](/reference/dot-language), check them into version control, and run them with `arc run`.

 ## Anatomy of a workflow

@ -112,13 +112,13 @@ validate [label="Validate", prompt="Run the test suite and verify all tests pass
 From the CLI:

 ```bash
-arc run start workflow.dot
+arc run workflow.dot
 ```

 Or from a [run config TOML](/execution/run-configuration) for repeatable, parameterized runs:

 ```bash
-arc run start run.toml
+arc run run.toml
 ```

 See the [Quick Start](/getting-started/quick-start) to try it out, or browse the [example workflows](/examples/implement-feature) for real-world patterns.
--- a/docs/examples/nlspec-conformance.mdx
+++ b/docs/examples/nlspec-conformance.mdx
@ -67,7 +67,7 @@ digraph NLSpecConformance {
 ```

 ```bash
-arc run start workflows/nlspec-conformance.dot
+arc run workflows/nlspec-conformance.dot
 ```

 ## How it works
--- a/docs/examples/semantic-port.mdx
+++ b/docs/examples/semantic-port.mdx
@ -240,7 +240,7 @@ downstream_lang = "go"
 Launch with:

 ```bash
-arc run start semport.toml
+arc run semport.toml
 ```

 ## Adapting this pattern
--- a/docs/examples/solitaire.mdx
+++ b/docs/examples/solitaire.mdx
@ -281,7 +281,7 @@ dockerfile = "FROM python:3.12-slim\nRUN apt-get update && apt-get install -y gi
 ```

 ```bash
-arc run start build-solitaire.toml
+arc run build-solitaire.toml
 ```

 ## Adapting this pattern
--- a/docs/execution/checkpoints.mdx
+++ b/docs/execution/checkpoints.mdx
@ -97,7 +97,7 @@ There are two ways to resume an interrupted run:
 Resume from a `checkpoint.json` saved in the logs directory:

 ```bash
-arc run start workflow.dot --resume path/to/logs/checkpoint.json
+arc run workflow.dot --resume path/to/logs/checkpoint.json
 ```

 Arc loads the checkpoint, restores the context and execution state, and continues from the next node after the checkpoint.
@ -107,7 +107,7 @@ Arc loads the checkpoint, restores the context and execution state, and continue
 Resume from the Git branches created during a previous run:

 ```bash
-arc run start --run-branch arc/run/01JKXYZ...
+arc run --run-branch arc/run/01JKXYZ...
 ```

 This reads the checkpoint, manifest, and graph DOT from the metadata branch (`refs/arc/01JKXYZ...`), re-attaches a worktree to the existing run branch, and resumes execution. No workflow file argument is needed — everything is recovered from Git.
--- a/docs/execution/environments.mdx
+++ b/docs/execution/environments.mdx
@ -20,10 +20,10 @@ Set the sandbox provider via CLI flag, [run config TOML](/execution/run-configur

 ```bash
 # CLI flag
-arc run start workflow.dot --sandbox local
-arc run start workflow.dot --sandbox docker
-arc run start workflow.dot --sandbox daytona
-arc run start workflow.dot --sandbox exe
+arc run workflow.dot --sandbox local
+arc run workflow.dot --sandbox docker
+arc run workflow.dot --sandbox daytona
+arc run workflow.dot --sandbox exe
 ```

 ```toml title="run.toml"
@ -90,7 +90,7 @@ The Docker sandbox is configured through the `DockerSandboxConfig`:
 By default, the container is destroyed when the run finishes. To keep it alive for debugging:

 ```bash
-arc run start workflow.dot --sandbox docker --preserve-sandbox
+arc run workflow.dot --sandbox docker --preserve-sandbox
 ```

 Or in the run config:
@ -167,7 +167,7 @@ When using server defaults, labels are merged — run config labels override def
 Connect to a running Daytona sandbox via SSH for live debugging:

 ```bash
-arc run start workflow.dot --sandbox daytona --ssh
+arc run workflow.dot --sandbox daytona --ssh
 ```

 This creates temporary SSH credentials (valid for 60 minutes) and prints the connection command.
@ -177,7 +177,7 @@ This creates temporary SSH credentials (valid for 60 minutes) and prints the con
 Like Docker, Daytona sandboxes are destroyed on cleanup by default. Use `--preserve-sandbox` to keep them alive:

 ```bash
-arc run start workflow.dot --sandbox daytona --preserve-sandbox
+arc run workflow.dot --sandbox daytona --preserve-sandbox
 ```

 Arc prints the sandbox name so you can find it in the [Daytona dashboard](https://app.daytona.io/dashboard/sandboxes).
--- a/docs/execution/interviews.mdx
+++ b/docs/execution/interviews.mdx
@ -68,7 +68,7 @@ The `Interviewer` trait has a simple interface — `ask(question) → answer`
 The default for CLI runs. On a TTY, the console interviewer uses interactive widgets (arrow-key selection, checkbox multi-select, confirm prompts) via `dialoguer`. When stdin is piped (non-TTY), it falls back to a line-based reader with numbered options.

 ```bash
-arc run start workflow.dot
+arc run workflow.dot
 # At a human gate:
 # ? Approve Plan
 #   [1] A - [A] Approve
@ -97,7 +97,7 @@ For fully automated runs or CI pipelines, the auto-approve interviewer answers e
 Enable it with the `--auto-approve` flag:

 ```bash
-arc run start workflow.dot --auto-approve
+arc run workflow.dot --auto-approve
 ```

 ## Timeouts
@ -113,4 +113,3 @@ The human handler then checks the node's `human.default_choice` attribute. If se
 ```dot
 approve [shape=hexagon, label="Approve?", human.default_choice="deploy"]
 ```
-
--- a/docs/execution/observability.mdx
+++ b/docs/execution/observability.mdx
@ -140,7 +140,7 @@ cat ~/.arc/logs/01JKXYZ.../live.json
 Arc uses the `tracing` crate to write structured logs to `~/.arc/logs/YYYY-MM-DD.log`. Control the log level with the `ARC_LOG` environment variable:

 ```bash
-ARC_LOG=debug arc run start workflow.dot
+ARC_LOG=debug arc run workflow.dot
 ```

 | Level | What's logged |
@ -168,14 +168,14 @@ The CLI displays a live progress bar during execution with per-stage status, dur

 ### Listing runs

-Browse your run history with `arc run list`:
+Browse your run history with `arc ps`:

 ```bash
-arc run list
-arc run list --workflow PlanImplement
-arc run list --before 2026-03-01
-arc run list --label team=platform
-arc run list --json
+arc ps
+arc ps --workflow PlanImplement
+arc ps --before 2026-03-01
+arc ps --label team=platform
+arc ps --json
 ```

 This scans `~/.arc/logs/` and displays each run's ID, workflow name, status, and start time. Use `--json` for machine-readable output.
--- a/docs/execution/retros.mdx
+++ b/docs/execution/retros.mdx
@ -111,7 +111,7 @@ Retro: smooth — Successfully implemented the feature
 To skip retro generation, pass `--no-retro`:

 ```bash
-arc run start workflow.dot --no-retro
+arc run workflow.dot --no-retro
 ```

 ### API
--- a/docs/execution/run-configuration.mdx
+++ b/docs/execution/run-configuration.mdx
@ -6,7 +6,7 @@ description: "Configure workflow runs with TOML files"
 A run config is a TOML file that bundles a workflow graph with all the settings needed to execute it — the goal, model, sandbox, setup commands, variables, and hooks. Instead of passing a dozen CLI flags, you check a `.toml` file into version control and launch with a single command:

 ```bash
-arc run start run.toml
+arc run run.toml
 ```

 ## Minimal example
@ -331,5 +331,5 @@ Arc validates the run config when it loads:
 Use `--preflight` to validate a run config without executing it:

 ```bash
-arc run start run.toml --preflight
+arc run run.toml --preflight
 ```
--- a/docs/getting-started/quick-start.mdx
+++ b/docs/getting-started/quick-start.mdx
@ -62,13 +62,13 @@ This checks that your API keys, tools, and environment are working correctly.
 Try the hello world workflow:

 ```bash
-./target/release/arc run start demo/01-hello.dot
+./target/release/arc run demo/01-hello.dot
 ```

 Or a multi-step plan-approve-implement workflow with a human approval gate:

 ```bash
-./target/release/arc run start demo/10-plan-implement.dot
+./target/release/arc run demo/10-plan-implement.dot
 ```

 ## Start the API server
--- a/docs/human-tools/ssh-access.mdx
+++ b/docs/human-tools/ssh-access.mdx
@ -11,10 +11,10 @@ SSH access is only available with the Daytona sandbox provider. Local, Docker, a

 ## Enabling SSH access

-Pass the `--ssh` flag to `arc run start`:
+Pass the `--ssh` flag to `arc run`:

 ```bash
-arc run start workflow.dot --sandbox daytona --ssh
+arc run workflow.dot --sandbox daytona --ssh
 ```

 After the sandbox is created, Arc generates temporary SSH credentials (valid for 60 minutes) and prints the connection command:
@ -31,7 +31,7 @@ Copy and run the `ssh` command in a separate terminal to connect.
 By default, Daytona sandboxes are destroyed when the workflow finishes. To keep the sandbox running after the workflow completes — so you can continue debugging — combine `--ssh` with `--preserve-sandbox`:

 ```bash
-arc run start workflow.dot --sandbox daytona --ssh --preserve-sandbox
+arc run workflow.dot --sandbox daytona --ssh --preserve-sandbox
 ```

 Without `--preserve-sandbox`, the SSH session is terminated when the run ends and the sandbox is cleaned up.
--- a/docs/human-tools/vs-code.mdx
+++ b/docs/human-tools/vs-code.mdx
@ -19,7 +19,7 @@ VS Code remote access requires [SSH access](/human-tools/ssh-access), which is o
 1. Start a workflow with SSH access and a preserved sandbox:

   ```bash
-   arc run start workflow.dot --sandbox daytona --ssh --preserve-sandbox
+   arc run workflow.dot --sandbox daytona --ssh --preserve-sandbox
   ```

 2. Arc prints the SSH connection command:
--- a/docs/integrations/daytona.mdx
+++ b/docs/integrations/daytona.mdx
@ -24,7 +24,7 @@ description: "Run Arc workflows in sandboxed Daytona cloud environments"
 Set the sandbox provider in your run config TOML or via CLI flag:

 ```bash
-arc run start workflow.dot --sandbox daytona
+arc run workflow.dot --sandbox daytona
 ```

 ```toml title="run.toml"
@ -113,7 +113,7 @@ for your organization.
 Connect to a running Daytona sandbox via SSH for live debugging:

 ```bash
-arc run start workflow.dot --sandbox daytona --ssh
+arc run workflow.dot --sandbox daytona --ssh
 ```

 This creates temporary SSH credentials (valid for 60 minutes) and prints the connection command:
@ -135,7 +135,7 @@ Each sandbox gets a unique timestamped name (e.g. `arc-20260307-143022-a3f2`) an
 To keep a sandbox alive for debugging:

 ```bash
-arc run start workflow.dot --sandbox daytona --preserve-sandbox
+arc run workflow.dot --sandbox daytona --preserve-sandbox
 ```

 Or in the run config:
--- a/docs/integrations/exe-dev.mdx
+++ b/docs/integrations/exe-dev.mdx
@ -19,7 +19,7 @@ The exe.dev sandbox provider is **in progress** and not yet available for use. T
 ## Configuration

 ```bash
-arc run start workflow.dot --sandbox exe
+arc run workflow.dot --sandbox exe
 ```

 ```toml title="run.toml"
--- a/docs/integrations/sprites.mdx
+++ b/docs/integrations/sprites.mdx
@ -21,7 +21,7 @@ The Sprites sandbox provider is **in progress** and not yet available for use. T
 ## Configuration

 ```bash
-arc run start workflow.dot --sandbox sprites
+arc run workflow.dot --sandbox sprites
 ```

 ```toml title="run.toml"
--- a/docs/reference/architecture.mdx
+++ b/docs/reference/architecture.mdx
@ -12,7 +12,7 @@ At the core of both modes is the `WorkflowRunEngine`. It parses the DOT graph, w
 ## CLI mode

 ```bash
-arc run start workflow.dot --goal "Implement the login feature"
+arc run workflow.dot --goal "Implement the login feature"
 ```

 The CLI parses the workflow, creates the engine with a `ConsoleInterviewer`, and executes synchronously. Events are printed to stderr, progress is shown with terminal indicators, and human-in-the-loop questions are answered via interactive terminal prompts. When the run finishes, the process exits.
@ -91,7 +91,7 @@ The UI provides:

 | Feature | CLI mode | API mode |
 |---|---|---|
-| Command | `arc run start` | `arc serve` |
+| Command | `arc run` | `arc serve` |
 | Execution | Synchronous, single run | Async, queued with scheduler |
 | Concurrency | One run per process | Configurable (default 5) |
 | Human-in-the-loop | Terminal prompts | HTTP endpoints |
--- a/docs/reference/cli.mdx
+++ b/docs/reference/cli.mdx
@ -35,14 +35,14 @@ CLI flags always override `cli.toml` values, which override hardcoded defaults.

 ---

-## `arc run start`
+## `arc run`

 Launch a workflow from a `.dot` workflow file or `.toml` task config.

 ```bash
-arc run start <WORKFLOW>
-arc run start run.toml
-arc run start --run-branch arc/run/abc123
+arc run <WORKFLOW>
+arc run run.toml
+arc run --run-branch arc/run/abc123
 ```

 | Argument / Flag | Description |
@ -68,14 +68,14 @@ arc run start --run-branch arc/run/abc123
 `--preflight` conflicts with `--resume`, `--run-branch`, and `--dry-run`. `--run-branch` conflicts with `--resume`.
 </Note>

-## `arc run list`
+## `arc ps`

 List workflow runs stored in `~/.arc/logs`.

 ```bash
-arc run list
-arc run list --workflow deploy --label env=prod
-arc run list --json
+arc ps
+arc ps --workflow deploy --label env=prod
+arc ps --json
 ```

 | Flag | Description |
@ -86,14 +86,14 @@ arc run list --json
 | `--orphans` | Include orphan directories (no `manifest.json`) |
 | `--json` | Output as JSON |

-## `arc run prune`
+## `arc system prune`

 Delete old workflow runs. Dry-run by default — pass `--yes` to actually delete.

 ```bash
-arc run prune --before 2026-01-01
-arc run prune --before 2026-01-01 --yes
-arc run prune --orphans --yes
+arc system prune --before 2026-01-01
+arc system prune --before 2026-01-01 --yes
+arc system prune --orphans --yes
 ```

 | Flag | Description |
--- a/docs/reference/logs-directory.mdx
+++ b/docs/reference/logs-directory.mdx
@ -17,7 +17,7 @@ The log level defaults to `info`. Set `ARC_LOG=debug` or pass `--debug` for verb

 ## Run directories

-Each `arc run start` invocation creates a timestamped directory:
+Each `arc run` invocation creates a timestamped directory:

 ```
 ~/.arc/logs/arc-run-20260307-143022/
@ -81,12 +81,12 @@ Manager nodes that run sub-workflows write a nested `child/` directory containin

 ## Browsing runs

-Use `arc run list` to scan the logs directory and display a table of all runs with their status, workflow name, and timestamps. Pass `--json` for machine-readable output.
+Use `arc ps` to scan the logs directory and display a table of all runs with their status, workflow name, and timestamps. Pass `--json` for machine-readable output.

 ```bash
-arc run list
-arc run list --json
-arc run list --filter workflow=my-workflow
+arc ps
+arc ps --json
+arc ps --filter workflow=my-workflow
 ```

 ## Full directory tree
--- a/docs/tutorials/branch-loop.mdx
+++ b/docs/tutorials/branch-loop.mdx
@ -31,7 +31,7 @@ digraph BranchLoop {
 ```

 ```bash
-arc run start demo/05-branch-loop.dot
+arc run demo/05-branch-loop.dot
 ```

 ## Command nodes
--- a/docs/tutorials/ensemble.mdx
+++ b/docs/tutorials/ensemble.mdx
@ -52,7 +52,7 @@ digraph Ensemble {
 ```

 ```bash
-arc run start demo/11-ensemble.dot
+arc run demo/11-ensemble.dot
 ```

 <Note>
--- a/docs/tutorials/hello-world.mdx
+++ b/docs/tutorials/hello-world.mdx
@ -34,7 +34,7 @@ digraph Hello {
 Run it:

 ```bash
-arc run start demo/01-hello.dot
+arc run demo/01-hello.dot
 ```

 ### What's happening
@ -68,7 +68,7 @@ digraph ToolUse {
 ```

 ```bash
-arc run start demo/02-tool-use.dot
+arc run demo/02-tool-use.dot
 ```

 ### What's happening
@ -108,7 +108,7 @@ digraph SubAgent {
 ```

 ```bash
-arc run start demo/03-subagent.dot
+arc run demo/03-subagent.dot
 ```

 ### What's happening
--- a/docs/tutorials/multi-model.mdx
+++ b/docs/tutorials/multi-model.mdx
@ -36,7 +36,7 @@ digraph MultiModel {
 ```

 ```bash
-arc run start demo/08-multi-model.dot
+arc run demo/08-multi-model.dot
 ```

 ## Model stylesheets
--- a/docs/tutorials/parallel-review.mdx
+++ b/docs/tutorials/parallel-review.mdx
@ -40,7 +40,7 @@ digraph Parallel {
 ```

 ```bash
-arc run start demo/06-parallel.dot
+arc run demo/06-parallel.dot
 ```

 ## Fan-out with the fork node
--- a/docs/tutorials/plan-implement.mdx
+++ b/docs/tutorials/plan-implement.mdx
@ -32,7 +32,7 @@ digraph PlanImplement {
 ```

 ```bash
-arc run start demo/10-plan-implement.dot
+arc run demo/10-plan-implement.dot
 ```

 ## Human gates
--- a/docs/tutorials/sub-workflow.mdx
+++ b/docs/tutorials/sub-workflow.mdx
@ -62,7 +62,7 @@ digraph SubWorkflow {
 ```

 ```bash
-arc run start demo/12-sub-workflow.dot
+arc run demo/12-sub-workflow.dot
 ```

 ## The house node
--- a/docs/workflows/human-in-the-loop.mdx
+++ b/docs/workflows/human-in-the-loop.mdx
@ -60,7 +60,7 @@ If the timeout elapses without a response, the workflow continues to the default
 For testing or fully automated runs, pass `--auto-approve` to skip all human gates:

 ```bash
-arc run start workflow.dot --auto-approve
+arc run workflow.dot --auto-approve
 ```

 Auto-approve selects `Yes` for yes/no gates and the first option for multiple-choice gates.
--- a/docs/workflows/variables.mdx
+++ b/docs/workflows/variables.mdx
@ -36,7 +36,7 @@ digraph Check {
 }
 ```

-When launched with `arc run start run.toml`, Arc replaces `$repo_name`, `$repo_url`, and `$language` with their values before parsing the graph.
+When launched with `arc run run.toml`, Arc replaces `$repo_name`, `$repo_url`, and `$language` with their values before parsing the graph.

 ### Undefined variables

--- a/test/docs/CHECKLIST.md
+++ b/test/docs/CHECKLIST.md
@ -49,19 +49,19 @@
 | 39 | workflows/variables/check.dot | PASS | has run.toml |
 | 40 | workflows/variables/example.dot | PASS | added start/exit |

-## Phase 2: Dry Run (`arc run start --dry-run --auto-approve`)
+## Phase 2: Dry Run (`arc run --dry-run --auto-approve`)

 | # | File | Status | Notes |
 |---|------|--------|-------|
 | 1-40 | (all) | | |

-## Phase 3: Haiku (`arc run start --model claude-haiku-4-5 --auto-approve`)
+## Phase 3: Haiku (`arc run --model claude-haiku-4-5 --auto-approve`)

 | # | File | Status | Notes |
 |---|------|--------|-------|
 | 1-40 | (all) | | |

-## Phase 4: Full (`arc run start --auto-approve`)
+## Phase 4: Full (`arc run --auto-approve`)

 | # | File | Status | Notes |
 |---|------|--------|-------|