@clipboard-health/groundcrew 1.12.6 → 2.1.0

package/README.md

@@ -15,7 +15,7 @@ This installs the `crew` binary. `@clipboard-health/clearance` is pulled in tran
 
 ## Quickstart
 
-1. **Install prereqs.** Node 24, `git`, `cmux` _or_ `tmux`, and the agent CLIs themselves (`claude`, `codex`, `cursor-agent`, ...). Local runs require macOS with [Safehouse](https://agent-safehouse.dev/) on `PATH`; Linux/WSL hosts must run tickets through the configured remote runner by adding the `agent-remote` label. Sprite is currently the only remote provider. Optional: `codexbar` for session-usage gating. The `workspaceKind` config key picks the workspace backend (`auto` resolves to cmux when installed, else tmux).
+1. **Install prereqs.** Node 24, `git`, `cmux` _or_ `tmux`, and the agent CLIs themselves (`claude`, `codex`, `cursor-agent`, ...). Groundcrew is **macOS-only** and requires [Safehouse](https://agent-safehouse.dev/) on `PATH`. Optional: `codexbar` for session-usage gating. The `workspaceKind` config key picks the workspace backend (`auto` resolves to cmux when installed, else tmux).
 
 2. **Create a Linear project to scope your work.** Any team works — make a project inside it and drop tickets in. The orchestrator polls by project, not by team, so you don't need a dedicated team.
 
@@ -49,24 +49,23 @@ This installs the `crew` binary. `@clipboard-health/clearance` is pulled in tran
 
    `crew` resolves the config path as: `GROUNDCREW_CONFIG` if set → `${XDG_CONFIG_HOME:-$HOME/.config}/groundcrew/config.ts` if it exists → a `config.ts` sitting next to `crew`'s own source files (only useful from a local checkout; see [Hacking on groundcrew](#hacking-on-groundcrew)). Set `GROUNDCREW_CONFIG` only when you want to override the XDG location.
 
-4. **Provide a Linear API key.** `crew` expects `LINEAR_API_KEY` in its environment. Any mechanism works — shell export, [direnv](https://direnv.net/), a `.env` file you `source`, or piping through `op run` if you store the credential in 1Password:
+4. **Provide a Linear API key.** `crew` reads the key from `GROUNDCREW_LINEAR_API_KEY` first, then falls back to `LINEAR_API_KEY`. Prefer `GROUNDCREW_LINEAR_API_KEY` so the value does not clash with other tools that consume `LINEAR_API_KEY`. Any mechanism works — shell export, [direnv](https://direnv.net/), a `.env` file you `source`, or piping through `op run` if you store the credential in 1Password:
 
    ```bash
    # Direct
-   export LINEAR_API_KEY="lin_api_..."
+   export GROUNDCREW_LINEAR_API_KEY="lin_api_..."
    crew doctor
 
    # Via 1Password CLI (`op`), if you keep the key in a vault
-   echo "LINEAR_API_KEY='op://<vault>/LINEAR_API_KEY/credential'" > .env.1password
+   echo "GROUNDCREW_LINEAR_API_KEY='op://<vault>/LINEAR_API_KEY/credential'" > .env.1password
    op run --env-file .env.1password -- crew doctor
    ```
 
-5. **Prepare the runner and agent auth.** Groundcrew supports one local runner and one remote runner:
-   - macOS local: `cmux` or `tmux` workspace, Safehouse on `PATH`, `clearance`, and locally authenticated agent CLIs.
-   - macOS remote: local `cmux` or `tmux` workspace that launches the configured remote runner.
-   - Linux/WSL remote: `cmux` or `tmux` workspace that launches the configured remote runner. Label tickets `agent-remote`; local execution is not supported.
+   `LINEAR_API_KEY` continues to work for existing setups; if both variables are set, `GROUNDCREW_LINEAR_API_KEY` wins.
 
-   Local setup fails before creating a worktree when the host is not macOS or `safehouse` is missing. `models.isolation`, per-model `isolation`, and per-model `sandbox` are legacy keys and now fail config validation.
+5. **Prepare the runner and agent auth.** Groundcrew supports one runner: a `cmux` or `tmux` workspace on macOS, with Safehouse on `PATH`, `clearance`, and locally authenticated agent CLIs.
+
+   Setup fails before creating a worktree when the host is not macOS or `safehouse` is missing. `models.isolation`, per-model `isolation`, and per-model `sandbox` are legacy keys and now fail config validation.
 
 6. **Set the clearance allowlist for local macOS runs.** Groundcrew starts `clearance` from `@clipboard-health/clearance` on `http://127.0.0.1:19999` (skipping the launch if something is already listening) and runs the agent through the bundled `safehouse-clearance` wrapper. Clearance refuses to start without an allowlist — see [its README](https://github.com/ClipboardHealth/core-utils/tree/main/packages/clearance) for the proxy's env vars, log paths, and DNS rules. The shortest path is to set the env before `crew run`:
 
@@ -84,36 +83,7 @@ This installs the `crew` binary. `@clipboard-health/clearance` is pulled in tran
 
    Watch `${XDG_CACHE_HOME:-$HOME/.cache}/clearance/clearance.log` for `DENY` lines and add only the domains your agents actually need.
 
-7. **Optional: prepare a remote runner.** The current remote provider is Sprite, so setup is intentionally explicit: choose which agent CLIs to authenticate and which MCP servers to add. `--mcp` adds and authenticates only the servers you name; it does not attempt to authenticate every MCP server visible in your Claude account.
-
-   ```bash
-   crew remote setup crew-claude-1 \
-     --claude \
-     --codex \
-     --copy-local-codex-auth \
-     --datadog \
-     --github \
-     --git-name "Your Name" \
-     --git-email "you@users.noreply.github.com" \
-     --mcp linear \
-     --mcp slack \
-     --checkpoint
-   ```
-
-   Known MCP aliases are `linear`, `slack`, and `notion`. For another HTTP MCP server, pass `--mcp name=https://example.com/mcp`. The command creates the remote runner if needed, prepares `~/dev`, configures Git, runs selected auth flows, and adds selected MCP servers to Claude Code. With the Sprite provider, `--claude` detects Claude Code's dynamic localhost OAuth callback port inside the remote runner and temporarily runs `sprite proxy` for that port while login runs. Selected MCP servers authenticate through one interactive Claude Code session by default, and when combined with `--claude`, setup skips the separate headless Claude login and uses that one session for both Claude login and MCP auth while forwarding Claude localhost callback ports. `--copy-local-codex-auth` copies `${CODEX_HOME:-$HOME/.codex}/auth.json` into `/home/sprite/.codex/auth.json` and then verifies `codex login status`; it never prints the file contents. `--datadog` installs a pinned `pup` release in the remote runner, verifies its checksum, installs the `dd-pup` guidance for Claude and Codex, verifies `pup auth status`, and when auth is missing temporarily runs `sprite proxy` for the OAuth callback while `pup auth login --read-only` runs in the remote runner. Open the Datadog URL printed by `pup` if your terminal does not open it automatically.
-
-   Repo setup is separate from runner setup and should run after the ticket branch exists, immediately before launching an agent. It clones/fetches the repo in the remote runner using `git.remote`, checks out the requested branch (creating it from the base branch when it does not exist on that remote), forwards only build-time secrets for the dependency install, removes the temporary secret file, clears those env vars, and then exits. It uses groundcrew's remote setup command.
-
-   ```bash
-   op run --env-file "${XDG_CONFIG_HOME:-$HOME/.config}/groundcrew/op.env" -- \
-     crew remote bootstrap crew-claude-1 core-utils --branch rocky-team-123
-   ```
-
-   By default bootstrap forwards any locally set `NPM_TOKEN` and `BUF_TOKEN`. Use repeated `--secret <ENV_NAME>` to require a specific set, or `--no-secrets` for public installs. Do not checkpoint after repo bootstrap; dependency state is branch-specific and should be refreshed per ticket.
-
-   To run a ticket remotely through the orchestrator or `crew run --ticket`, label it with `agent-remote` plus the agent label you want, for example `agent-claude` or `agent-codex`. `agent-remote` alone uses `models.default`. Groundcrew keeps cmux/tmux local, creates a per-ticket git worktree in the remote runner under `remote.worktreeRoot`, and asks the configured provider to launch the agent. The Sprite provider emits `sprite exec --tty`. Use `crew remote sessions [<runner-name>]` to inspect active remote sessions and `crew remote attach <session-id-or-command> [--runner <runner-name>]` to attach to one; both commands default to `remote.runnerName` when the runner name is omitted.
-
-8. **Run.** Doctor first, then a dry run, then the real thing:
+7. **Run.** Doctor first, then a dry run, then the real thing:
 
    ```bash
    crew doctor
@@ -126,37 +96,31 @@ This installs the `crew` binary. `@clipboard-health/clearance` is pulled in tran
 
 Required fields are marked **required**; everything else has a default and can be omitted from `config.ts`.
 
-| Key                                     | Default                               | What it does                                                                                                                                                                                                                                                                              |
-| --------------------------------------- | ------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `linear.projectSlug`                    | **required**                          | Linear project URL slug (e.g. `ai-strategy-5152195762f3`). The trailing 12-char hex `slugId` is what's matched against Linear's API; the leading name keeps `config.ts` self-documenting and the lookup survives project renames.                                                         |
-| `linear.statuses.todo`                  | `"Todo"`                              | Status name picked up for new work.                                                                                                                                                                                                                                                       |
-| `linear.statuses.inProgress`            | `"In Progress"`                       | Status set after a workspace is provisioned; counts toward `maximumInProgress`.                                                                                                                                                                                                           |
-| `linear.statuses.done`                  | `"Done"`                              | Status that triggers worktree cleanup.                                                                                                                                                                                                                                                    |
-| `linear.statuses.terminal`              | `["Done"]`                            | Additional status names treated as terminal for cleanup, board remaining counts, and blocker checks. The `done` status is always included.                                                                                                                                                |
-| `git.remote`                            | `"origin"`                            | Remote used for `fetch` and as the worktree base ref.                                                                                                                                                                                                                                     |
-| `git.defaultBranch`                     | `"main"`                              | Branch fetched from `git.remote` and used as the worktree base.                                                                                                                                                                                                                           |
-| `workspace.projectDir`                  | **required**                          | Parent dir for cloned repos and local sibling ticket worktrees. Remote ticket worktrees live in `remote.worktreeRoot` on the remote runner.                                                                                                                                               |
-| `workspace.knownRepositories`           | **required**                          | Repos searched for in ticket descriptions to infer where work belongs. A ticket labeled for groundcrew (`agent-*`) fails fast when no known repo appears; unlabeled tickets are ignored.                                                                                                  |
-| `orchestrator.maximumInProgress`        | `4`                                   | Cap on tickets in `linear.statuses.inProgress` at once.                                                                                                                                                                                                                                   |
-| `orchestrator.pollIntervalMilliseconds` | `120_000`                             | Poll interval in `--watch` mode.                                                                                                                                                                                                                                                          |
-| `orchestrator.sessionLimitPercentage`   | `85`                                  | Number in `(0, 100]`. A model whose codexbar session window exceeds this percentage is skipped that tick.                                                                                                                                                                                 |
-| `models.default`                        | `"claude"`                            | Tiebreak for `agent-any` resolution and fallback for explicit but unknown `agent-*` labels. Also used by `crew run --ticket <TICKET>` for unlabeled tickets. `crew run` without `--ticket` ignores unlabeled tickets and does not apply this default. Must exist in `models.definitions`. |
-| `models.definitions`                    | `{ claude, codex }`                   | Agent definitions. Additive merge with shipped defaults.                                                                                                                                                                                                                                  |
-| `models.definitions.<name>.cmd`         | —                                     | Shell command launched for the model. Local macOS runs execute in the worktree through Safehouse/clearance; remote runs execute inside the remote worktree. `{{worktree}}` is replaced before launch and legacy `{{sandbox}}` expands to an empty string.                                 |
-| `models.definitions.<name>.color`       | —                                     | Color for the workspace status pill (cmux only; tmux silently drops it).                                                                                                                                                                                                                  |
-| `models.definitions.<name>.usage`       | optional                              | If set, codexbar usage is fetched for this model and gated by `sessionLimitPercentage`. Omit to never gate. When `usage.codexbar.source` is omitted, groundcrew uses `auto` on macOS and `cli` elsewhere.                                                                                 |
-| `models.definitions.<name>.disabled`    | optional                              | When set to exactly `true`, drops the named shipped default (`claude` or `codex`). Doctor skips probing it; `agent-<name>` labels fall back to `models.default` with a warning. See "Disabling a shipped default" below.                                                                  |
-| `prompts.initial`                       | (template)                            | First message sent to the agent. Placeholders: `{{ticket}}`, `{{worktree}}`, `{{title}}`, `{{description}}`.                                                                                                                                                                              |
-| `workspaceKind`                         | `"auto"`                              | Terminal session manager. `"auto"` picks `cmux` when on PATH, else `tmux`. Set to `"cmux"` or `"tmux"` to fail loudly when the chosen backend is missing. tmux windows live in a dedicated `groundcrew` session.                                                                          |
-| `remote.provider`                       | `"sprite"`                            | Remote runner provider used for tickets labeled `agent-remote`. Sprite is currently the only provider.                                                                                                                                                                                    |
-| `remote.runnerName`                     | `"crew-claude-1"`                     | Remote runner used for tickets labeled `agent-remote`.                                                                                                                                                                                                                                    |
-| `remote.owner`                          | `"ClipboardHealth"`                   | GitHub owner used when cloning bare repository names inside the remote runner.                                                                                                                                                                                                            |
-| `remote.repoRoot`                       | `"/home/sprite/dev"`                  | Shared clone root inside the remote runner.                                                                                                                                                                                                                                               |
-| `remote.worktreeRoot`                   | `"/home/sprite/groundcrew/worktrees"` | Per-ticket remote worktree root inside the remote runner.                                                                                                                                                                                                                                 |
-| `remote.secretNames`                    | `["NPM_TOKEN", "BUF_TOKEN"]`          | Build-only env vars that may be uploaded for remote dependency setup, then unset before the agent process starts.                                                                                                                                                                         |
-| `logging.file`                          | XDG state path                        | Append-mode log file destination. `log()` / `logEvent()` tee here in addition to stdout, so a vanished workspace doesn't take the evidence with it. Defaults to `${XDG_STATE_HOME:-$HOME/.local/state}/groundcrew/groundcrew.log`.                                                        |
-
-The branch prefix (`<prefix>-<TICKET>`) is derived from your OS username (`os.userInfo().username`), not configured. Agent selection looks for a top-level Linear label named `agent-<model>` (e.g. `agent-claude`, `agent-codex`). Add `agent-remote` to run that ticket in the configured remote runner instead of locally; `agent-remote` is a modifier label, not a model. **`crew run` without `--ticket` only fetches tickets with an `agent-*` label** — the GraphQL query filters them server-side, so unlabeled tickets are never returned by Linear's API and do not appear in the rendered board. Use `crew run --ticket <TICKET>` to provision an unlabeled ticket on demand (manual setup falls back to `models.default`). The reserved label `agent-any` routes the ticket to the configured model with the most available session capacity (lowest codexbar session-used percent), skipping any model already over `sessionLimitPercentage`. With no usage data, `agent-any` resolves to `models.default`. The name `any` cannot be used in `models.definitions`. Todo tickets blocked by Linear issues that are not in `linear.statuses.terminal` are skipped until their blockers reach a terminal status.
+| Key                                     | Default             | What it does                                                                                                                                                                                                                                                                              |
+| --------------------------------------- | ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `linear.projectSlug`                    | **required**        | Linear project URL slug (e.g. `ai-strategy-5152195762f3`). The trailing 12-char hex `slugId` is what's matched against Linear's API; the leading name keeps `config.ts` self-documenting and the lookup survives project renames.                                                         |
+| `linear.statuses.todo`                  | `"Todo"`            | Status name picked up for new work.                                                                                                                                                                                                                                                       |
+| `linear.statuses.inProgress`            | `"In Progress"`     | Status set after a workspace is provisioned; counts toward `maximumInProgress`.                                                                                                                                                                                                           |
+| `linear.statuses.done`                  | `"Done"`            | Status that triggers worktree cleanup.                                                                                                                                                                                                                                                    |
+| `linear.statuses.terminal`              | `["Done"]`          | Additional status names treated as terminal for cleanup, board remaining counts, and blocker checks. The `done` status is always included.                                                                                                                                                |
+| `git.remote`                            | `"origin"`          | Remote used for `fetch` and as the worktree base ref.                                                                                                                                                                                                                                     |
+| `git.defaultBranch`                     | `"main"`            | Branch fetched from `git.remote` and used as the worktree base.                                                                                                                                                                                                                           |
+| `workspace.projectDir`                  | **required**        | Parent dir for cloned repos and sibling ticket worktrees.                                                                                                                                                                                                                                 |
+| `workspace.knownRepositories`           | **required**        | Repos searched for in ticket descriptions to infer where work belongs. A ticket labeled for groundcrew (`agent-*`) fails fast when no known repo appears; unlabeled tickets are ignored.                                                                                                  |
+| `orchestrator.maximumInProgress`        | `4`                 | Cap on tickets in `linear.statuses.inProgress` at once.                                                                                                                                                                                                                                   |
+| `orchestrator.pollIntervalMilliseconds` | `120_000`           | Poll interval in `--watch` mode.                                                                                                                                                                                                                                                          |
+| `orchestrator.sessionLimitPercentage`   | `85`                | Number in `(0, 100]`. A model whose codexbar session window exceeds this percentage is skipped that tick.                                                                                                                                                                                 |
+| `models.default`                        | `"claude"`          | Tiebreak for `agent-any` resolution and fallback for explicit but unknown `agent-*` labels. Also used by `crew run --ticket <TICKET>` for unlabeled tickets. `crew run` without `--ticket` ignores unlabeled tickets and does not apply this default. Must exist in `models.definitions`. |
+| `models.definitions`                    | `{ claude, codex }` | Agent definitions. Additive merge with shipped defaults.                                                                                                                                                                                                                                  |
+| `models.definitions.<name>.cmd`         | —                   | Shell command launched for the model. Runs in the worktree through Safehouse/clearance. `{{worktree}}` is replaced before launch and legacy `{{sandbox}}` expands to an empty string.                                                                                                     |
+| `models.definitions.<name>.color`       | —                   | Color for the workspace status pill (cmux only; tmux silently drops it).                                                                                                                                                                                                                  |
+| `models.definitions.<name>.usage`       | optional            | If set, codexbar usage is fetched for this model and gated by `sessionLimitPercentage`. Omit to never gate. When `usage.codexbar.source` is omitted, groundcrew uses `auto` on macOS and `cli` elsewhere.                                                                                 |
+| `models.definitions.<name>.disabled`    | optional            | When set to exactly `true`, drops the named shipped default (`claude` or `codex`). Doctor skips probing it; `agent-<name>` labels fall back to `models.default` with a warning. See "Disabling a shipped default" below.                                                                  |
+| `prompts.initial`                       | (template)          | First message sent to the agent. Placeholders: `{{ticket}}`, `{{worktree}}`, `{{title}}`, `{{description}}`.                                                                                                                                                                              |
+| `workspaceKind`                         | `"auto"`            | Terminal session manager. `"auto"` picks `cmux` when on PATH, else `tmux`. Set to `"cmux"` or `"tmux"` to fail loudly when the chosen backend is missing. tmux windows live in a dedicated `groundcrew` session.                                                                          |
+| `logging.file`                          | XDG state path      | Append-mode log file destination. `log()` / `logEvent()` tee here in addition to stdout, so a vanished workspace doesn't take the evidence with it. Defaults to `${XDG_STATE_HOME:-$HOME/.local/state}/groundcrew/groundcrew.log`.                                                        |
+
+The branch prefix (`<prefix>-<TICKET>`) is derived from your OS username (`os.userInfo().username`), not configured. Agent selection looks for a top-level Linear label named `agent-<model>` (e.g. `agent-claude`, `agent-codex`). **`crew run` without `--ticket` only fetches tickets with an `agent-*` label** — the GraphQL query filters them server-side, so unlabeled tickets are never returned by Linear's API and do not appear in the rendered board. Use `crew run --ticket <TICKET>` to provision an unlabeled ticket on demand (manual setup falls back to `models.default`). The reserved label `agent-any` routes the ticket to the configured model with the most available session capacity (lowest codexbar session-used percent), skipping any model already over `sessionLimitPercentage`. With no usage data, `agent-any` resolves to `models.default`. The name `any` cannot be used in `models.definitions`. Todo tickets blocked by Linear issues that are not in `linear.statuses.terminal` are skipped until their blockers reach a terminal status.
 
 ### Disabling a shipped default
 
@@ -191,34 +155,24 @@ Rules:
 ## Manual commands
 
 ```bash
-crew remote setup crew-claude-1 --claude --codex --copy-local-codex-auth --datadog --github --mcp linear --checkpoint
-crew remote bootstrap crew-claude-1 core-utils --branch rocky-team-123
-crew remote sessions
-crew remote attach <session-id-or-command> --runner crew-claude-1
-crew remote ps crew-claude-1
-crew remote interrupt <process-group-id> --runner crew-claude-1
 crew run --ticket <TICKET>
 crew setup repos [--dry-run] [<repo>...]
 crew cleanup <TICKET>
 ```
 
-`crew run --ticket <TICKET>` provisions a single ticket the same way the orchestrator would: the repo is parsed from the ticket's Linear description, the model comes from the ticket's `agent-*` label, manual setup falls back to `models.default` for unlabeled tickets, and `agent-remote` is honored. If the description does not mention a repo from `workspace.knownRepositories`, setup fails before provisioning. `--watch` and `--ticket` are mutually exclusive — `--watch` drives the orchestrator loop; `--ticket` provisions one ticket and exits. `crew cleanup <TICKET>` resolves to every tracked worktree carrying that ticket id (host and remote kinds, across repos) and tears them all down. To inspect remote sessions, run `crew remote sessions` or pass an explicit runner name. To attach to a listed session id or command selector, run `crew remote attach <session-id-or-command>`. If an attached agent appears stuck in a long-running shell tool, use `crew remote ps <runner-name>` to find the child process group (`PGID`) under the agent, then use `crew remote interrupt <PGID> --runner <runner-name>` to send SIGINT to that child command without killing the agent session. With the Sprite provider, if cleanup cannot remove a remote worktree because the agent is still running, stop that session with `sprite sessions kill -s crew-claude-1 <session-id>` and retry cleanup. To inspect codexbar session windows directly, run `codexbar usage`; the orchestrator already gates on this internally via `orchestrator.sessionLimitPercentage`.
+`crew run --ticket <TICKET>` provisions a single ticket the same way the orchestrator would: the repo is parsed from the ticket's Linear description and the model comes from the ticket's `agent-*` label (manual setup falls back to `models.default` for unlabeled tickets). If the description does not mention a repo from `workspace.knownRepositories`, setup fails before provisioning. `--watch` and `--ticket` are mutually exclusive — `--watch` drives the orchestrator loop; `--ticket` provisions one ticket and exits. `crew cleanup <TICKET>` resolves to every tracked worktree carrying that ticket id (across repos) and tears them all down. To inspect codexbar session windows directly, run `codexbar usage`; the orchestrator already gates on this internally via `orchestrator.sessionLimitPercentage`.
 
 ## Gotchas
 
-- **Local execution is macOS plus Safehouse only.** There is no `models.isolation` strategy and no direct local execution mode. On Linux/WSL, label tickets `agent-remote` and run them through the configured remote runner.
+- **Execution is macOS plus Safehouse only.** There is no `models.isolation` strategy and no direct local execution mode. Linux/WSL is not supported.
 - **Safehouse-already-wrapped commands are not re-wrapped.** If a `models.definitions.<name>.cmd` already starts with `safehouse`, groundcrew assumes that command owns its Safehouse flags and does not add the `safehouse-clearance` wrapper a second time. Changing the proxy's allowlist after it's running requires killing the PID in `${XDG_CACHE_HOME:-$HOME/.cache}/clearance/clearance.pid` so the next launch picks up the new env.
 - **Legacy Docker Sandboxes state is unmanaged.** Groundcrew no longer discovers or cleans `.sbx` worktrees or persistent Docker Sandboxes containers. If you have old state, inspect and remove it manually with `sbx`.
-- **Remote cleanup is also conservative.** `crew cleanup` removes tracked remote worktrees and branches, but it does not kill active remote sessions. Use `crew remote sessions [<runner-name>]` to inspect sessions and, with the Sprite provider, `sprite sessions kill -s <runner-name> <session-id>` when Git reports a worktree is busy.
 - **Dead tmux windows vanish by default.** When a wrapped agent command fails (e.g. `safehouse-clearance` not found, `npm install` crash), the tmux window closes immediately and the error scrolls into the void. Set `GROUNDCREW_KEEP_DEAD_WINDOWS=1` (any non-empty value works) in the env you launch `crew` from to flip the per-window `remain-on-exit` to `on`; the window stays open with the error visible. Close it manually with `tmux kill-window -t groundcrew:<ticket>` after diagnosis. tmux backend only.
-- **Long-running remote shell tools block agent input.** Claude Code and similar TUI agents cannot accept a new prompt while one of their shell tools is still running. Use `crew remote ps <runner-name>` to inspect the remote process tree; interrupt the tool's child `PGID`, not the agent session `PGID`, with `crew remote interrupt <PGID> --runner <runner-name>`.
-- **Codex auth in remote runners may need auth-file copy.** If `crew remote setup <runner-name> --codex` finishes interactive login but `codex login status` still fails inside the remote runner, rerun with `--copy-local-codex-auth` after confirming local Codex auth works.
-- **Usage source defaults are OS-aware.** `codexbar` usage uses `--source auto` on macOS so CodexBar can prefer account/web sources and fall back as it supports. On Linux/WSL it uses `--source cli`, so install the CodexBar Linux CLI and authenticate the provider CLIs inside that environment.
 - **Status names matter.** If your team uses `Started` instead of `In Progress`, set `linear.statuses.inProgress = "Started"`.
 - **Leaf-only.** Parent issues with children are ignored — sub-issues are the work items.
 - **Tickets stay in the in-progress status until something else moves them.** Groundcrew sets a ticket to `inProgress` when it provisions a workspace and never advances it. The next transition (typically "in review" when a PR opens) is left to your team's Linear automation rules.
 - **Project must be on a single Linear team in practice.** Cross-team projects work — the orchestrator caches the in-progress state ID per team — but every team in the project must use the same status name for `linear.statuses.inProgress`.
-- **Claude launches in bypass-permissions mode by default.** Groundcrew creates isolated per-ticket worktrees and unattended remote sessions, so the shipped `claude` command is `claude --permission-mode bypassPermissions` to avoid workspace-trust and tool-permission prompts blocking automation. Override `models.definitions.claude.cmd` if you want a stricter mode.
+- **Claude launches in bypass-permissions mode by default.** Groundcrew creates isolated per-ticket worktrees for unattended runs, so the shipped `claude` command is `claude --permission-mode bypassPermissions` to avoid workspace-trust and tool-permission prompts blocking automation. Override `models.definitions.claude.cmd` if you want a stricter mode.
 - **Doctor's command introspection is shallow.** Doctor reports whether the host can run local tickets with macOS plus Safehouse, then tokenizes model `cmd` and checks the first two non-flag tokens against PATH (so `safehouse claude --foo` checks both `safehouse` and `claude`). Boolean flags without values, env-var assignments (`FOO=1`), shell pipelines, and subshells are not parsed — verify those manually. In particular, `npx -y claude` and `env FOO=1 claude` only check the wrapper, not the wrapped CLI.
 - **Doctor checks every enabled model, including shipped defaults you didn't disable.** `models.definitions` includes both shipped defaults (`claude`, `codex`) by default via additive merge. If you only intend to label tickets `agent-claude` and don't have `codex` installed, set `models.definitions.codex: { disabled: true }` (see "Disabling a shipped default" under "Config reference"). Without that, doctor exits non-zero on a missing `codex` binary even though `crew run` would never route to it.
 - **Switch to tmux if cmux is misbehaving.** Set `workspaceKind: "tmux"` to force the tmux backend when cmux's CLI/socket bridge is flaky (symptoms: `cmux --json list-workspaces` returning `Failed to write to socket (Broken pipe)` or `Socket not found at ...cmux.sock` on every tick). tmux is more reliable — just a unix socket, no GUI app — at the cost of losing cmux's status pills, notifications, and vertical-tab sidebar.
@@ -233,7 +187,7 @@ For developers working on the package itself, clone this repo, run `npm install`
 cd ~/dev/c/groundcrew
 node --run crew -- doctor
 
-# With 1Password for LINEAR_API_KEY:
+# With 1Password for GROUNDCREW_LINEAR_API_KEY:
 node --run crew:op -- run --watch
 ```
 

package/configExample.ts

@@ -38,8 +38,7 @@ export const config: Config = {
   //   // Additive: defaults for `claude` and `codex` are merged in unless you
   //   // re-declare those keys here. Add a third agent (e.g. `cursor`) by
   //   // dropping it in this map and tagging tickets with `agent-cursor`.
-  //   // Local runs on macOS are always wrapped with Safehouse/clearance.
-  //   // Linux/WSL users should label tickets `agent-remote` to use the remote runner.
+  //   // Groundcrew runs agent commands through Safehouse/clearance unless already Safehouse-wrapped.
   //   definitions: {
   //     cursor: {
   //       cmd: "cursor-agent",
@@ -64,22 +63,6 @@ export const config: Config = {
   // // session and lose status-pill painting (cmux-only feature).
   // workspaceKind: "auto",
   //
-  // remote: {
-  //   // Provider implementation. Sprite is currently the only provider.
-  //   provider: "sprite",
-  //   // Tickets labeled `agent-remote` run through this shared remote runner.
-  //   runnerName: "crew-claude-1",
-  //   // Bare repository names are cloned as `${owner}/${repo}` inside the remote runner.
-  //   owner: "ClipboardHealth",
-  //   // Absolute paths inside the remote runner. Groundcrew creates one shared
-  //   // clone per repo and one remote git worktree per ticket.
-  //   repoRoot: "/home/sprite/dev",
-  //   worktreeRoot: "/home/sprite/groundcrew/worktrees",
-  //   // Build-only env vars forwarded for remote dependency setup, then
-  //   // unset before the agent process starts.
-  //   secretNames: ["NPM_TOKEN", "BUF_TOKEN"],
-  // },
-  //
   // logging: {
   //   // Append-mode log file destination. `log()` / `logEvent()` tee here
   //   // in addition to stdout, so a vanished workspace doesn't take the

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAsIA,wBAAsB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA8BvD"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AA0HA,wBAAsB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA8BvD"}

package/dist/cli.js

@@ -2,7 +2,6 @@ import { createRequire } from "node:module";
 import { cleanupWorkspaceCli } from "./commands/cleanupWorkspace.js";
 import { doctor } from "./commands/doctor.js";
 import { orchestrate } from "./commands/orchestrator.js";
-import { remoteCli } from "./commands/remoteSetup.js";
 import { setupReposCli } from "./commands/setupRepos.js";
 import { setupWorkspaceCli } from "./commands/setupWorkspace.js";
 import { errorMessage, writeError, writeOutput } from "./lib/util.js";
@@ -77,16 +76,6 @@ const SUBCOMMANDS = {
         usage: "repos [--dry-run] [<repo>...]",
         invoke: setupCli,
     },
-    remote: {
-        summary: "Create, authenticate, bootstrap, and inspect a remote runner",
-        usage: "setup <runner-name> [--claude] [--codex] [--datadog] [--github] [--mcp <alias|name=url>] [--checkpoint]\n" +
-            "           → crew remote bootstrap <runner-name> <repo> [--branch <branch>]\n" +
-            "           → crew remote sessions [<runner-name>]\n" +
-            "           → crew remote attach <session-id-or-command> [--runner <runner-name>]\n" +
-            "           → crew remote ps [<runner-name>]\n" +
-            "           → crew remote interrupt <process-group-id> [--runner <runner-name>]",
-        invoke: remoteCli,
-    },
 };
 function printHelp() {
     const width = Math.max(...Object.keys(SUBCOMMANDS).map((key) => key.length));

package/dist/commands/dispatcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dispatcher.d.ts","sourceRoot":"","sources":["../../src/commands/dispatcher.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,OAAO,EAAE,KAAK,UAAU,EAA2C,MAAM,uBAAuB,CAAC;AACjG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAGpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAczD,UAAU,cAAc;IACtB,MAAM,EAAE,cAAc,CAAC;IACvB,MAAM,EAAE,YAAY,CAAC;CACtB;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,CAAC,UAAU,EAAE;QAClB,KAAK,EAAE,UAAU,CAAC;QAClB,eAAe,EAAE,SAAS,aAAa,EAAE,CAAC;QAC1C,+FAA+F;QAC/F,KAAK,EAAE,CAAC,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;QACvD,MAAM,EAAE,OAAO,CAAC;QAChB,MAAM,CAAC,EAAE,WAAW,CAAC;KACtB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnB;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc,GAAG,UAAU,CAwNjE"}
+{"version":3,"file":"dispatcher.d.ts","sourceRoot":"","sources":["../../src/commands/dispatcher.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,OAAO,EAAE,KAAK,UAAU,EAA2C,MAAM,uBAAuB,CAAC;AACjG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAGpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAczD,UAAU,cAAc;IACtB,MAAM,EAAE,cAAc,CAAC;IACvB,MAAM,EAAE,YAAY,CAAC;CACtB;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,CAAC,UAAU,EAAE;QAClB,KAAK,EAAE,UAAU,CAAC;QAClB,eAAe,EAAE,SAAS,aAAa,EAAE,CAAC;QAC1C,+FAA+F;QAC/F,KAAK,EAAE,CAAC,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;QACvD,MAAM,EAAE,OAAO,CAAC;QAChB,MAAM,CAAC,EAAE,WAAW,CAAC;KACtB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnB;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc,GAAG,UAAU,CAmNjE"}

package/dist/commands/dispatcher.js

@@ -57,7 +57,6 @@ export function createDispatcher(deps) {
             ticket: verdict.issue.id,
             blockers: verdict.blockers,
             model: verdict.model,
-            runner: verdict.issue.runner,
         });
     }
     async function startEligibleIssue(start, dryRun, signal) {
@@ -68,14 +67,13 @@ export function createDispatcher(deps) {
         if (dryRun) {
             log(
             /* v8 ignore next @preserve -- classifyTodo forces recovery=false in dry-run, so the resume branch can't fire here */
-            `[dry-run] Would ${recovery ? "resume" : "start"} ${issue.id} in ${issue.repository} (${issue.model}, ${issue.runner})`);
+            `[dry-run] Would ${recovery ? "resume" : "start"} ${issue.id} in ${issue.repository} (${issue.model})`);
             logEvent("dispatch", {
                 outcome: "skipped",
                 reason: "dry_run",
                 ticket: issue.id,
                 model: issue.model,
                 repository: issue.repository,
-                runner: issue.runner,
             });
             return;
         }
@@ -88,7 +86,6 @@ export function createDispatcher(deps) {
                     repository: issue.repository,
                     ticket: issue.id,
                     model: issue.model,
-                    runner: issue.runner,
                 };
                 await (signal === undefined
                     ? setupWorkspace(config, setupOptions)
@@ -100,7 +97,6 @@ export function createDispatcher(deps) {
                 ticket: issue.id,
                 model: issue.model,
                 repository: issue.repository,
-                runner: issue.runner,
             });
         }
         catch (error) {
@@ -110,7 +106,6 @@ export function createDispatcher(deps) {
                 ticket: issue.id,
                 model: issue.model,
                 repository: issue.repository,
-                runner: issue.runner,
                 error: errorMessage(error),
             });
         }
@@ -183,7 +178,7 @@ export function createDispatcher(deps) {
         log(`${slots} slot(s) available, starting ${starts.length} ticket(s): ${starts.map(({ issue }) => `${issue.id}(${issue.model})`).join(", ")}`);
         logEvent("dispatch", {
             outcome: "starting",
-            tickets: starts.map(({ issue }) => `${issue.id}:${issue.model}:${issue.runner}`),
+            tickets: starts.map(({ issue }) => `${issue.id}:${issue.model}`),
         });
         for (const start of starts) {
             // oxlint-disable-next-line no-await-in-loop -- one workspace at a time avoids racing on git

package/dist/commands/doctor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAmIH,wBAAsB,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,CAmE/C"}
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAwIH,wBAAsB,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,CA6D/C"}

package/dist/commands/doctor.js

@@ -5,7 +5,7 @@
 import { existsSync, statSync } from "node:fs";
 import { loadConfig } from "../lib/config.js";
 import { detectHostCapabilities, which } from "../lib/host.js";
-import { errorMessage, readEnvironmentVariable, writeOutput } from "../lib/util.js";
+import { errorMessage, resolveLinearApiKey, writeOutput } from "../lib/util.js";
 import { resolveWorkspaceKind } from "../lib/workspaces.js";
 // Tokenization stops after this many non-flag tokens. Two is enough to
 // catch wrapper + wrapped CLI commands like `safehouse claude --foo`.
@@ -23,14 +23,21 @@ async function checkCmd(cmd, required, hint) {
     }
     return result;
 }
-function checkEnvironment(name) {
-    const value = readEnvironmentVariable(name);
-    const set = value !== undefined && value.length > 0;
+function checkLinearApiKey() {
+    const resolved = resolveLinearApiKey();
+    if (resolved !== undefined) {
+        return {
+            name: "linear api key",
+            ok: true,
+            required: true,
+            hint: `set via $${resolved.source}`,
+        };
+    }
     return {
-        name: `$${name}`,
-        ok: set,
+        name: "linear api key",
+        ok: false,
         required: true,
-        hint: set ? "set" : "export the variable in your shell",
+        hint: "export $GROUNDCREW_LINEAR_API_KEY or $LINEAR_API_KEY",
     };
 }
 function checkDir(path, label) {
@@ -89,8 +96,6 @@ function commandTokensToCheck(cmd) {
 function gatherToolTokens(config) {
     const all = new Set();
     for (const definition of Object.values(config.models.definitions)) {
-        // Local runs execute the agent command on the host; remote runs need the
-        // same command in the remote runner, but doctor cannot know ticket labels in advance.
         for (const token of commandTokensToCheck(definition.cmd)) {
             all.add(token);
         }
@@ -140,7 +145,7 @@ export async function doctor() {
     const workspaceOutcome = resolveWorkspaceOutcome(config, host);
     reportWorkspaceKind(config, workspaceOutcome);
     const checks = [
-        checkEnvironment("LINEAR_API_KEY"),
+        checkLinearApiKey(),
         await checkCmd("git", true, "https://git-scm.com/"),
         ...(await workspaceChecks(workspaceOutcome)),
         checkDir(config.workspace.projectDir, "workspace.projectDir"),
@@ -150,9 +155,7 @@ export async function doctor() {
     for (const token of toolTokens) {
         const required = localCapability.ok;
         // oxlint-disable-next-line no-await-in-loop -- doctor reports tools in deterministic order
-        const check = await checkCmd(token, required, required
-            ? undefined
-            : "required for local runs; remote runs need this inside the remote runner");
+        const check = await checkCmd(token, required, required ? undefined : "required for local runs");
         checks.push(check);
     }
     if (anyModelUsesUsage(config)) {
@@ -174,21 +177,14 @@ export async function doctor() {
     return true;
 }
 function localCapabilityCheck(host) {
-    if (!host.isMacOS) {
-        return {
-            name: "local runner (macOS + Safehouse)",
-            ok: false,
-            required: false,
-            hint: "required for local runs; on Linux/WSL use agent-remote with the remote runner",
-        };
-    }
+    const supportsLocalRunner = host.isSafehouseSupported && host.hasSafehouse;
     return {
         name: "local runner (macOS + Safehouse)",
-        ok: host.hasSafehouse,
+        ok: supportsLocalRunner,
         required: false,
-        hint: host.hasSafehouse
+        hint: supportsLocalRunner
             ? "ready"
-            : "required for local runs; install Safehouse from https://agent-safehouse.dev/ and ensure `safehouse` is on PATH",
+            : "groundcrew requires macOS with Safehouse on PATH (install from https://agent-safehouse.dev/)",
     };
 }
 function reportLocalCapability(check) {

package/dist/commands/setupWorkspace.d.ts

@@ -1,4 +1,4 @@
-import { type ResolvedConfig, type WorkspaceRunner } from "../lib/config.ts";
+import { type ResolvedConfig } from "../lib/config.ts";
 interface TicketDetails {
     title: string;
     description: string;
@@ -7,7 +7,6 @@ export interface SetupWorkspaceOptions {
     ticket: string;
     repository: string;
     model: string;
-    runner?: WorkspaceRunner;
     /** When provided, skip the Linear lookup for prompt-template fields. */
     details?: TicketDetails;
 }

package/dist/commands/setupWorkspace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setupWorkspace.d.ts","sourceRoot":"","sources":["../../src/commands/setupWorkspace.ts"],"names":[],"mappings":"AAOA,OAAO,EAGL,KAAK,cAAc,EACnB,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAC;AAc1B,UAAU,aAAa;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;CACrB;AAgBD,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,wEAAwE;IACxE,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB;AAED,MAAM,WAAW,wBAAwB;IACvC,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAsED,wBAAsB,cAAc,CAClC,MAAM,EAAE,cAAc,EACtB,OAAO,EAAE,qBAAqB,EAC9B,UAAU,GAAE,wBAA6B,GACxC,OAAO,CAAC,IAAI,CAAC,CA8Ef;AAuHD,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,GACjC,OAAO,CAAC,IAAI,CAAC,CAyBf"}
+{"version":3,"file":"setupWorkspace.d.ts","sourceRoot":"","sources":["../../src/commands/setupWorkspace.ts"],"names":[],"mappings":"AAOA,OAAO,EAAkC,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AASvF,UAAU,aAAa;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;CACrB;AAgBD,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB;AAED,MAAM,WAAW,wBAAwB;IACvC,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAmED,wBAAsB,cAAc,CAClC,MAAM,EAAE,cAAc,EACtB,OAAO,EAAE,qBAAqB,EAC9B,UAAU,GAAE,wBAA6B,GACxC,OAAO,CAAC,IAAI,CAAC,CAoEf;AA6CD,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,GACjC,OAAO,CAAC,IAAI,CAAC,CAoBf"}

package/dist/commands/setupWorkspace.js

@@ -3,15 +3,14 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { ensureClearance } from "@clipboard-health/clearance";
 import { fetchResolvedIssue } from "../lib/boardSource.js";
-import { BUILD_SECRET_NAMES, loadConfig, } from "../lib/config.js";
+import { BUILD_SECRET_NAMES, loadConfig } from "../lib/config.js";
 import { detectHostCapabilities } from "../lib/host.js";
-import { buildLaunchCommand, buildRemoteLaunchCommand, shellSingleQuote, } from "../lib/launchCommand.js";
+import { buildLaunchCommand, shellSingleQuote } from "../lib/launchCommand.js";
 import { createLinearIssueStatusUpdater } from "../lib/linearIssueStatus.js";
 import { assertLocalRunnerRequirements } from "../lib/localRunner.js";
-import { getRemoteRunnerProvider } from "../lib/spriteRemoteRunnerProvider.js";
 import { errorMessage, getLinearClient, log, readEnvironmentVariable } from "../lib/util.js";
 import { workspaces } from "../lib/workspaces.js";
-import { repoDirFor, worktrees } from "../lib/worktrees.js";
+import { worktrees } from "../lib/worktrees.js";
 async function fetchTicket(ticket) {
     const client = getLinearClient();
     const issue = await client.issue(ticket.toUpperCase());
@@ -34,9 +33,9 @@ function renderPrompt(template, variables) {
  * dir is `rm -rf`'d by the launch command (and rollback path), so cleanup
  * is already handled.
  */
-function stageBuildSecrets(promptDir, secretNames = BUILD_SECRET_NAMES) {
+function stageBuildSecrets(promptDir) {
     const lines = [];
-    for (const name of secretNames) {
+    for (const name of BUILD_SECRET_NAMES) {
         const value = readEnvironmentVariable(name);
         if (value === undefined || value.length === 0) {
             continue;
@@ -71,23 +70,14 @@ function stagePrompt(input) {
 }
 export async function setupWorkspace(config, options, runOptions = {}) {
     const { ticket, repository, model } = options;
-    const runner = options.runner ?? "local";
     const { signal } = runOptions;
     const definition = config.models.definitions[model];
     if (!definition) {
         throw new Error(`Unknown model: ${model}`);
     }
-    if (runner === "remote") {
-        await setupRemoteWorkspace({
-            config,
-            options: { ...options, runner },
-            ...(signal === undefined ? {} : { signal }),
-        });
-        return;
-    }
     assertLocalRunnerRequirements(await detectHostCapabilities(signal));
     await ensureClearance({ logger: log });
-    const spec = { repository, ticket, model, runner };
+    const spec = { repository, ticket };
     const created = signal === undefined
         ? await worktrees.create(config, spec)
         : await worktrees.create(config, spec, signal);
@@ -136,64 +126,6 @@ export async function setupWorkspace(config, options, runOptions = {}) {
         throw error;
     }
 }
-async function resolveTicketDetails(options) {
-    if (options.details !== undefined) {
-        return options.details;
-    }
-    log(`Fetching ${options.ticket} from Linear...`);
-    return await fetchTicket(options.ticket);
-}
-async function setupRemoteWorkspace(arguments_) {
-    const { config, options, signal } = arguments_;
-    const { ticket, repository, model } = options;
-    const definition = config.models.definitions[model];
-    /* v8 ignore next 3 @preserve -- setupWorkspace validates the model before routing here */
-    if (definition === undefined) {
-        throw new Error(`Unknown model: ${model}`);
-    }
-    log(`Workspace runner: remote (${config.remote.provider}:${config.remote.runnerName})`);
-    const spec = { repository, ticket, model, runner: "remote" };
-    const created = signal === undefined
-        ? await worktrees.create(config, spec)
-        : await worktrees.create(config, spec, signal);
-    const { branchName, dir: remoteWorktreeDir } = created;
-    const worktreeName = `${repository}-${ticket}`;
-    let promptDir;
-    try {
-        const ticketDetails = await resolveTicketDetails(options);
-        const stagedPrompt = stagePrompt({ config, ticket, ticketDetails, worktreeName });
-        promptDir = stagedPrompt.directory;
-        const secretsFile = stageBuildSecrets(promptDir, config.remote.secretNames);
-        const remotePromptFile = `/tmp/groundcrew-${ticket}-prompt.txt`;
-        const remoteSecretsFile = secretsFile === undefined ? undefined : `/tmp/groundcrew-${ticket}-secrets.env`;
-        const remoteLaunchCommand = buildRemoteLaunchCommand({
-            definition,
-            provider: getRemoteRunnerProvider(config.remote.provider),
-            remoteConfig: config.remote,
-            promptFile: stagedPrompt.file,
-            remotePromptFile,
-            worktreeDir: remoteWorktreeDir,
-            secretNames: config.remote.secretNames,
-            ...(secretsFile === undefined ? {} : { secretsFile, remoteSecretsFile }),
-        });
-        const launchCmd = stageWorkspaceLaunchCommand(promptDir, remoteLaunchCommand);
-        log("Opening workspace...");
-        await workspaces.open(config, {
-            name: ticket,
-            cwd: repoDirFor(config, repository),
-            command: launchCmd,
-            status: { text: `${model}:remote`, color: definition.color, icon: "sparkle" },
-        }, signal);
-        log(`Workspace "${ticket}" launched (${model}, remote)`);
-        log(`  Worktree: ${remoteWorktreeDir}`);
-        log(`  Branch:   ${branchName}`);
-        log(`  Remote:   ${config.remote.provider}:${config.remote.runnerName}`);
-    }
-    catch (error) {
-        await rollbackWorktree({ config, entry: created, promptDir });
-        throw error;
-    }
-}
 async function rollbackWorktree(arguments_) {
     log(`Setup failed; rolling back worktree ${arguments_.entry.repository}-${arguments_.entry.ticket}...`);
     let result;
@@ -234,16 +166,15 @@ export async function setupWorkspaceCli(ticket, options = {}) {
     const config = await loadConfig();
     const client = getLinearClient();
     const resolved = await fetchResolvedIssue({ client, config, ticket });
-    log(`Resolved ${ticket}: repository=${resolved.repository}, model=${resolved.model}, runner=${resolved.runner}`);
+    log(`Resolved ${ticket}: repository=${resolved.repository}, model=${resolved.model}`);
     if (options.dryRun === true) {
-        log(`[dry-run] Would launch ${ticket} in ${resolved.repository} (${resolved.model}, ${resolved.runner})`);
+        log(`[dry-run] Would launch ${ticket} in ${resolved.repository} (${resolved.model})`);
         return;
     }
     await setupWorkspace(config, {
         ticket: ticket.toLowerCase(),
         repository: resolved.repository,
         model: resolved.model,
-        runner: resolved.runner,
         details: { title: resolved.title, description: resolved.description },
     });
     await createLinearIssueStatusUpdater({ config, client }).markInProgress({