@nilsr0711/drydock 0.1.4 → 0.1.6

package/README.md

@@ -67,25 +67,35 @@ It's the difference between *driving* an agent and *operating a dock* of them.
 
 🔌 **Pluggable agents** — choose `claude` or `codex` per repo (with a global default in settings); a preflight check verifies the selected CLI is installed.
 
+🌐 **Opt-in OpenRouter backend** — run jobs against OpenRouter-hosted models, including **free-tier** ones, next to the Claude/Codex CLIs. The model catalog (ids, pricing, capabilities, deprecations) is **mirrored from OpenRouter's Models API into SQLite and refreshed automatically** on a configurable interval, so new models appear in the pickers without a Drydock release; sync failures keep the last-good snapshot working offline. One-shot stages (triage decomposition, verification, plan, PR audit) accept any synced model; implementation jobs are gated to tool-capable models and edit the worktree through a bounded tool loop. Costs use OpenRouter's exact usage accounting (catalog pricing as fallback) and flow into the same budgets and dashboards; 429s park jobs via the provider-limit latch and resume automatically. A global **free-models-only** policy restricts every OpenRouter run to zero-cost models. Off by default — paste an API key and flip the switch in Settings. See [ADR 032](docs/adr/032-openrouter-backend.md).
+
 🦊 **GitHub & GitLab** — choose the platform per repo. GitLab (gitlab.com or self-hosted) uses the REST API v4 with a per-repo base URL + access token — no extra CLI to install.
 
 🛂 **Opt-in autonomous triage** — per repo, let Drydock label incoming issues (deterministic keyword classifier, whitelist-only output) and auto-process the ones that are *ready* and not blocked. Off by default; gated by author association for public repos, a per-issue attempt limit, and all the usual cost/concurrency limits. Never auto-merges.
 
