diff --git a/docs/superpowers/plans/2026-04-14-plan4a-subcommands.md b/docs/superpowers/plans/2026-04-14-plan4a-subcommands.md
new file mode 100644
index 0000000..e858f63
--- /dev/null
+++ b/docs/superpowers/plans/2026-04-14-plan4a-subcommands.md
@@ -0,0 +1,1514 @@
+# Plan 4a — User-Facing Subcommands Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Ship `archduino theme`, `archduino new`, and `archduino doctor` subcommands plus a shared `internal/theming/` package that both the new `theme` subcommand and the existing `install` command use to write starship / zellij / yazi / lazygit / NvChad configs.
+
+**Architecture:** One new package (`theming`) owns per-theme embedded assets + the `Apply` function. Two subcommand packages (`newproject`, `doctor`) implement the remaining two subcommands. The `neovim` module exports a `WriteChadrc` helper that `theming.Apply` reuses to re-render chadrc when the theme changes. `tui.BuiltinThemes` retires; the wizard reads `theming.List()` instead. The `install` command calls `theming.Apply` after a successful `engine.Run` so the selected theme is applied on first run.
+
+**Tech Stack:** Go stdlib + `embed`, `gopkg.in/yaml.v3` (already a dep) for overlay round-trip, `huh` for the interactive theme picker, `text/template` for existing chadrc rendering.
+
+---
+
+## Reference: relevant existing surfaces
+
+```go
+// internal/module/module.go — unchanged
+type Module interface { Meta() Meta; Detect(ctx) (State, error); Plan(ctx, State) (Plan, error); Apply(ctx, Plan, Reporter) error; Verify(ctx) error }
+
+// internal/platform — unchanged
+func WriteUserFile(path string, data []byte, mode os.FileMode) error
+type Runner interface { Run(ctx, name string, args ...string) error; Output(ctx, name string, args ...string) ([]byte, error) }
+
+// internal/config/config.go — has ThemeOverrides map[string]string already
+type Config struct {
+    // ... existing fields ...
+    ThemeOverrides map[string]string
+}
+const currentVersion = 1
+
+// internal/modules/neovim/neovim.go — private helpers
+func (m Module) resolvedTheme() string      // returns NvChad theme name
+func (m Module) renderChadrc() ([]byte, error) // renders chadrc.lua.tmpl
+
+// internal/tui/state.go — to be retired
+type Theme struct { ID, Name, NvChadTheme string }
+var BuiltinThemes = []Theme{ ... 5 entries ... }
+func ThemeByID(themes []Theme, id string) (Theme, bool)
+type WizardState struct { ThemeID string; ... }
+
+// cmd/archduino/main.go
+root := &cobra.Command{Use: "archduino"}
+root.AddCommand(newInstallCmd())
+func newInstallCmd() *cobra.Command
+func buildRegistry(cfg config.Config, themeID string) (*module.Registry, error)
+```
+
+---
+
+## Task 1: `theming` package skeleton — Theme type, manifest discovery, gruvbox assets
+
+**Files:**
+- Create: `internal/theming/theming.go`
+- Create: `internal/theming/theming_test.go`
+- Create: `internal/theming/assets/gruvbox/theme.yaml`
+- Create: `internal/theming/assets/gruvbox/starship.toml`
+- Create: `internal/theming/assets/gruvbox/zellij.kdl`
+- Create: `internal/theming/assets/gruvbox/yazi.toml`
+- Create: `internal/theming/assets/gruvbox/lazygit.yml`
+
+- [ ] **Step 1: Create gruvbox assets**
+
+Extract contents from `/home/marvin/git-clones/ArduinoArchSetup/lib/themes/gruvbox.sh`'s `write_starship_config`, `write_zellij_config`, `write_lazygit_config`, `write_yazi_config` heredocs. Write each heredoc body verbatim to the corresponding asset file (drop the `TOML` / `KDL` / `YAML` end-tokens and the surrounding bash). `theme.yaml`:
+
+```yaml
+display_name: "Gruvbox Dark"
+nvchad: "gruvbox"
+```
+
+- [ ] **Step 2: Write failing test**
+
+```go
+package theming
+
+import (
+    "testing"
+)
+
+func TestListDiscoversThemes(t *testing.T) {
+    themes := List()
+    if len(themes) == 0 { t.Fatal("no themes discovered") }
+    for _, th := range themes {
+        if th.ID == "" || th.DisplayName == "" || th.NvChadTheme == "" {
+            t.Errorf("incomplete theme: %+v", th)
+        }
+    }
+}
+
+func TestGetKnownThemeReturnsMatch(t *testing.T) {
+    got, ok := Get("gruvbox")
+    if !ok { t.Fatal("gruvbox should exist") }
+    if got.ID != "gruvbox" || got.DisplayName == "" || got.NvChadTheme != "gruvbox" {
+        t.Fatalf("got %+v", got)
+    }
+}
+
+func TestGetUnknownThemeReturnsFalse(t *testing.T) {
+    if _, ok := Get("does-not-exist"); ok {
+        t.Fatal("bogus id should return ok=false")
+    }
+}
+
+func TestListIsSortedByID(t *testing.T) {
+    themes := List()
+    for i := 1; i < len(themes); i++ {
+        if themes[i].ID < themes[i-1].ID {
+            t.Fatalf("not sorted: %s before %s", themes[i-1].ID, themes[i].ID)
+        }
+    }
+}
+```
+
+- [ ] **Step 3: Run test, confirm fail**
+
+```
+go test ./internal/theming/... -v
+```
+Expected: `undefined: List` / `undefined: Get`.
+
+- [ ] **Step 4: Implement `theming.go` skeleton**
+
+```go
+// Package theming applies a selected colorscheme across starship, zellij,
+// yazi, lazygit, and NvChad. Themes are discovered from embedded manifest
+// files under assets/<id>/theme.yaml at package init time.
+package theming
+
+import (
+    "embed"
+    "fmt"
+    "io/fs"
+    "path/filepath"
+    "sort"
+    "strings"
+
+    "gopkg.in/yaml.v3"
+)
+
+//go:embed assets
+var assetsFS embed.FS
+
+// Theme describes a colorscheme discovered under assets/<id>/theme.yaml.
+type Theme struct {
+    ID          string
+    DisplayName string
+    NvChadTheme string
+}
+
+type manifest struct {
+    DisplayName string `yaml:"display_name"`
+    NvChad      string `yaml:"nvchad"`
+}
+
+var discovered []Theme
+
+func init() {
+    themes, err := discover()
+    if err != nil {
+        // Package is embed-only; discovery failure is a programmer error,
+        // not runtime input. Panic so tests surface the mistake early.
+        panic(fmt.Errorf("theming: discover themes: %w", err))
+    }
+    discovered = themes
+}
+
+func discover() ([]Theme, error) {
+    entries, err := fs.ReadDir(assetsFS, "assets")
+    if err != nil { return nil, err }
+    var out []Theme
+    for _, e := range entries {
+        if !e.IsDir() { continue }
+        id := e.Name()
+        m, err := readManifest(id)
+        if err != nil { return nil, fmt.Errorf("theme %q: %w", id, err) }
+        out = append(out, Theme{ID: id, DisplayName: m.DisplayName, NvChadTheme: m.NvChad})
+    }
+    sort.Slice(out, func(i, j int) bool { return out[i].ID < out[j].ID })
+    return out, nil
+}
+
+func readManifest(id string) (manifest, error) {
+    data, err := assetsFS.ReadFile(filepath.Join("assets", id, "theme.yaml"))
+    if err != nil { return manifest{}, err }
+    var m manifest
+    if err := yaml.Unmarshal(data, &m); err != nil { return manifest{}, err }
+    if m.DisplayName == "" { return manifest{}, fmt.Errorf("empty display_name") }
+    if m.NvChad == "" { return manifest{}, fmt.Errorf("empty nvchad") }
+    return m, nil
+}
+
+// List returns the themes sorted by ID.
+func List() []Theme {
+    out := make([]Theme, len(discovered))
+    copy(out, discovered)
+    return out
+}
+
+// Get returns the theme with the given ID, if present.
+func Get(id string) (Theme, bool) {
+    for _, t := range discovered {
+        if t.ID == id { return t, true }
+    }
+    return Theme{}, false
+}
+
+// stringsPrefix is a trivial helper reserved for Task 2's tool-config step.
+// It exists to keep the strings import live if Task 1's code doesn't use it.
+var _ = strings.Split
+```
+
+Delete the `_ = strings.Split` line if the build complains; Task 2 will reintroduce `strings` usage.
+
+- [ ] **Step 5: Run tests, confirm pass**
+
+```
+go test ./internal/theming/... -v
+go test ./...
+```
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add internal/theming/
+git commit -m "feat(theming): add theme discovery with gruvbox assets"
+```
+
+---
+
+## Task 2: `theming.Apply` — write the four tool configs
+
+**Files:**
+- Modify: `internal/theming/theming.go` — add `Apply(cfg config.Config, themeID string) error`.
+- Modify: `internal/theming/theming_test.go` — add tests.
+
+- [ ] **Step 1: Write failing test**
+
+Append to `theming_test.go`:
+
+```go
+import (
+    "os"
+    "path/filepath"
+
+    "github.com/MDietermann/ArduinoArchSetup/internal/config"
+)
+
+func TestApplyWritesFourToolConfigs(t *testing.T) {
+    home := t.TempDir()
+    t.Setenv("HOME", home)
+    if err := Apply(config.Config{}, "gruvbox"); err != nil { t.Fatal(err) }
+
+    checks := []struct{ rel, wantPrefix string }{
+        {".config/starship.toml", "palette"},
+        {".config/zellij/config.kdl", "theme"},
+        {".config/yazi/theme.toml", ""},
+        {".config/lazygit/config.yml", "gui"},
+    }
+    for _, c := range checks {
+        data, err := os.ReadFile(filepath.Join(home, c.rel))
+        if err != nil { t.Errorf("%s missing: %v", c.rel, err); continue }
+        if len(data) == 0 { t.Errorf("%s empty", c.rel) }
+        if c.wantPrefix != "" && !strings.HasPrefix(strings.TrimSpace(string(data)), c.wantPrefix) {
+            t.Errorf("%s: want prefix %q, got %q", c.rel, c.wantPrefix, string(data[:min(len(data),40)]))
+        }
+    }
+}
+
+func TestApplyUnknownThemeErrors(t *testing.T) {
+    if err := Apply(config.Config{}, "does-not-exist"); err == nil {
+        t.Fatal("want error on unknown theme")
+    }
+}
+```
+
+(The `min` helper is stdlib in Go 1.21+; if the repo's go.mod is older, replace `min(len(data),40)` with a manual min.)
+
+- [ ] **Step 2: Run test, confirm fail**
+
+```
+go test ./internal/theming/... -v
+```
+Expected: `undefined: Apply`.
+
+- [ ] **Step 3: Implement `Apply` (initial version — writes tool configs only, no overlay, no chadrc)**
+
+Add to `theming.go`:
+
+```go
+import (
+    "os"
+    "path/filepath"
+    "strings"
+
+    "github.com/MDietermann/ArduinoArchSetup/internal/config"
+    "github.com/MDietermann/ArduinoArchSetup/internal/platform"
+)
+
+// toolConfig describes one tool's config file: its asset name under
+// assets/<theme>/ and its user-config destination relative to $HOME.
+type toolConfig struct {
+    Asset   string // e.g. "starship.toml"
+    DestRel string // e.g. ".config/starship.toml"
+}
+
+var toolConfigs = []toolConfig{
+    {"starship.toml", ".config/starship.toml"},
+    {"zellij.kdl", ".config/zellij/config.kdl"},
+    {"yazi.toml", ".config/yazi/theme.toml"},
+    {"lazygit.yml", ".config/lazygit/config.yml"},
+}
+
+// Apply writes each tool's theme config to the user's home directory.
+// Task 3 adds overlay-file update; Task 4 adds NvChad chadrc rewrite.
+func Apply(cfg config.Config, themeID string) error {
+    th, ok := Get(themeID)
+    if !ok {
+        ids := make([]string, 0, len(discovered))
+        for _, t := range discovered { ids = append(ids, t.ID) }
+        return fmt.Errorf("unknown theme %q; valid: %s", themeID, strings.Join(ids, ", "))
+    }
+    home, err := os.UserHomeDir(); if err != nil { return err }
+
+    for _, tc := range toolConfigs {
+        data, err := assetsFS.ReadFile(filepath.Join("assets", th.ID, tc.Asset))
+        if err != nil { return fmt.Errorf("read asset %s: %w", tc.Asset, err) }
+        dst := filepath.Join(home, tc.DestRel)
+        if err := platform.WriteUserFile(dst, data, 0o644); err != nil {
+            return fmt.Errorf("write %s: %w", tc.DestRel, err)
+        }
+    }
+    _ = cfg // overlay update lands in Task 3
+    return nil
+}
+```
+
+Remove the `_ = strings.Split` line from Task 1 now that `strings` is used genuinely.
+
+- [ ] **Step 4: Run tests, confirm pass**
+
+```
+go test ./internal/theming/... -v
+go test ./...
+```
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add internal/theming/
+git commit -m "feat(theming): apply writes four tool configs to $HOME"
+```
+
+---
+
+## Task 3: `theming.Apply` — overlay round-trip
+
+**Files:**
+- Modify: `internal/theming/theming.go` — extend `Apply`.
+- Modify: `internal/theming/theming_test.go` — add overlay tests.
+
+- [ ] **Step 1: Write failing test**
+
+Append:
+
+```go
+func TestApplyUpdatesOverlayActive(t *testing.T) {
+    home := t.TempDir()
+    t.Setenv("HOME", home)
+    if err := Apply(config.Config{}, "gruvbox"); err != nil { t.Fatal(err) }
+    data, err := os.ReadFile(filepath.Join(home, ".config", "archduino", "overlay.yaml"))
+    if err != nil { t.Fatalf("overlay missing: %v", err) }
+    if !strings.Contains(string(data), "__active: gruvbox") {
+        t.Fatalf("overlay missing active theme: %s", data)
+    }
+}
+
+func TestApplyPreservesOtherOverlayKeys(t *testing.T) {
+    home := t.TempDir()
+    t.Setenv("HOME", home)
+    // Seed overlay with a non-theme key.
+    op := filepath.Join(home, ".config", "archduino", "overlay.yaml")
+    os.MkdirAll(filepath.Dir(op), 0o755)
+    os.WriteFile(op, []byte("version: 1\nextra_packages:\n  - foo\n"), 0o644)
+
+    if err := Apply(config.Config{}, "gruvbox"); err != nil { t.Fatal(err) }
+    data, _ := os.ReadFile(op)
+    if !strings.Contains(string(data), "- foo") {
+        t.Fatalf("extra_packages lost: %s", data)
+    }
+    if !strings.Contains(string(data), "__active: gruvbox") {
+        t.Fatalf("active theme missing after preserve: %s", data)
+    }
+}
+```
+
+- [ ] **Step 2: Run tests, confirm fail**
+
+```
+go test ./internal/theming/... -run TestApplyUpdates -v
+go test ./internal/theming/... -run TestApplyPreserves -v
+```
+
+- [ ] **Step 3: Implement the overlay update**
+
+Add a helper and call it at the end of `Apply`:
+
+```go
+func updateOverlayActive(themeID string) error {
+    home, err := os.UserHomeDir(); if err != nil { return err }
+    path := filepath.Join(home, ".config", "archduino", "overlay.yaml")
+
+    // Load existing overlay into a generic map so we preserve sibling keys.
+    var root map[string]any
+    if data, err := os.ReadFile(path); err == nil {
+        if err := yaml.Unmarshal(data, &root); err != nil {
+            return fmt.Errorf("parse overlay: %w", err)
+        }
+    }
+    if root == nil { root = map[string]any{} }
+
+    // Ensure the version stamp is present so Load doesn't complain.
+    if _, ok := root["version"]; !ok { root["version"] = 1 }
+
+    // theme_overrides may be absent, nil, or a map under various yaml decode
+    // shapes. Normalise to map[string]any.
+    var overrides map[string]any
+    if raw, ok := root["theme_overrides"]; ok {
+        if m, ok := raw.(map[string]any); ok {
+            overrides = m
+        }
+    }
+    if overrides == nil { overrides = map[string]any{} }
+    overrides["__active"] = themeID
+    root["theme_overrides"] = overrides
+
+    out, err := yaml.Marshal(root); if err != nil { return err }
+    return platform.WriteUserFile(path, out, 0o644)
+}
+```
+
+In `Apply`, after the tool-config loop, add:
+
+```go
+    if err := updateOverlayActive(themeID); err != nil {
+        return fmt.Errorf("update overlay: %w", err)
+    }
+```
+
+- [ ] **Step 4: Run tests, confirm pass**
+
+```
+go test ./internal/theming/... -v
+go test ./...
+```
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add internal/theming/
+git commit -m "feat(theming): apply updates overlay theme_overrides.__active"
+```
+
+---
+
+## Task 4: Extract neovim chadrc writer, wire into theming.Apply
+
+**Files:**
+- Modify: `internal/modules/neovim/neovim.go` — export `WriteChadrc`.
+- Modify: `internal/modules/neovim/neovim_test.go` — add targeted test.
+- Modify: `internal/theming/theming.go` — call `neovim.WriteChadrc` from `Apply`.
+- Modify: `internal/theming/theming_test.go` — add chadrc tests.
+
+- [ ] **Step 1: Add the exported helper in the neovim package**
+
+In `internal/modules/neovim/neovim.go`, add at file scope (near the other render helpers around line 91):
+
+```go
+// WriteChadrc renders chadrc.lua for the given NvChad theme name and writes
+// it to ~/.config/nvim/lua/chadrc.lua. If the file does not already exist
+// and the surrounding nvim config dir does not exist, the function returns
+// nil without writing anything (the user hasn't installed neovim yet).
+//
+// Exported so the theming package can re-render chadrc on theme switches
+// without re-running the full Module pipeline.
+func WriteChadrc(nvChadThemeName string) error {
+    home, err := os.UserHomeDir(); if err != nil { return err }
+    cfg := filepath.Join(home, ".config", "nvim")
+    chadrcPath := filepath.Join(cfg, "lua", "chadrc.lua")
+
+    // If chadrc doesn't exist, only write when the parent dir exists. A
+    // fresh system where nvim was never installed should be a no-op.
+    if _, err := os.Stat(chadrcPath); err != nil {
+        if _, err := os.Stat(cfg); err != nil {
+            return nil
+        }
+    }
+
+    tmplBytes, err := assets.ReadFile("assets/chadrc.lua.tmpl"); if err != nil { return err }
+    tmpl, err := template.New("chadrc").Parse(string(tmplBytes)); if err != nil { return err }
+    var buf bytes.Buffer
+    if err := tmpl.Execute(&buf, struct{ NvChadTheme string }{NvChadTheme: nvChadThemeName}); err != nil {
+        return err
+    }
+    return platform.WriteUserFile(chadrcPath, buf.Bytes(), 0o644)
+}
+```
+
+(This duplicates a few lines from `Module.renderChadrc`; the duplication is acceptable since the renderer is small and the Module-scoped version carries the `Module`'s theme-ID fallback logic that doesn't belong in the standalone helper.)
+
+- [ ] **Step 2: Add a test for the new helper**
+
+In `internal/modules/neovim/neovim_test.go`, add:
+
+```go
+func TestWriteChadrcWritesFile(t *testing.T) {
+    home := t.TempDir(); t.Setenv("HOME", home)
+    cfg := filepath.Join(home, ".config", "nvim")
+    os.MkdirAll(cfg, 0o755)
+    if err := WriteChadrc("dracula"); err != nil { t.Fatal(err) }
+    data, err := os.ReadFile(filepath.Join(cfg, "lua", "chadrc.lua"))
+    if err != nil { t.Fatal(err) }
+    if !strings.Contains(string(data), `theme = "dracula"`) {
+        t.Fatalf("theme not applied: %s", data)
+    }
+}
+
+func TestWriteChadrcNoopWithoutConfigDir(t *testing.T) {
+    home := t.TempDir(); t.Setenv("HOME", home)
+    if err := WriteChadrc("gruvbox"); err != nil { t.Fatal(err) }
+    if _, err := os.Stat(filepath.Join(home, ".config", "nvim", "lua", "chadrc.lua")); !os.IsNotExist(err) {
+        t.Fatal("chadrc should not be created on a bare system")
+    }
+}
+```
+
+- [ ] **Step 3: Add theming integration**
+
+In `internal/theming/theming.go`, import the neovim package:
+
+```go
+import (
+    // ... existing imports ...
+    "github.com/MDietermann/ArduinoArchSetup/internal/modules/neovim"
+)
+```
+
+After the overlay update in `Apply`:
+
+```go
+    if err := neovim.WriteChadrc(th.NvChadTheme); err != nil {
+        return fmt.Errorf("update chadrc: %w", err)
+    }
+
+    // Clear NvChad's base46 theme cache so the new theme activates on next
+    // nvim launch. Errors ignored — the cache may not exist.
+    _ = os.RemoveAll(filepath.Join(home, ".cache", "nvim", "base46"))
+    _ = os.RemoveAll(filepath.Join(home, ".local", "share", "nvim", "lazy", "base46", "lua", "base46", "themes"))
+```
+
+Note: `home` must still be in scope at this point; if the existing code doesn't keep it, hoist `home, _ := os.UserHomeDir()` near the top of `Apply`.
+
+- [ ] **Step 4: Add theming tests**
+
+Append to `theming_test.go`:
+
+```go
+func TestApplyRewritesChadrcIfPresent(t *testing.T) {
+    home := t.TempDir(); t.Setenv("HOME", home)
+    nvimCfg := filepath.Join(home, ".config", "nvim", "lua")
+    os.MkdirAll(nvimCfg, 0o755)
+    os.WriteFile(filepath.Join(nvimCfg, "chadrc.lua"),
+        []byte(`M.base46 = { theme = "gruvbox" }`), 0o644)
+    if err := Apply(config.Config{}, "dracula"); err != nil { t.Fatal(err) }
+    data, _ := os.ReadFile(filepath.Join(nvimCfg, "chadrc.lua"))
+    if !strings.Contains(string(data), `theme = "dracula"`) {
+        t.Fatalf("chadrc not rewritten: %s", data)
+    }
+}
+
+func TestApplyNoChadrcIsFine(t *testing.T) {
+    home := t.TempDir(); t.Setenv("HOME", home)
+    if err := Apply(config.Config{}, "gruvbox"); err != nil { t.Fatal(err) }
+}
+```
+
+- [ ] **Step 5: Run tests, confirm pass**
+
+```
+go test ./internal/theming/... -v
+go test ./internal/modules/neovim/... -v
+go test ./...
+```
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add internal/modules/neovim/ internal/theming/
+git commit -m "feat(theming): integrate NvChad chadrc rewrite into Apply"
+```
+
+---
+
+## Task 5: Add the remaining four themes (catppuccin, tokyonight, nord, dracula)
+
+**Files:**
+- Create: `internal/theming/assets/<theme>/{theme.yaml,starship.toml,zellij.kdl,yazi.toml,lazygit.yml}` for four themes.
+
+- [ ] **Step 1: Write failing test**
+
+Append to `theming_test.go`:
+
+```go
+func TestAllFiveThemesPresent(t *testing.T) {
+    want := []string{"catppuccin", "dracula", "gruvbox", "nord", "tokyonight"}
+    themes := List()
+    if len(themes) != len(want) {
+        t.Fatalf("want %d themes, got %d", len(want), len(themes))
+    }
+    for i, id := range want {
+        if themes[i].ID != id { t.Fatalf("themes[%d].ID = %q, want %q", i, themes[i].ID, id) }
+    }
+}
+
+func TestApplyEachThemeWritesStarship(t *testing.T) {
+    for _, id := range []string{"catppuccin", "dracula", "nord", "tokyonight"} {
+        id := id
+        t.Run(id, func(t *testing.T) {
+            home := t.TempDir(); t.Setenv("HOME", home)
+            if err := Apply(config.Config{}, id); err != nil { t.Fatal(err) }
+            data, err := os.ReadFile(filepath.Join(home, ".config", "starship.toml"))
+            if err != nil { t.Fatal(err) }
+            if len(data) == 0 { t.Fatal("empty starship.toml") }
+        })
+    }
+}
+```
+
+- [ ] **Step 2: Confirm fail**
+
+```
+go test ./internal/theming/... -run TestAllFiveThemesPresent -v
+```
+Expected: `want 5 themes, got 1`.
+
+- [ ] **Step 3: Copy the four themes' assets**
+
+For each of `catppuccin`, `tokyonight`, `nord`, `dracula`:
+- Read `/home/marvin/git-clones/ArduinoArchSetup/lib/themes/<theme>.sh`.
+- Create directory `internal/theming/assets/<theme>/`.
+- Extract heredoc bodies: `write_starship_config` → `starship.toml`, `write_zellij_config` → `zellij.kdl`, `write_yazi_config` → `yazi.toml`, `write_lazygit_config` → `lazygit.yml`. Drop the heredoc tokens; keep content verbatim.
+- Extract the top-of-file variables for the manifest:
+  ```yaml
+  display_name: "<THEME_DISPLAY_NAME from bash>"
+  nvchad: "<NVCHAD_THEME from bash>"
+  ```
+  The bash variables are `THEME_DISPLAY_NAME="..."` and `NVCHAD_THEME="..."` near lines 2-3 of each file.
+
+- [ ] **Step 4: Run tests, confirm pass**
+
+```
+go test ./internal/theming/... -v
+go test ./...
+```
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add internal/theming/assets/
+git commit -m "feat(theming): add catppuccin, dracula, nord, tokyonight themes"
+```
+
+---
+
+## Task 6: Retire `tui.BuiltinThemes`; wizard reads `theming.List()`
+
+**Files:**
+- Modify: `internal/tui/state.go` — remove `BuiltinThemes`, `NvChadTheme`, `ThemeByID`; simplify `Theme`.
+- Modify: `internal/tui/state_test.go` — adjust or remove affected tests.
+- Modify: `internal/tui/wizard/wizard.go` — read from `theming.List()`.
+- Modify: `internal/modules/neovim/neovim.go` — drop the `tui.Theme`-based fallback in `resolvedTheme`; switch to `theming.Get`.
+- Modify: `cmd/archduino/main.go` — adjust any `tui.BuiltinThemes` references (Plan 3b added one for the pre-wizard `buildRegistry` call — replace with `""` or the first theme from `theming.List()`).
+
+- [ ] **Step 1: Grep current usages**
+
+```
+grep -rn "BuiltinThemes\|ThemeByID\|tui.Theme\b" --include="*.go"
+```
+Expected hits: `internal/tui/state.go`, `internal/tui/state_test.go`, `internal/tui/wizard/wizard.go`, `internal/modules/neovim/neovim.go`, `internal/modules/neovim/neovim_test.go`, `cmd/archduino/main.go`. Note every file before editing.
+
+- [ ] **Step 2: Simplify `tui.Theme`**
+
+In `internal/tui/state.go`:
+
+```go
+// Theme is the wizard's display-only view of a colorscheme option.
+// Canonical theme metadata lives in internal/theming.
+type Theme struct {
+    ID   string
+    Name string
+}
+```
+
+Remove `BuiltinThemes`, `ThemeByID`. In `NewWizardState`:
+
+```go
+import "github.com/MDietermann/ArduinoArchSetup/internal/theming"
+
+func NewWizardState(cfg config.Config, reg *module.Registry) WizardState {
+    // ... existing module-choice logic unchanged ...
+
+    themes := theming.List()
+    theme := ""
+    if len(themes) > 0 { theme = themes[0].ID }
+    if override, ok := cfg.ThemeOverrides["__active"]; ok && override != "" {
+        theme = override
+    }
+
+    return WizardState{
+        ThemeID:     theme,
+        Modules:     choices,
+        Parallelism: 1,
+    }
+}
+```
+
+- [ ] **Step 3: Rewrite affected tests**
+
+In `internal/tui/state_test.go`, replace any test referencing `BuiltinThemes` or `NvChadTheme` with equivalents against `theming.List()`. Specifically, the `TestBuiltinThemesCarryNvChadName` and `TestThemeByID*` tests (added in Plan 3b Task 2) should be **deleted** — the symbols they test no longer exist in `tui`. Their logic is already covered by `internal/theming`'s own tests (Task 1, Task 5).
+
+A `NewWizardState` test that expected `s.ThemeID == BuiltinThemes[0].ID` should be updated to `s.ThemeID == theming.List()[0].ID`.
+
+- [ ] **Step 4: Update wizard**
+
+In `internal/tui/wizard/wizard.go`:
+
+```go
+import "github.com/MDietermann/ArduinoArchSetup/internal/theming"
+
+// ... in Run, replace the themeOptions construction (lines ~26-29):
+themes := theming.List()
+themeOptions := make([]huh.Option[string], 0, len(themes))
+for _, t := range themes {
+    themeOptions = append(themeOptions, huh.NewOption(t.DisplayName, t.ID))
+}
+```
+
+Drop `import "github.com/MDietermann/ArduinoArchSetup/internal/tui"` if it's no longer used (the wizard still references `tui.WizardState` and `tui.ModuleChoice`, so keep it).
+
+- [ ] **Step 5: Update neovim module**
+
+In `internal/modules/neovim/neovim.go`, `resolvedTheme` currently takes `[]tui.Theme`. Simplify:
+
+```go
+import "github.com/MDietermann/ArduinoArchSetup/internal/theming"
+
+func (m Module) resolvedTheme() string {
+    if t, ok := theming.Get(m.themeID); ok { return t.NvChadTheme }
+    if themes := theming.List(); len(themes) > 0 { return themes[0].NvChadTheme }
+    return "gruvbox"
+}
+```
+
+Change `New` signature to drop the `themes []tui.Theme` parameter:
+
+```go
+func New(cfg config.NeovimConfig, themeID string, pm platform.PackageManager, git platform.GitClient) Module {
+    return Module{cfg: cfg, themeID: themeID, pm: pm, git: git}
+}
+```
+
+Remove the `themes []tui.Theme` field from `Module` struct.
+
+Update `internal/modules/neovim/neovim_test.go`: replace every `New(cfg, id, tui.BuiltinThemes, pm, git)` call with `New(cfg, id, pm, git)`. Drop the `tui` import if unused.
+
+- [ ] **Step 6: Update cmd/archduino/main.go**
+
+In `buildRegistry`, update the neovim registration:
+
+```go
+neovim.New(cfg.Neovim, themeID, pm, git),
+```
+
+Replace any `tui.BuiltinThemes[0].ID` reference with `""` (neovim's `resolvedTheme` already falls back to `theming.List()[0].NvChadTheme`).
+
+- [ ] **Step 7: Run the full test suite**
+
+```
+go build ./...
+go test ./...
+```
+
+If tests fail due to leftover `BuiltinThemes` references the grep missed, fix them and rerun.
+
+- [ ] **Step 8: Commit**
+
+```bash
+git add internal/tui/ internal/modules/neovim/ cmd/archduino/main.go
+git commit -m "refactor: retire tui.BuiltinThemes in favor of theming.List"
+```
+
+---
+
+## Task 7: Extend config with `Scaffolding.Boards`
+
+**Files:**
+- Modify: `internal/config/config.go`
+- Modify: `internal/config/defaults.yaml`
+- Modify: `internal/config/config_test.go`
+
+- [ ] **Step 1: Write failing test**
+
+Append to `config_test.go`:
+
+```go
+func TestDefaultsCarryScaffoldingBoards(t *testing.T) {
+    cfg, err := Load("/nonexistent/overlay.yaml")
+    if err != nil { t.Fatal(err) }
+    if len(cfg.Scaffolding.Boards) < 6 {
+        t.Fatalf("want >= 6 boards, got %d", len(cfg.Scaffolding.Boards))
+    }
+    want := map[string]string{
+        "uno": "arduino:avr:uno", "mega": "arduino:avr:mega", "nano": "arduino:avr:nano",
+        "esp32": "esp32:esp32:esp32", "esp32s3": "esp32:esp32:esp32s3", "esp8266": "esp8266:esp8266:nodemcuv2",
+    }
+    got := map[string]string{}
+    for _, b := range cfg.Scaffolding.Boards { got[b.Name] = b.FQBN }
+    for name, fqbn := range want {
+        if got[name] != fqbn { t.Errorf("board %q: got fqbn %q, want %q", name, got[name], fqbn) }
+    }
+}
+```
+
+- [ ] **Step 2: Run test, confirm fail**
+
+```
+go test ./internal/config/... -run TestDefaultsCarryScaffoldingBoards -v
+```
+
+- [ ] **Step 3: Extend `config.go`**
+
+Add types above `Config`:
+
+```go
+type Board struct {
+    Name     string `yaml:"name"`
+    FQBN     string `yaml:"fqbn"`
+    Template string `yaml:"template"`
+}
+
+type Scaffolding struct {
+    Boards []Board `yaml:"boards"`
+}
+```
+
+Add field to `Config`:
+
+```go
+    Scaffolding     Scaffolding        `yaml:"scaffolding"`
+```
+
+Extend `merge` with:
+
+```go
+    if len(over.Scaffolding.Boards) > 0 { out.Scaffolding = over.Scaffolding }
+```
+
+- [ ] **Step 4: Extend `defaults.yaml`**
+
+Append:
+
+```yaml
+
+scaffolding:
+  boards:
+    - {name: uno, fqbn: "arduino:avr:uno", template: uno}
+    - {name: mega, fqbn: "arduino:avr:mega", template: mega}
+    - {name: nano, fqbn: "arduino:avr:nano", template: nano}
+    - {name: esp32, fqbn: "esp32:esp32:esp32", template: esp32}
+    - {name: esp32s3, fqbn: "esp32:esp32:esp32s3", template: esp32s3}
+    - {name: esp8266, fqbn: "esp8266:esp8266:nodemcuv2", template: esp8266}
+```
+
+- [ ] **Step 5: Run tests, confirm pass**
+
+```
+go test ./internal/config/... -v
+go test ./...
+```
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add internal/config/
+git commit -m "feat(config): add Scaffolding.Boards typed input with 6 defaults"
+```
+
+---
+
+## Task 8: `newproject` subcommand package
+
+**Files:**
+- Create: `internal/subcommands/newproject/newproject.go`
+- Create: `internal/subcommands/newproject/newproject_test.go`
+- Create: `internal/subcommands/newproject/assets/default.ino`
+- Create: `internal/subcommands/newproject/assets/uno.ino`
+- Create: `internal/subcommands/newproject/assets/mega.ino`
+- Create: `internal/subcommands/newproject/assets/nano.ino`
+- Create: `internal/subcommands/newproject/assets/esp32.ino`
+- Create: `internal/subcommands/newproject/assets/esp32s3.ino`
+- Create: `internal/subcommands/newproject/assets/esp8266.ino`
+
+- [ ] **Step 1: Create .ino assets**
+
+Read `/home/marvin/git-clones/ArduinoArchSetup/lib/scaffold.sh` and extract the `cat >...` heredoc bodies for each per-board `.ino` template. If any board doesn't have its own heredoc in the bash file, copy the `default.ino` content for it. Keep each file's content verbatim.
+
+For `default.ino`, if the bash has no explicit default heredoc, use this minimal fallback:
+
+```
+void setup() {
+  Serial.begin(115200);
+}
+
+void loop() {
+}
+```
+
+- [ ] **Step 2: Write failing test**
+
+```go
+package newproject
+
+import (
+    "os"
+    "path/filepath"
+    "strings"
+    "testing"
+
+    "github.com/MDietermann/ArduinoArchSetup/internal/config"
+)
+
+func sampleCfg() config.Config {
+    return config.Config{
+        Scaffolding: config.Scaffolding{Boards: []config.Board{
+            {Name: "uno", FQBN: "arduino:avr:uno", Template: "uno"},
+            {Name: "xyz", FQBN: "fake:fqbn:xyz", Template: "does-not-exist"},
+        }},
+    }
+}
+
+func TestRunCreatesProject(t *testing.T) {
+    dir := t.TempDir()
+    t.Chdir(dir)
+    if err := Run(sampleCfg(), "blinky", "uno"); err != nil { t.Fatal(err) }
+    ino, err := os.ReadFile(filepath.Join("blinky", "blinky.ino"))
+    if err != nil { t.Fatalf("blinky.ino missing: %v", err) }
+    if len(ino) == 0 { t.Error("blinky.ino empty") }
+    sketch, err := os.ReadFile(filepath.Join("blinky", "sketch.yaml"))
+    if err != nil { t.Fatalf("sketch.yaml missing: %v", err) }
+    if !strings.Contains(string(sketch), "arduino:avr:uno") {
+        t.Errorf("sketch.yaml missing fqbn: %s", sketch)
+    }
+    if _, err := os.Stat(filepath.Join("blinky", ".clangd")); err != nil {
+        t.Errorf(".clangd missing: %v", err)
+    }
+}
+
+func TestRunRefusesExistingDir(t *testing.T) {
+    dir := t.TempDir(); t.Chdir(dir)
+    os.Mkdir("blinky", 0o755)
+    if err := Run(sampleCfg(), "blinky", "uno"); err == nil {
+        t.Fatal("want error on existing dir")
+    }
+}
+
+func TestRunFallsBackToDefaultTemplate(t *testing.T) {
+    dir := t.TempDir(); t.Chdir(dir)
+    if err := Run(sampleCfg(), "thing", "xyz"); err != nil { t.Fatal(err) }
+    if _, err := os.Stat(filepath.Join("thing", "thing.ino")); err != nil {
+        t.Fatalf("thing.ino missing: %v", err)
+    }
+}
+
+func TestRunUnknownBoardErrors(t *testing.T) {
+    dir := t.TempDir(); t.Chdir(dir)
+    err := Run(sampleCfg(), "thing", "bogus")
+    if err == nil { t.Fatal("want error") }
+    if !strings.Contains(err.Error(), "uno") {
+        t.Errorf("error should list valid boards: %v", err)
+    }
+}
+
+func TestRunRejectsSlashInProjectName(t *testing.T) {
+    dir := t.TempDir(); t.Chdir(dir)
+    if err := Run(sampleCfg(), "bad/name", "uno"); err == nil {
+        t.Fatal("want error on slashes")
+    }
+}
+```
+
+`t.Chdir` is Go 1.24+. If the repo's Go is older, replace with an explicit pushd pattern (record `os.Getwd`, `os.Chdir(dir)`, and a `t.Cleanup(func() { os.Chdir(old) })`).
+
+- [ ] **Step 3: Run tests, confirm fail**
+
+```
+go test ./internal/subcommands/newproject/... -v
+```
+Expected: `undefined: Run`.
+
+- [ ] **Step 4: Implement `newproject.go`**
+
+```go
+// Package newproject scaffolds a new Arduino sketch directory.
+package newproject
+
+import (
+    "embed"
+    "fmt"
+    "os"
+    "path/filepath"
+    "strings"
+
+    "github.com/MDietermann/ArduinoArchSetup/internal/config"
+    "github.com/MDietermann/ArduinoArchSetup/internal/platform"
+)
+
+//go:embed assets
+var assetsFS embed.FS
+
+const clangdContent = `CompileFlags:
+  Add:
+    - -xc++
+    - -std=c++17
+`
+
+// Run creates a new Arduino project directory. It errors if the project
+// directory already exists, if the board is unknown, or if the project name
+// contains a path separator.
+func Run(cfg config.Config, project, board string) error {
+    if project == "" {
+        return fmt.Errorf("project name required")
+    }
+    if strings.ContainsAny(project, "/\\") || strings.HasPrefix(project, ".") {
+        return fmt.Errorf("invalid project name %q", project)
+    }
+
+    var b *config.Board
+    var valid []string
+    for i := range cfg.Scaffolding.Boards {
+        bp := &cfg.Scaffolding.Boards[i]
+        valid = append(valid, bp.Name)
+        if bp.Name == board { b = bp }
+    }
+    if b == nil {
+        return fmt.Errorf("unknown board %q; valid: %s", board, strings.Join(valid, ", "))
+    }
+
+    if _, err := os.Stat(project); err == nil {
+        return fmt.Errorf("project directory %q already exists", project)
+    }
+    if err := os.MkdirAll(project, 0o755); err != nil { return err }
+
+    // Pick .ino template: try <template>.ino, else default.ino.
+    inoData, err := assetsFS.ReadFile(filepath.Join("assets", b.Template+".ino"))
+    if err != nil {
+        inoData, err = assetsFS.ReadFile("assets/default.ino")
+        if err != nil { return err }
+    }
+    if err := platform.WriteUserFile(filepath.Join(project, project+".ino"), inoData, 0o644); err != nil {
+        return err
+    }
+
+    sketch := fmt.Sprintf("default_fqbn: %s\ndefault_port: auto\n", b.FQBN)
+    if err := platform.WriteUserFile(filepath.Join(project, "sketch.yaml"), []byte(sketch), 0o644); err != nil {
+        return err
+    }
+    if err := platform.WriteUserFile(filepath.Join(project, ".clangd"), []byte(clangdContent), 0o644); err != nil {
+        return err
+    }
+    return nil
+}
+```
+
+- [ ] **Step 5: Run tests, confirm pass**
+
+```
+go test ./internal/subcommands/newproject/... -v
+go test ./...
+```
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add internal/subcommands/newproject/
+git commit -m "feat(newproject): add archduino new project scaffolder"
+```
+
+---
+
+## Task 9: `doctor` subcommand package
+
+**Files:**
+- Create: `internal/subcommands/doctor/doctor.go`
+- Create: `internal/subcommands/doctor/doctor_test.go`
+
+- [ ] **Step 1: Write failing test**
+
+```go
+package doctor
+
+import (
+    "bytes"
+    "context"
+    "errors"
+    "strings"
+    "testing"
+
+    "github.com/MDietermann/ArduinoArchSetup/internal/config"
+    "github.com/MDietermann/ArduinoArchSetup/internal/module"
+)
+
+// convergedModule returns an empty Plan — always converged.
+type convergedModule struct{ id string }
+func (c convergedModule) Meta() module.Meta { return module.Meta{ID: c.id, Name: c.id} }
+func (c convergedModule) Detect(context.Context) (module.State, error) { return nil, nil }
+func (c convergedModule) Plan(context.Context, module.State) (module.Plan, error) { return module.Plan{}, nil }
+func (c convergedModule) Apply(context.Context, module.Plan, module.Reporter) error { return nil }
+func (c convergedModule) Verify(context.Context) error { return nil }
+
+type pendingModule struct{ id string }
+func (p pendingModule) Meta() module.Meta { return module.Meta{ID: p.id} }
+func (p pendingModule) Detect(context.Context) (module.State, error) { return nil, nil }
+func (p pendingModule) Plan(context.Context, module.State) (module.Plan, error) {
+    return module.Plan{Actions: []module.Action{{Description: "do a thing"}}}, nil
+}
+func (p pendingModule) Apply(context.Context, module.Plan, module.Reporter) error { return nil }
+func (p pendingModule) Verify(context.Context) error { return nil }
+
+type detectFailModule struct{ id string }
+func (d detectFailModule) Meta() module.Meta { return module.Meta{ID: d.id} }
+func (d detectFailModule) Detect(context.Context) (module.State, error) { return nil, errors.New("boom") }
+func (d detectFailModule) Plan(context.Context, module.State) (module.Plan, error) { return module.Plan{}, nil }
+func (d detectFailModule) Apply(context.Context, module.Plan, module.Reporter) error { return nil }
+func (d detectFailModule) Verify(context.Context) error { return nil }
+
+// notFoundRunner simulates "command not found" for version checks.
+type notFoundRunner struct{}
+func (notFoundRunner) Run(context.Context, string, ...string) error { return errors.New("not found") }
+func (notFoundRunner) Output(context.Context, string, ...string) ([]byte, error) { return nil, errors.New("not found") }
+
+// fixedRunner returns a preset version string for a matching command.
+type fixedRunner struct {
+    arduinoOut []byte
+    arduinoErr error
+    wokwiOut   []byte
+    wokwiErr   error
+}
+func (f fixedRunner) Run(context.Context, string, ...string) error { return nil }
+func (f fixedRunner) Output(_ context.Context, name string, args ...string) ([]byte, error) {
+    switch name {
+    case "arduino-cli":
+        return f.arduinoOut, f.arduinoErr
+    case "wokwi-cli":
+        return f.wokwiOut, f.wokwiErr
+    }
+    return nil, errors.New("no match")
+}
+
+func TestDoctorAllConvergedExitsZero(t *testing.T) {
+    reg := module.NewRegistry()
+    _ = reg.Register(convergedModule{id: "foo"})
+    var buf bytes.Buffer
+    code := Run(context.Background(), config.Config{}, reg, notFoundRunner{}, &buf)
+    if code != 0 { t.Fatalf("exit %d, want 0; output:\n%s", code, buf.String()) }
+    if !strings.Contains(buf.String(), "[✓] foo") {
+        t.Errorf("missing converged mark: %s", buf.String())
+    }
+}
+
+func TestDoctorDivergedExitsOne(t *testing.T) {
+    reg := module.NewRegistry()
+    _ = reg.Register(pendingModule{id: "bar"})
+    var buf bytes.Buffer
+    code := Run(context.Background(), config.Config{}, reg, notFoundRunner{}, &buf)
+    if code != 1 { t.Fatalf("exit %d, want 1", code) }
+    if !strings.Contains(buf.String(), "[✗] bar") {
+        t.Errorf("missing diverged mark: %s", buf.String())
+    }
+}
+
+func TestDoctorDetectErrorIsReported(t *testing.T) {
+    reg := module.NewRegistry()
+    _ = reg.Register(detectFailModule{id: "baz"})
+    var buf bytes.Buffer
+    code := Run(context.Background(), config.Config{}, reg, notFoundRunner{}, &buf)
+    if code != 1 { t.Fatalf("exit %d, want 1", code) }
+    if !strings.Contains(buf.String(), "[!] baz") {
+        t.Errorf("missing error mark: %s", buf.String())
+    }
+}
+
+func TestDoctorArduinoCLIDriftIsReported(t *testing.T) {
+    reg := module.NewRegistry()
+    _ = reg.Register(convergedModule{id: "foo"})
+    cfg := config.Config{ArduinoCLI: config.ArduinoCLIConfig{Version: "0.35.3"}}
+    runner := fixedRunner{arduinoOut: []byte(`{"VersionString":"0.36.0"}`)}
+    var buf bytes.Buffer
+    code := Run(context.Background(), cfg, reg, runner, &buf)
+    if code != 1 { t.Fatalf("exit %d, want 1 (drift)", code) }
+    if !strings.Contains(buf.String(), "drift") {
+        t.Errorf("missing drift report: %s", buf.String())
+    }
+}
+
+func TestDoctorMissingBinariesSkipVersionCheck(t *testing.T) {
+    reg := module.NewRegistry()
+    _ = reg.Register(convergedModule{id: "foo"})
+    cfg := config.Config{ArduinoCLI: config.ArduinoCLIConfig{Version: "0.35.3"}}
+    var buf bytes.Buffer
+    code := Run(context.Background(), cfg, reg, notFoundRunner{}, &buf)
+    if code != 0 { t.Fatalf("exit %d, want 0; output:\n%s", code, buf.String()) }
+}
+```
+
+- [ ] **Step 2: Run tests, confirm fail**
+
+```
+go test ./internal/subcommands/doctor/... -v
+```
+Expected: `undefined: Run`.
+
+- [ ] **Step 3: Implement `doctor.go`**
+
+```go
+// Package doctor reports module convergence and pinned-tool version drift.
+package doctor
+
+import (
+    "context"
+    "encoding/json"
+    "fmt"
+    "io"
+    "regexp"
+    "strings"
+
+    "github.com/MDietermann/ArduinoArchSetup/internal/config"
+    "github.com/MDietermann/ArduinoArchSetup/internal/module"
+    "github.com/MDietermann/ArduinoArchSetup/internal/platform"
+)
+
+// Run inspects every module in the registry plus pinned tool versions and
+// writes a human-readable report to w. Returns 0 when everything is
+// converged with no drift; 1 otherwise. Never panics on module errors.
+func Run(ctx context.Context, cfg config.Config, reg *module.Registry, runner platform.Runner, w io.Writer) int {
+    var converged, pending, errs, drift int
+
+    for _, m := range reg.All() {
+        id := m.Meta().ID
+        st, err := m.Detect(ctx)
+        if err != nil {
+            fmt.Fprintf(w, "[!] %s — detect failed: %v\n", id, err)
+            errs++
+            continue
+        }
+        pl, err := m.Plan(ctx, st)
+        if err != nil {
+            fmt.Fprintf(w, "[!] %s — plan failed: %v\n", id, err)
+            errs++
+            continue
+        }
+        if pl.IsEmpty() {
+            fmt.Fprintf(w, "[✓] %s\n", id)
+            converged++
+        } else {
+            fmt.Fprintf(w, "[✗] %s (%d actions pending)\n", id, len(pl.Actions))
+            pending++
+        }
+    }
+
+    drift += checkArduinoCLI(ctx, runner, cfg.ArduinoCLI.Version, w)
+    drift += checkWokwiCLI(ctx, runner, cfg.Renode.WokwiVersion, w)
+
+    fmt.Fprintf(w, "\n%d converged, %d need-install, %d drift, %d errors\n", converged, pending, drift, errs)
+
+    if pending > 0 || drift > 0 || errs > 0 { return 1 }
+    return 0
+}
+
+type arduinoCLIVersion struct {
+    VersionString string `json:"VersionString"`
+}
+
+func checkArduinoCLI(ctx context.Context, runner platform.Runner, want string, w io.Writer) int {
+    if want == "" { return 0 }
+    out, err := runner.Output(ctx, "arduino-cli", "version", "--format", "json")
+    if err != nil { return 0 } // not installed → silent skip
+    var v arduinoCLIVersion
+    if err := json.Unmarshal(out, &v); err != nil || v.VersionString == "" {
+        fmt.Fprintf(w, "[!] arduino-cli — version parse failed\n")
+        return 1
+    }
+    if v.VersionString != want {
+        fmt.Fprintf(w, "[!] arduino-cli drift: got %s, want %s\n", v.VersionString, want)
+        return 1
+    }
+    fmt.Fprintf(w, "[✓] arduino-cli %s\n", v.VersionString)
+    return 0
+}
+
+var wokwiVersionRE = regexp.MustCompile(`v?(\d+\.\d+\.\d+)`)
+
+func checkWokwiCLI(ctx context.Context, runner platform.Runner, want string, w io.Writer) int {
+    if want == "" { return 0 }
+    out, err := runner.Output(ctx, "wokwi-cli", "--version")
+    if err != nil { return 0 }
+    m := wokwiVersionRE.FindStringSubmatch(strings.TrimSpace(string(out)))
+    if len(m) < 2 {
+        fmt.Fprintf(w, "[!] wokwi-cli — version parse failed\n")
+        return 1
+    }
+    got := m[1]
+    if got != want {
+        fmt.Fprintf(w, "[!] wokwi-cli drift: got %s, want %s\n", got, want)
+        return 1
+    }
+    fmt.Fprintf(w, "[✓] wokwi-cli %s\n", got)
+    return 0
+}
+```
+
+- [ ] **Step 4: Run tests, confirm pass**
+
+```
+go test ./internal/subcommands/doctor/... -v
+go test ./...
+```
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add internal/subcommands/doctor/
+git commit -m "feat(doctor): add archduino doctor subcommand"
+```
+
+---
+
+## Task 10: Wire all three subcommands into cobra + integrate theming into install
+
+**Files:**
+- Modify: `cmd/archduino/main.go`
+
+- [ ] **Step 1: Add the three cobra constructors**
+
+Append near the existing `newInstallCmd`:
+
+```go
+func newThemeCmd() *cobra.Command {
+    var overlayPath string
+    cmd := &cobra.Command{
+        Use:   "theme [id]",
+        Short: "Switch the active colorscheme across tools",
+        Args:  cobra.MaximumNArgs(1),
+        RunE: func(cmd *cobra.Command, args []string) error {
+            cfg, err := config.Load(overlayPath)
+            if err != nil { return err }
+
+            // "list" short-circuit.
+            if len(args) == 1 && args[0] == "list" {
+                for _, t := range theming.List() {
+                    fmt.Printf("%s — %s\n", t.ID, t.DisplayName)
+                }
+                return nil
+            }
+
+            var id string
+            if len(args) == 1 {
+                id = args[0]
+            } else {
+                // Interactive picker.
+                themes := theming.List()
+                opts := make([]huh.Option[string], 0, len(themes))
+                for _, t := range themes { opts = append(opts, huh.NewOption(t.DisplayName, t.ID)) }
+                id = cfg.ThemeOverrides["__active"]
+                if id == "" && len(themes) > 0 { id = themes[0].ID }
+                form := huh.NewForm(huh.NewGroup(
+                    huh.NewSelect[string]().Title("Choose a theme").Options(opts...).Value(&id),
+                ))
+                if err := form.RunWithContext(cmd.Context()); err != nil {
+                    if errors.Is(err, huh.ErrUserAborted) { return nil }
+                    return err
+                }
+            }
+
+            if err := theming.Apply(cfg, id); err != nil { return err }
+            fmt.Printf("Applied theme: %s\n", id)
+            fmt.Println("Restart zellij and neovim to see the new colors.")
+            return nil
+        },
+    }
+    cmd.Flags().StringVar(&overlayPath, "overlay", "", "path to overlay.yaml (defaults to ~/.config/archduino/overlay.yaml)")
+    return cmd
+}
+
+func newNewCmd() *cobra.Command {
+    var overlayPath string
+    cmd := &cobra.Command{
+        Use:   "new <project> <board>",
+        Short: "Scaffold a new Arduino sketch directory",
+        Args:  cobra.ExactArgs(2),
+        RunE: func(cmd *cobra.Command, args []string) error {
+            cfg, err := config.Load(overlayPath)
+            if err != nil { return err }
+            project, board := args[0], args[1]
+            if err := newproject.Run(cfg, project, board); err != nil { return err }
+            fmt.Printf("Created %s/ (board: %s)\n", project, board)
+            fmt.Printf("Next: cd %s && nvim %s.ino\n", project, project)
+            return nil
+        },
+    }
+    cmd.Flags().StringVar(&overlayPath, "overlay", "", "path to overlay.yaml")
+    return cmd
+}
+
+func newDoctorCmd() *cobra.Command {
+    var overlayPath string
+    cmd := &cobra.Command{
+        Use:   "doctor",
+        Short: "Report module convergence and pinned-tool version drift",
+        Args:  cobra.NoArgs,
+        RunE: func(cmd *cobra.Command, args []string) error {
+            cfg, err := config.Load(overlayPath)
+            if err != nil { return err }
+            reg, err := buildRegistry(cfg, cfg.ThemeOverrides["__active"])
+            if err != nil { return fmt.Errorf("build registry: %w", err) }
+            code := doctor.Run(cmd.Context(), cfg, reg, platform.ExecRunner{}, os.Stdout)
+            if code != 0 { os.Exit(code) }
+            return nil
+        },
+    }
+    cmd.Flags().StringVar(&overlayPath, "overlay", "", "path to overlay.yaml")
+    return cmd
+}
+```
+
+Add these registrations near `root.AddCommand(newInstallCmd())`:
+
+```go
+root.AddCommand(newThemeCmd())
+root.AddCommand(newNewCmd())
+root.AddCommand(newDoctorCmd())
+```
+
+Add imports:
+
+```go
+"errors"
+"github.com/charmbracelet/huh"
+"github.com/MDietermann/ArduinoArchSetup/internal/subcommands/doctor"
+"github.com/MDietermann/ArduinoArchSetup/internal/subcommands/newproject"
+"github.com/MDietermann/ArduinoArchSetup/internal/theming"
+```
+
+- [ ] **Step 2: Integrate theming into install**
+
+In `newInstallCmd`'s RunE, after the block that invokes `engine.Run` and assigns `sum, runErr` (the existing plain-path or TUI-path block), add — after any error handling that returns early and after the TUI post-wizard logic that rebuilds the registry:
+
+```go
+            // Apply the wizard-selected theme (no-op if user chose a theme
+            // whose configs are already on disk).
+            if runErr == nil && !dryRun {
+                selectedTheme := finalState.ThemeID
+                if selectedTheme == "" { selectedTheme = cfg.ThemeOverrides["__active"] }
+                if selectedTheme != "" {
+                    if err := theming.Apply(cfg, selectedTheme); err != nil {
+                        fmt.Fprintf(os.Stderr, "warning: theme apply failed: %v\n", err)
+                    }
+                }
+            }
+```
+
+The exact variable names (`finalState`, `runErr`, `dryRun`) come from the existing install command code. Match them to what's currently in `newInstallCmd`. If the plain-output path doesn't have access to a chosen theme ID (because no wizard ran), fall through with just `cfg.ThemeOverrides["__active"]`.
+
+- [ ] **Step 3: Run build + tests**
+
+```
+go build ./...
+go test ./...
+```
+Both green.
+
+- [ ] **Step 4: Manual smoke (optional, non-blocking)**
+
+```
+go run ./cmd/archduino --help
+go run ./cmd/archduino theme list
+go run ./cmd/archduino doctor
+```
+Expected: help lists all four subcommands; `theme list` prints 5 themes; `doctor` reports per-module status.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add cmd/archduino/main.go
+git commit -m "feat(cmd): add theme/new/doctor subcommands; install applies theme"
+```
+
+---
+
+## Self-review notes
+
+- Spec coverage: theming package (Tasks 1-5), tui retirement (Task 6), config extension (Task 7), newproject (Task 8), doctor (Task 9), cobra wiring + install integration (Task 10). All spec sections mapped.
+- Type consistency: `theming.Theme{ID, DisplayName, NvChadTheme}`, `theming.List`, `theming.Get`, `theming.Apply(cfg, id)`, `config.Board{Name, FQBN, Template}`, `config.Scaffolding.Boards`, `newproject.Run(cfg, project, board) error`, `doctor.Run(ctx, cfg, reg, runner, w) int`, `neovim.WriteChadrc(nvChadThemeName) error`. Neovim `New` signature change in Task 6 consistently applied to `main.go` and tests.
+- Known approximations:
+  - Task 1's `_ = strings.Split` is a placeholder to keep the import live for Task 2; delete if the build complains.
+  - Task 5 Step 3 requires copy-paste from 4 bash files. Diff carefully — bash `$variable` interpolations are rare in the theme files but not impossible; any `$foo` in the heredoc bodies must be preserved as literal text (the heredocs use quoted delimiters `'TOML'` / `'KDL'` / `'YAML'` which disable expansion in bash).
+  - Task 6 is the highest-risk task because it touches six files. The grep in Step 1 is authoritative; do not skip it.
+  - Task 10 Step 2's `finalState.ThemeID` depends on the current install command's variable name. If it's a different name (e.g., `state`), use that. Read the current code before inserting.