-🔧 **CI babysitting & auto-merge** — polls `gh pr checks`, merges on green, and on red resumes the session with a CI-fix prompt (up to **3 retries**), then files a follow-up issue and hands off. The failed log is classified by failure type (test, type error, lint, build, dependency, timeout, flaky) and reduced to a focused, line-capped evidence slice so the fix prompt targets the actual failure.
+🔧 **CI babysitting & auto-merge** — polls `gh pr checks`, merges on green (optionally after a per-repo **merge gate**: a settle window that holds the merge so late bot/human reviews can land and feed the review-feedback loop first; any regression re-arms the window), and on red resumes the session with a CI-fix prompt (up to **3 retries**), then files a follow-up issue and hands off. The failed log is classified by failure type (test, type error, lint, build, dependency, timeout, flaky) and reduced to a focused, line-capped evidence slice so the fix prompt targets the actual failure.
+
+🧹 **Branch & PR janitor** — a periodic background sweep keeps the remote tidy: the remote branch of a merged Drydock PR is **deleted within one sweep** (idempotent across restarts — each cleanup is stamped on the job's event log), an open PR that fell **behind** the default branch is updated automatically while conflict-free, and a **conflicted** PR parks its job as *needs a human* with an explicit “rebase needed: conflicts with `<default branch>`” reason instead of letting CI polling time out. Only branches under the `drydock/` prefix are ever deleted or updated.
 
-🩹 **Opt-in CI auto-heal** — per repo, turn the failure path into a structured classify → fix → verify loop: failing checks are bucketed (healable / external / flaky / unknown), only healable ones get a targeted fix, and each attempt is verified for a real, improving change. External and AI-review checks are never code-healed. Hard budgets (per-session and per-fingerprint attempts, a cooldown, and a concurrency cap) keep it bounded. Off by default; never auto-merges.
+🩹 **Opt-in CI auto-heal** — per repo, turn the failure path into a structured classify → fix → verify loop: failing checks are bucketed (healable / external / flaky / unknown), only healable ones get a targeted fix, and each attempt is verified for a real, improving change. Flaky checks get a plain re-run instead of a code edit (GitHub; on forges without re-run support they escalate to a human). External and AI-review checks are never code-healed. Hard budgets (per-session and per-fingerprint attempts, a cooldown, and a concurrency cap) keep it bounded. Off by default; never auto-merges.
 
-💬 **Opt-in PR review-feedback** — per repo, ingest review threads on a Drydock PR and run the mechanical iteration: only **trusted reviewers** are acted on (bots ignored), each comment walks a lifecycle (`pending → queued → in_progress → resolved`, with `failed` / `rejected` / `flagged` branches), and the agent applies the change on the PR branch, replies, and resolves the thread. Status replies are marker-based and idempotent (updated in place, not duplicated), with bounded per-sweep and per-item budgets. Off by default; never auto-merges. See [ADR 019](docs/adr/019-pr-review-feedback.md).
+💬 **Opt-in PR review-feedback** — per repo, ingest review threads on a Drydock PR and run the mechanical iteration: only **trusted reviewers** and explicitly **allowlisted bots** (e.g. `cursor[bot]`) are acted on — unlisted bots are ignored, each comment walks a lifecycle (`pending → queued → in_progress → resolved`, with `failed` / `rejected` / `flagged` branches), and the agent applies the change on the PR branch, replies, and resolves the thread. Status replies are marker-based and idempotent (updated in place, not duplicated), with bounded per-sweep and per-item budgets. Off by default; never auto-merges. See [ADR 019](docs/adr/019-pr-review-feedback.md).
 
 🧩 **Opt-in issue decomposition** — per repo, split a large issue ("fix these 5 bugs", "implement X with A/B/C") into ordered, tracked subtasks. A deterministic heuristic handles GitHub task lists (`- [ ]`) and "Bug N —" headings for free; prose falls back to a one-shot agent. Decomposition is idempotent (keyed on the issue body hash, redone only when the body changes), subtasks are surfaced in the agent prompt and worked in order, and progress is reflected on the issue and in the UI. Off by default. See [ADR 020](docs/adr/020-issue-decomposition.md).
 
+🪜 **Opt-in model escalation on retry** — per repo, retry failed jobs one rung up the model ladder: when a job parked in *needs a human* is requeued, the next attempt runs the **next-stronger model** of the repo's agent (e.g. Haiku → Sonnet → Opus), capped at the strongest. The escalated model is persisted on the job, so each attempt is **priced at the model that actually ran** and the job page shows which rung an attempt used (a `model_escalated` event on the timeline). Limit-parked jobs resuming their session and interrupted jobs are never escalated. Off by default.
+
+📋 **Opt-in plan-first** — per repo, run a **read-only planning pass** before implementation: a one-shot agent explores the codebase and produces a step-by-step plan, which is posted on the issue (an audit trail you can react to) and embedded in the implementation prompt as a dedicated section. The plan template is editable like the other prompts, plan cost is tracked like other one-shots, and any failure (non-zero exit, empty plan) falls back to the normal single-stage run. Off by default.
+
 🔎 **Opt-in post-PR verification** — per repo, run a **read-only** pass right after a PR opens that checks whether the diff actually satisfies the issue and each decomposed subtask. A one-shot agent is given the issue, its subtasks, and the (length-capped) diff and returns a strict JSON verdict (`done` / `pending` / `deferred`) per subtask; the result updates subtask status and posts a verification summary flagging what remains. It runs in a throwaway dir with a tight timeout, and on any failure (non-zero exit, non-JSON output, exception) leaves status unchanged — never corrupting state. Off by default; never auto-merges. See [ADR 027](docs/adr/027-post-pr-verification.md).
 
+🔍 **Opt-in AI PR audit** — per repo, run a **read-only, whole-PR review** (Bugbot/CodeRabbit style) right after a PR opens, or on demand from the job page / `run_pr_audit` MCP tool. A one-shot agent — its **agent and model selectable per repo** (defaults inherit the repo's agent/model) — reviews the length-capped diff, CI conclusions, and the linked issue with its subtasks across six dimensions (correctness, security, tests, API/compatibility, maintainability, issue fit) and returns strict JSON, rendered as a severity-ranked markdown comment on the **issue** (optionally mirrored on the PR). Re-runs update the same marker comment in place; oversized PRs get a partial audit with a truncation notice; the review language is configurable (`en` default). Failures post a short note and never touch job state; provider usage limits defer the audit via the ADR 030 latch; a global pause skips it. Cost-tracked like other one-shots. Off by default; **advisory only** — never merges, blocks, or edits. See [ADR 031](docs/adr/031-pr-audit.md).
+
 🚀 **Opt-in post-merge deployment healing** — per repo, watch a merged PR's deployment via pluggable platform adapters (Vercel and Railway today; adding Netlify/Fly/Render is one adapter, no core changes). The platform is auto-detected from repo config or set explicitly. The merged commit's deployment is polled with bounded delay/interval/timeout budgets, and on failure the logs are captured and a follow-up **fix PR** is opened for a human to review. Sessions are surfaced in the repo's Deployments panel. Off by default; never auto-merges. See [ADR 021](docs/adr/021-post-merge-deployment-healing.md).
 
 🏷️ **Opt-in release management** — per repo, extend autonomy past merge to shipping: evaluate the PRs merged since the last tag, decide whether a release is warranted and the semver bump, generate notes, and publish a release. The auto path is **idempotent** (one run per merge commit, never a duplicate release for a tag) and a failed run is retryable; a **dry-run preview** shows the proposed version and included PRs with no side effects; a **manual publish** forces a release through the same evaluation pipeline. Gated by both a global kill-switch and a per-repo opt-in, off by default; releases at the default-branch tip and never auto-merges. See [ADR 028](docs/adr/028-release-management.md).
 
-⚖️ **Rate-limit budgeting** — a priority-aware governor meters every GitHub call: the background sweep runs at *low* priority and yields once the budget drops below a reserve fraction, while interactive actions stay *high*; a hard floor stops anything from draining the budget to zero, a 429 backs off until reset, and unchanged issue lists are fetched with conditional ETag requests so they cost nothing. See [ADR 018](docs/adr/018-rate-limit-governor.md).
+⚖️ **Rate-limit budgeting** — a priority-aware governor meters every GitHub call: the background sweep runs at *low* priority and yields once the budget drops below a reserve fraction, while interactive actions stay *high*; a hard floor stops anything from draining the budget to zero, a 429 backs off until reset, and unchanged single-page issue lists are fetched with conditional ETag requests so they cost nothing (multi-page lists are always refetched — GitHub's ETag only validates the first page). See [ADR 018](docs/adr/018-rate-limit-governor.md).
 
 💬 **Ask about this PR** — on a job's detail view, ask a free-text question ("why did this change X?", "is the failing test related?", "what's left to do?") and a **read-only** agent answers from a length-capped context bundle Drydock already has: PR metadata, check pass/fail state, a review-feedback summary, the recent activity log, and the PR diff. Each question is persisted with a visible lifecycle (`answering → answered | error`), scoped to the PR it was asked about, and empty or failed responses are recorded as an error rather than crashing.
 
@@ -93,13 +103,15 @@ It's the difference between *driving* an agent and *operating a dock* of them.
 
 📡 **Live logs over SSE** — the agent's NDJSON output is parsed incrementally, persisted, and streamed to the browser in real time.
 
-💸 **Cost tracking** — per-job and aggregate spend from the agent's reported `total_cost_usd` (or estimated from tokens), with a **daily cost limit** that gates the driver loop and an optional **per-job cost ceiling** that aborts a single runaway session mid-stream (global default + per-repo override; off when unset). Spend is **exportable** to CSV or JSON from the cost dashboard — per-job line items or aggregates by repo/model, scoped to a date range and repo, with totals that reconcile with the dashboard.
+💸 **Cost tracking** — per-job and aggregate spend from the agent's reported `total_cost_usd` (or estimated from tokens), with a **daily cost limit** that gates the driver loop and an optional **per-job cost ceiling** that aborts a single runaway session mid-stream (global default + per-repo override; off when unset). Spend is **exportable** to CSV or JSON from the cost dashboard — line items (jobs plus one-shot agent calls) or aggregates by repo/model, scoped to a date range and repo, with totals that reconcile with the dashboard.
 
 ⏯️ **Global pause & per-repo controls** — pause or resume the whole dock with one click from the navbar, pick an agent and model per repo, toggle serial vs. parallel processing, and customize the queue label.
 
-🪝 **Webhook-driven issue sync** — opt in per repo to receive issue events instead of waiting for the next poll. Set a secret on a repo and Drydock exposes a signature-verified receiver (`/api/webhooks/<id>`); a validated GitHub/GitLab issue event triggers a targeted, debounced sync so new issues surface near-instantly. Polling stays on as the default fallback and shares the same idempotent reconcile, so a change is never double-processed. Since Drydock binds `127.0.0.1`, expose the URL through a tunnel (e.g. `cloudflared`, `ngrok`). See [ADR 029](docs/adr/029-webhook-issue-sync.md).
+🪝 **Webhook-driven sync & nudges** — opt in per repo to receive forge events instead of waiting for the next poll. Set a secret on a repo and Drydock exposes a signature-verified receiver (`/api/webhooks/<id>`): a validated issue event triggers a targeted, debounced sync so new issues surface near-instantly; a finished `check_suite`/`check_run` (GitLab: pipeline) wakes the CI babysitter so green PRs merge within seconds instead of at the next poll; a new PR review or review comment triggers the review-feedback sweep right away. Polling stays on as the default fallback and shares the same idempotent reconcile, so a change is never double-processed. Since Drydock binds `127.0.0.1`, expose the URL through a tunnel (e.g. `cloudflared`, `ngrok`). See [ADR 029](docs/adr/029-webhook-issue-sync.md).
+
+🔔 **External notifications** — get pinged on Telegram, Slack (incoming webhook) and email (SMTP) for the lifecycle events you care about (job needs human, job failed, PR opened, PR merged, release published, daily cost limit reached, credentials expired/restored, automation paused/draining). Each channel is configured independently, every event has a per-event opt-in, and a one-click test button verifies setup. Delivery is best-effort and never blocks the loop; secrets are redacted from logs. See [ADR 024](docs/adr/024-external-notifications.md).
 
-🔔 **External notifications** — get pinged on Telegram, Slack (incoming webhook) and email (SMTP) for the lifecycle events you care about (job needs human, job failed, PR opened, PR merged, release published, daily cost limit reached, automation paused/draining). Each channel is configured independently, every event has a per-event opt-in, and a one-click test button verifies setup. Delivery is best-effort and never blocks the loop; secrets are redacted from logs. See [ADR 024](docs/adr/024-external-notifications.md).
+🔑 **Credential watchdog** — periodic auth probes (on startup, then every 15 minutes) catch expired credentials *before* the queue dies overnight: `gh auth status` for GitHub repos, a cheap authenticated API call per configured GitLab base URL, the agent CLIs, and the OpenRouter API key. On failure a persistent navbar banner names the dead credential, a notification fires once per outage, and new job starts are gated while in-flight jobs finish; the next healthy probe resumes the queue automatically — no manual toggle. Only definitive auth failures (non-zero `gh auth status`, HTTP 401/403, missing CLI/key) trip the gate; network hiccups, 5xx and timeouts never pause the queue, and the GitHub probe yields to the rate-limit governor so it never burns budget jobs are waiting on.
 
 🆙 **Update-available notice** — a passive, dismissible navbar banner appears when a newer Drydock release is published. The check queries the latest stable GitHub release (drafts/prereleases skipped), is cached for an hour, and dedupes concurrent checks onto a single upstream call; any network or parse error advertises no update, so a transient hiccup never raises a false alarm. Global installs get a `drydock update` hint.
 
@@ -153,6 +165,8 @@ stateDiagram-v2
     queued --> working
     working --> ci_running
     working --> needs_human
+    working --> waiting_limit
+    waiting_limit --> queued
     ci_running --> merged
     ci_running --> ci_failed
     ci_failed --> retrying
@@ -166,6 +180,12 @@ stateDiagram-v2
 
 `aborted` (manual) and `interrupted` (crash recovery) can be reached from any in-flight state;
 `needs_human` and `interrupted` jobs can be re-queued. Terminal states are `merged` and `aborted`.
+`waiting_limit` parks a job whose agent session hit the provider's usage/rate limit — Claude
+(Anthropic usage windows, API 429/529) and Codex (ChatGPT-plan limits, OpenAI 429/5xx) alike
+([ADR&nbsp;030](docs/adr/030-provider-limit-auto-wait.md)): Drydock latches that provider, stops
+starting new sessions for it (the other agent keeps running), and re-queues the parked job
+automatically once the window resets — resuming the stored session (`claude --resume` /
+`codex exec resume`) where one exists. Auth/billing errors still escalate to `needs_human`.
 
 ## Install
 
@@ -188,12 +208,16 @@ and migrated automatically on first start — there are no setup steps. Then ope
 add a repository, and start queuing issues.
 
 ```bash
-drydock --help         # all flags
+drydock --help         # all flags and subcommands
 drydock --version      # installed version
 drydock --port 8080                   # change port (default: 3737)
 # Non-loopback binds require an explicit opt-in because the dashboard has no auth:
 DRYDOCK_ALLOW_REMOTE=1 drydock --host 0.0.0.0 --port 8080
 drydock update         # update a global install (reports current → latest, skips if already current)
+drydock backup         # WAL-safe DB snapshot, works while the server runs
+drydock restore <path> # replace the DB with a backup (server must be stopped)
+drydock doctor         # scriptable health checks, non-zero exit on failure
+drydock service install   # run the dock at login (launchd / systemd user unit)
 ```
 
 You still need the `claude` and (for GitHub) `gh` CLIs on `PATH` — see [Requirements](#requirements).
@@ -250,12 +274,13 @@ Drydock is configured at runtime from the **Settings** page and per-repo control
 | `DRYDOCK_DB` | `<data dir>/drydock.db`¹ | SQLite file path (use `:memory:` for ephemeral runs); overrides the data dir |
 | `DRYDOCK_MIGRATIONS` | `./drizzle` | Folder of generated SQL migrations (set automatically by the `drydock` launcher) |
 | `DRYDOCK_ALLOW_PRIVATE_FORGE` | _unset_ | Set to `1` to allow a GitLab base URL on a private/loopback network (self-hosted); otherwise such targets are refused as an SSRF safeguard |
+| `DRYDOCK_OPENROUTER_API_KEY` | _unset_ | Overrides the OpenRouter API key stored in settings (headless deployments keep the secret out of SQLite) |
 
 ¹ A source checkout (`pnpm dev`/`pnpm start`) defaults `DRYDOCK_DB` to `data/drydock.db` in the
 project; the `drydock` launcher defaults it to `~/.drydock/drydock.db`.
 
-**Settings (global):** pause switch · release management kill-switch (master on/off for the opt-in release pipeline) · daily cost limit · max job cost (per-job USD ceiling that aborts a runaway session mid-stream; 0 = off) · log retention (days) · max job minutes (per-agent session timeout) · max CI wait minutes (how long the babysitter waits for checks to settle before escalating to needs-human) · `claude`/`gh` CLI paths · notification channels (Telegram / Slack / email) and per-event opt-in.
-**Per repo:** platform (GitHub / GitLab, with base URL + token for GitLab) · default model · serial vs. parallel processing · queue label (default `drydock:queue`) · optional job/CI timeout overrides.
+**Settings (global):** pause switch · release management kill-switch (master on/off for the opt-in release pipeline) · daily cost limit · max job cost (per-job USD ceiling that aborts a runaway session mid-stream; 0 = off) · log retention (days) · max job minutes (per-agent session timeout) · max CI wait minutes (how long the babysitter waits for checks to settle before escalating to needs-human) · auto-wait on Claude and Codex provider limits (per-agent toggles: park jobs hit by usage/rate limits or overloads and resume them automatically when the window resets; default on) · `claude`/`gh` CLI paths · OpenRouter backend (enable switch, API key, catalog refresh interval, default model, free-models-only policy, attribution headers, limit auto-wait, plus test-connection and refresh-models actions) · notification channels (Telegram / Slack / email) and per-event opt-in.
+**Per repo:** platform (GitHub / GitLab, with base URL + token for GitLab) · agent (`claude`, `codex`, or `openrouter` once enabled) · default model (validated against the synced catalog for OpenRouter) · serial vs. parallel processing · queue label (default `drydock:queue`) · optional job/CI timeout overrides.
 
 ## Screens
 
@@ -322,16 +347,38 @@ pnpm mcp            # start the local stdio MCP server (see "MCP server")
 ## Operations
 
 - **Backups** — `pnpm backup` writes a consistent SQLite snapshot into `data/backups/` and
-  prunes anything older than 7 days. Schedule it daily via cron/launchd.
+  prunes anything older than 7 days. Schedule it daily via cron/launchd. Packaged installs
+  use `drydock backup [path]` instead (default target `<data dir>/backups/`, never prunes)
+  and `drydock restore <path>` to roll back — restore refuses while a drydock instance is
+  running and clears stale WAL/SHM sidecars. Both are WAL-aware via better-sqlite3's native
+  `.backup()`, so a backup taken under a live server is still consistent.
+- **Diagnostics** — `drydock doctor` prints one line per probe (gh auth, claude/codex CLIs,
+  GitLab token validity per configured base URL, free disk space at the data dir,
+  `PRAGMA integrity_check`, instance lock) and exits non-zero on any failed probe, so it
+  drops straight into cron/CI scripts.
+- **Health endpoint** — `GET /api/health` returns a machine-readable liveness snapshot for
+  Uptime-Kuma/Prometheus probes and scripts: `status` (`ok`/`degraded`) with `reasons`,
+  `version`, `uptimeSeconds`, `driver` (instance lock, paused/draining flags, last tick
+  timestamp), `queue` (job counts per state), and `budget` (today's spend vs the daily
+  limit). HTTP 200 while the driver loop ticks; 503 when the loop is stalled (no tick
+  within 3 poll intervals), not running, or the DB is unreachable. Read-only and
+  secret-free, served from a single cheap query set with no forge calls.
+- **Run at login** — `drydock service install` generates and loads a launchd agent (macOS)
+  or systemd user unit (Linux) that runs `drydock serve` at login and restarts it on
+  crashes; `drydock service uninstall` removes it again.
 - **Retention & pruning** — finished jobs' verbose log events are pruned past the
   **log retention** window (default 30 days; cost summary rows are kept). A daily in-process
   sweep runs automatically; for a manual run use `pnpm db:prune [--days <n>] [--no-vacuum]`,
   which deletes expired events and runs `VACUUM` to reclaim disk. See
   [ADR 023](docs/adr/023-log-retention-and-pruning.md).
-- **Secret redaction** — GitHub/GitLab tokens and `Bearer` values echoed in agent output are
-  scrubbed before any log event is persisted or streamed.
+- **Secret redaction** — GitHub/GitLab tokens, `Bearer`/`Basic` values, Anthropic/OpenAI API
+  keys and Telegram bot tokens echoed in agent output are scrubbed before any log event is
+  persisted or streamed.
 - **Pause / cost limit** — flip the global pause or hit the daily cost limit and the driver
   loop stops claiming new work; in-flight jobs finish cleanly.
+- **Credential watchdog** — expired `gh`/GitLab/agent credentials gate new job starts the
+  same way (banner + notification included) and the queue resumes on its own once the next
+  probe sees healthy auth.
 
 ## MCP server
 

package/bin/drydock.mjs

@@ -61,12 +61,45 @@ export function parseArgs(argv) {
     return { mode: "update" };
   }
 
+  if (argv[0] === "backup") {
+    if (argv.length > 2) throw new Error(`unexpected argument: ${argv[2]}`);
+    return { mode: "backup", path: argv[1] };
+  }
+
+  if (argv[0] === "restore") {
+    if (argv.length < 2) throw new Error("missing backup path: usage `drydock restore <path>`");
+    if (argv.length > 2) throw new Error(`unexpected argument: ${argv[2]}`);
+    return { mode: "restore", path: argv[1] };
+  }
+
+  if (argv[0] === "doctor") {
+    if (argv.length > 1) throw new Error(`unexpected argument: ${argv[1]}`);
+    return { mode: "doctor" };
+  }
+
+  if (argv[0] === "service") {
+    const action = argv[1];
+    if (action !== "install" && action !== "uninstall") {
+      throw new Error(
+        action
+          ? `unknown service action: ${action} (expected install or uninstall)`
+          : "missing service action: usage `drydock service install|uninstall`",
+      );
+    }
+    if (argv.length > 2) throw new Error(`unexpected argument: ${argv[2]}`);
+    return { mode: "service", action };
+  }
+
+  // `drydock serve` is an explicit alias for the default mode so scripts and
+  // service units can spell out what they launch.
+  const flags = argv[0] === "serve" ? argv.slice(1) : argv;
+
   let host = DEFAULT_HOST;
   let port = DEFAULT_PORT;
   let open = false;
 
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
+  for (let i = 0; i < flags.length; i++) {
+    const arg = flags[i];
 
     if (arg === "--open") {
       open = true;
@@ -76,7 +109,7 @@ export function parseArgs(argv) {
     const value = (flag) => {
       const eq = `${flag}=`;
       if (arg.startsWith(eq)) return arg.slice(eq.length);
-      const next = argv[i + 1];
+      const next = flags[i + 1];
       if (next === undefined) throw new Error(`missing value for ${flag}`);
       i++;
       return next;
@@ -132,7 +165,15 @@ const HELP = `drydock — autonomously turn GitHub issues into pull requests
 
 Usage:
   drydock [options]      Start the server and dashboard
+  drydock serve          Same as running with no subcommand
   drydock update         Update to the latest published version
+  drydock backup [path]  Snapshot the database (WAL-safe, works while running);
+                         default target: <data dir>/backups/drydock-<timestamp>.db
+  drydock restore <path> Replace the database with a backup (server must be stopped)
+  drydock doctor         Health checks: gh/claude/codex auth, GitLab tokens, disk
+                         space, DB integrity, instance lock; exits non-zero on failure
+  drydock service install|uninstall
+                         Run the dock at login via launchd (macOS) / systemd (Linux)
 
 Options:
   -p, --port <number>   Port to listen on (default: ${DEFAULT_PORT})
@@ -365,6 +406,50 @@ async function main(argv) {
     case "update":
       await runUpdate();
       return;
+    case "backup": {
+      const { runBackupCommand } = await import("./ops.mjs");
+      process.exit(
+        await runBackupCommand(directive.path, {
+          dbPath: resolveDbPath(),
+          dataDir: resolveDataDir(),
+        }),
+      );
+      return;
+    }
+    case "restore": {
+      const { resolveLockPath, runRestoreCommand } = await import("./ops.mjs");
+      process.exit(
+        await runRestoreCommand(directive.path, {
+          dbPath: resolveDbPath(),
+          lockPath: resolveLockPath(),
+        }),
+      );
+      return;
+    }
+    case "doctor": {
+      const { resolveLockPath, runDoctorCommand } = await import("./ops.mjs");
+      process.exit(
+        await runDoctorCommand({
+          dbPath: resolveDbPath(),
+          dataDir: resolveDataDir(),
+          lockPath: resolveLockPath(),
+        }),
+      );
+      return;
+    }
+    case "service": {
+      const { runServiceCommand } = await import("./ops.mjs");
+      process.exit(
+        await runServiceCommand(directive.action, {
+          platform: process.platform,
+          home: homedir(),
+          nodePath: process.execPath,
+          binPath: fileURLToPath(import.meta.url),
+          dataDir: resolveDataDir(),
+        }),
+      );
+      return;
+    }
     default:
       await serve(directive);
   }