diff --git a/README.md b/README.md
index ac74962..a496db0 100644
--- a/README.md
+++ b/README.md
@@ -25,10 +25,10 @@ Reusable Dev Containers for any project — without modifying the repository.
 - [Background](#background)
 - [Install](#install)
 - [Usage](#usage)
-- [API](#api)
 - [Configuration](#configuration)
 - [Template System](#template-system)
 - [File Injection](#file-injection)
+- [API](#api)
 - [Contributing](#contributing)
 - [License](#license)
 
@@ -56,7 +56,7 @@ Typical Dev Container workflows involve:
 
 ## Install
 
-### Prerequisites
+### Dependencies
 
 - VS Code with the [Dev Containers](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers) extension
 - Docker
@@ -81,15 +81,15 @@ devcode open ~/projects/my-app dev-code
 ### Typical Workflow
 
 ```bash
-devcode new python-dev
-devcode edit python-dev
+devcode template new python-dev
+devcode template edit python-dev
 devcode open ~/projects/my-app python-dev
 ```
 
 ### Project Switching
 
 ```bash
-devcode ps -a -i
+devcode list -a -i
 ```
 
 Lists containers and allows reopening projects interactively.
@@ -97,7 +97,6 @@ Lists containers and allows reopening projects interactively.
 ### Advanced Options
 
 - Multiple template directories
-- Template inheritance
 - Verbose debugging (`-v`)
 - Dry runs (`--dry-run`)
 - Custom container paths
@@ -111,257 +110,332 @@ Lists containers and allows reopening projects interactively.
 
 ---
 
-## API
+## Configuration
 
-Full reference for all `devcode` commands and flags.
+devcode reads `settings.json` from:
 
-### Global Flags
+```
+~/.config/dev-code/settings.json
+```
+
+Override the config directory:
 
 ```bash
--v, --verbose   Enable debug output
+DEVCODE_CONF_DIR=/custom/path devcode open ~/projects/my-app
 ```
 
+The file is created automatically with defaults on first run.
+
+### settings.json
+
+```json
+{
+  "template_sources": ["~/.local/share/dev-code/templates"],
+  "default_template": "dev-code",
+  "template_write_dir": null
+}
+```
+
+| Key | Description |
+| --- | --- |
+| `template_sources` | Ordered list of template directories searched when resolving templates. |
+| `default_template` | Template used when `devcode open` is called without a template argument and no container history is found. Error if unset. |
+| `template_write_dir` | Directory where `devcode template new` writes new templates. `null` (default) uses the XDG data home: `~/.local/share/dev-code/templates`. Overridden per-invocation by `--path`. |
+
 ---
 
-### devcode open
+## Template System
 
-```bash
-devcode open <path> [template] [options]
+### Default Location
+
+```
+~/.local/share/dev-code/templates/
 ```
 
-Open a project in VS Code using a devcontainer template.
+Configure additional paths via `template_sources` in `settings.json` (see [Configuration](#configuration)).
 
-#### Arguments
+---
 
-* `<path>` — Project directory (must exist)
+## File Injection
 
-* `[template]` *(optional)*
+Inject files from the host into the container at startup.
 
-  * Template name, or
-  * Path to a `devcontainer.json`, or
-  * Path to a directory containing it
+### Example
 
-  Paths must start with `./`, `../`, `/`, or `~/`.
+```json
+{
+  "customizations": {
+    "dev-code": {
+      "cp": [
+        {
+          "source": "${localEnv:HOME}/.config/myapp",
+          "target": "/home/vscode/.config/myapp"
+        }
+      ]
+    }
+  }
+}
+```
 
-  If both a template name and a local directory match, the template takes precedence and a warning is shown.
+### Fields
 
-  **If omitted**, devcode auto-detects the template in this order:
-  1. Most recently running container for this project path (uses its stored config)
-  2. Most recently stopped container for this project path
-  3. `default_template` from `settings.json` (error if not set)
+| Field         | Required | Description                            |
+| ------------- | -------- | -------------------------------------- |
+| `source`      | Yes      | Host path                              |
+| `target`      | Yes      | Container path                         |
+| `override`    | No       | Skip if target exists (default: false) |
+| `owner`       | No       | Requires `group`                       |
+| `group`       | No       | Requires `owner`                       |
+| `permissions` | No       | chmod applied recursively              |
 
-#### Options
+### Source Behavior
 
-| Option                      | Default                 | Description                                                |
-| --------------------------- | ----------------------- | ---------------------------------------------------------- |
-| `--dry-run`                 | —                       | Print resolved configuration and actions without executing |
-| `--container-folder <path>` | resolved from devcontainer config | Container mount path                                       |
-| `--timeout <seconds>`       | `300`                   | Time to wait for container startup                         |
+* Supports `${localEnv:VAR}`
+* Supports relative paths from `.devcontainer/`
+* Missing environment variables cause the entry to be skipped
 
----
+### Copy Directory Contents
 
-### devcode new
+Use `/.` suffix:
 
-```bash
-devcode new <name> [base]
+```json
+{
+  "source": "${localEnv:HOME}/.config/myapp/.",
+  "target": "/home/vscode/.config/myapp/"
+}
 ```
 
-Create a new template.
+Copies directory contents instead of the directory itself.
 
-| Argument | Default    | Description           |
-| -------- | ---------- | --------------------- |
-| `[base]` | `dev-code` | Template to copy from |
+### Behavior Rules
+
+* `target/` copies into the directory
+* Without trailing `/` copies as a file or directory
+* `override=false` skips existing files
+* Ownership and permissions are applied after copying
+
+---
+
+## API
 
-Options:
+Full reference for all `devcode` commands and flags.
+
+### Global Flags
 
 ```bash
---edit
+-v, --verbose   Enable debug output
+--version       Show version and exit
 ```
 
-Open the template in VS Code after creation.
-
 ---
 
-### devcode edit
+### devcode open
 
 ```bash
-devcode edit [template]
+devcode open <path> [template] [options]
 ```
 
-* With a name: opens that template
-* Without arguments: opens the templates directory
+Open a project in VS Code using a devcontainer template.
+
+#### Arguments
+
+* `<path>` — Project directory (must exist)
+* `[template]` *(optional)* — Template name, path to a `devcontainer.json`, or path to a directory containing it. Paths must start with `./`, `../`, `/`, or `~/`. If omitted, devcode resolves in this order:
+  1. Most recently running container for this project path
+  2. Most recently stopped container for this project path
+  3. `default_template` from `settings.json` (error if not set)
+
+#### Options
+
+| Option | Default | Description |
+| --- | --- | --- |
+| `--dry-run` | — | Print resolved configuration and actions without executing |
+| `--container-folder <path>` | resolved from devcontainer config | Container mount path |
+| `--timeout <seconds>` | `300` | Time to wait for container startup |
 
 ---
 
 ### devcode list
 
 ```bash
-devcode list [--long]
+devcode list [-a] [-i]
 ```
 
-| Option   | Description                             |
-| -------- | --------------------------------------- |
-| `--long` | Show full paths and grouped directories |
+List dev containers.
+
+| Flag | Description |
+| --- | --- |
+| `-a, --all` | Include stopped containers |
+| `-i, --interactive` | Prompt to reopen a listed container |
+
+Interactive mode prompts `Open [1-N]:` — selecting a number reopens the project in VS Code.
 
 ---
 
-### devcode ps
+### devcode prune
 
 ```bash
-devcode ps [-a] [-i]
+devcode prune [path] [options]
 ```
 
-| Flag | Description                |
-| ---- | -------------------------- |
-| `-a` | Include stopped containers |
-| `-i` | Interactive reopen mode    |
+Remove stopped dev containers. Either `[path]` or `--all-projects` is required.
 
-Interactive mode prompts:
+#### Arguments
 
-```
-Open [1-N]:
-```
+* `[path]` *(optional)* — Limit pruning to containers for this project directory.
+
+#### Options
 
-Selecting a number reopens the project in VS Code.
+| Option | Description |
+| --- | --- |
+| `--all-projects` | Prune stopped containers across all projects |
+| `--include-recent` | Also prune the most recently used container (skipped by default) |
 
 ---
 
-### devcode completion
+### devcode template
 
 ```bash
-devcode completion bash
-devcode completion zsh
+devcode template <subcommand>
 ```
 
-Enable in shell:
+Manage dev container templates.
+
+---
+
+#### devcode template new
 
 ```bash
-eval "$(devcode completion bash)"
+devcode template new <name> [base] [options]
 ```
 
----
+Create a new template by copying a base template.
 
-## Configuration
+| Argument | Default | Description |
+| --- | --- | --- |
+| `[base]` | `dev-code` | Template to copy from |
 
-devcode reads `settings.json` from:
+| Option | Description |
+| --- | --- |
+| `--edit` | Launch the new template as a Dev Container in VS Code after creation |
+| `--path <dir>` | Write the new template into `<dir>` instead of the configured write target |
 
-```
-~/.config/dev-code/settings.json
-```
+---
 
-Override the config directory:
+#### devcode template edit
 
 ```bash
-DEVCODE_CONF_DIR=/custom/path devcode open ~/projects/my-app
+devcode template edit <template>
 ```
 
-The file is created automatically with defaults on first run.
+Open a template directory in VS Code for editing.
 
-### settings.json
+---
 
-```json
-{
-  "template_sources": ["~/.local/share/dev-code/templates"],
-  "default_template": "dev-code"
-}
+#### devcode template list
+
+```bash
+devcode template list [--long]
 ```
 
-| Key | Description |
+List available templates.
+
+| Option | Description |
 | --- | --- |
-| `template_sources` | Ordered list of template directories. First is the write target; rest are read-only. |
-| `default_template` | Template used when `devcode open` is called without a template argument and no container history is found. Error if unset. |
+| `--long` | Show description and full path for each template |
 
 ---
 
-## Template System
+#### devcode template default
 
-### Default Location
-
-```
-~/.local/share/dev-code/templates/
+```bash
+devcode template default [name]
 ```
 
-Configure additional paths via `template_sources` in `settings.json` (see [Configuration](#configuration)).
+Get or set the default template.
+
+* Without `name`: prints the current default.
+* With `name`: sets `default_template` in `settings.json`.
 
 ---
 
-## File Injection
+#### devcode template source
 
-Inject files from the host into the container at startup.
+```bash
+devcode template source <subcommand>
+```
 
-### Example
+Manage template search paths stored in `settings.json`.
 
-```json
-{
-  "customizations": {
-    "dev-code": {
-      "cp": [
-        {
-          "source": "${localEnv:HOME}/.config/myapp",
-          "target": "/home/vscode/.config/myapp"
-        }
-      ]
-    }
-  }
-}
+---
+
+#### devcode template source list
+
+```bash
+devcode template source list
 ```
 
+Print all configured template search paths, one per line.
+
 ---
 
-### Fields
+#### devcode template source add
 
-| Field         | Required | Description                            |
-| ------------- | -------- | -------------------------------------- |
-| `source`      | Yes      | Host path                              |
-| `target`      | Yes      | Container path                         |
-| `override`    | No       | Skip if target exists (default: false) |
-| `owner`       | No       | Requires `group`                       |
-| `group`       | No       | Requires `owner`                       |
-| `permissions` | No       | chmod applied recursively              |
+```bash
+devcode template source add <path>
+```
+
+Append `<path>` to `template_sources` in `settings.json`. Prints a notice and exits cleanly if already present.
 
 ---
 
-### Source Behavior
+#### devcode template source remove
 
-* Supports `${localEnv:VAR}`
-* Supports relative paths from `.devcontainer/`
-* Missing environment variables cause the entry to be skipped
+```bash
+devcode template source remove <path>
+```
 
----
+Remove `<path>` from `template_sources` in `settings.json`. Exits with an error if not found.
 
-### Copy Directory Contents
+---
 
-Use `/.` suffix:
+### devcode completion
 
-```json
-{
-  "source": "${localEnv:HOME}/.config/myapp/.",
-  "target": "/home/vscode/.config/myapp/"
-}
+```bash
+devcode completion bash
+devcode completion zsh
+devcode completion fish
 ```
 
-Copies directory contents instead of the directory itself.
+Print the shell completion setup command for the given shell.
 
----
+Add to your shell rc file for persistent completion:
 
-### Behavior Rules
+```bash
+# bash (~/.bashrc)
+eval "$(devcode completion bash)"
 
-* `target/` copies into the directory
-* Without trailing `/` copies as a file or directory
-* `override=false` skips existing files
-* Ownership and permissions are applied after copying
+# zsh (~/.zshrc)
+eval "$(devcode completion zsh)"
+
+# fish (~/.config/fish/config.fish)
+eval (devcode completion fish)
+```
 
 ---
 
 ## Contributing
 
-- PRs welcome. Open an issue first for significant changes.
-- Run `tox` (or `pytest` for a single-interpreter run) before submitting.
+Ask questions, report bugs, or request features in [Issues](https://github.com/dacrystal/dev-code/issues).
+
+PRs welcome. Open an issue first for significant changes.
 
-Report bugs or request features in [Issues](https://github.com/dacrystal/dev-code/issues).
+Run `tox` (or `pytest` for a single-interpreter run) before submitting.
 
 ---
 
 ## License
 
 MIT © Nasser Alansari (dacrystal)
+
+See [LICENSE](LICENSE).
diff --git a/pyproject.toml b/pyproject.toml
index 54ec474..3dd8e25 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -40,7 +40,13 @@ pythonpath = ["src"]
 
 [dependency-groups]
 test = ["pytest>=7", "pytest-cov>=4"]
-dev = ["tox>=4", "pyyaml>=6", "git-cliff>=2"]
+dev = [
+    "tox>=4",
+    "pyyaml>=6",
+    "git-cliff>=2",
+    "ruff>=0.15.10",
+    "mypy>=1.20.0",
+]
 
 [tool.hatch.metadata.hooks.fancy-pypi-readme]
 content-type = "text/markdown"
diff --git a/src/devcode.py b/src/devcode.py
index 4850bce..37fc658 100644
--- a/src/devcode.py
+++ b/src/devcode.py
@@ -1,7 +1,6 @@
 #!/usr/bin/env python3
 import click
 import click.shell_completion
-import importlib.metadata
 import json
 import logging
 import os
@@ -21,7 +20,7 @@
     " / _` |/ _ \\ \\ / /______/ __/ _ \\ / _` |/ _ \\\n"
     "| (_| |  __/\\ V /      | (_| (_) | (_| |  __/\n"
     " \\__,_|\\___| \\_/        \\___\\___/ \\__,_|\\___|\n"
-    "  project · editor · container — simplified  "
+    "  project · editor · container — simplified\n"
 )
 
 KNOWN_CP_FIELDS = {"source", "target", "override", "owner", "group", "permissions"}
@@ -29,6 +28,7 @@
 _DEFAULT_SETTINGS = {
     "template_sources": ["~/.local/share/dev-code/templates"],
     "default_template": "dev-code",
+    "template_write_dir": None,
 }
 
 def _configure_logging(verbose: bool) -> None:
@@ -97,6 +97,20 @@ def _load_settings() -> dict:
         return dict(_DEFAULT_SETTINGS)
 
 
+def _save_settings(settings: dict) -> None:
+    """Write settings dict to settings.json. Exits on write failure."""
+    conf_dir = _conf_dir()
+    settings_path = os.path.join(conf_dir, "settings.json")
+    try:
+        os.makedirs(conf_dir, exist_ok=True)
+        with open(settings_path, "w") as f:
+            json.dump(settings, f, indent=2)
+            f.write("\n")
+    except OSError as e:
+        logger.error("could not write settings file %s: %s", settings_path, e)
+        sys.exit(1)
+
+
 def resolve_template_search_path() -> list[str]:
     """Return ordered list of template search directories from settings.json."""
     settings = _load_settings()
@@ -105,13 +119,41 @@ def resolve_template_search_path() -> list[str]:
         xdg = os.environ.get(
             "XDG_DATA_HOME", os.path.join(os.path.expanduser("~"), ".local", "share")
         )
-        return [os.path.join(xdg, "dev-code", "templates")]
-    return [os.path.expanduser(d) for d in sources if d]
+        return [os.path.realpath(os.path.join(xdg, "dev-code", "templates"))]
+    return [os.path.realpath(os.path.expanduser(d)) for d in sources if d]
+
+
+def _resolve_write_target(path_override=None) -> str:
+    """Resolve the directory where new templates are written.
 
+    Priority (highest to lowest):
+    1. path_override  — the --path flag value
+    2. settings.template_write_dir  — persistent setting
+    3. XDG_DATA_HOME/dev-code/templates  — unconditional fallback
+    """
+    if path_override is not None:
+        resolved = os.path.realpath(os.path.expanduser(path_override))
+        if os.path.exists(resolved) and not os.path.isdir(resolved):
+            logger.error("--path '%s' is not a directory", path_override)
+            sys.exit(1)
+        return resolved
 
-def _write_template_dir() -> str:
-    """Return the first (canonical write) directory from the template search path."""
-    return resolve_template_search_path()[0]
+    settings = _load_settings()
+    write_dir = settings.get("template_write_dir")
+    if write_dir:
+        resolved = os.path.realpath(os.path.expanduser(write_dir))
+        if os.path.exists(resolved) and not os.path.isdir(resolved):
+            logger.warning(
+                "template_write_dir '%s' is not a directory, falling back to XDG default",
+                write_dir,
+            )
+        else:
+            return resolved
+
+    xdg = os.environ.get(
+        "XDG_DATA_HOME", os.path.join(os.path.expanduser("~"), ".local", "share")
+    )
+    return os.path.join(xdg, "dev-code", "templates")
 
 
 def _list_template_names() -> list:
@@ -554,8 +596,8 @@ def _do_open(projectpath: str, template, container_folder, timeout: int, dry_run
     if template:
         config_file = resolve_template(template)
     else:
-        config_file = _find_container_config_for_project(project_path)
-        if config_file is None:
+        found = _find_container_config_for_project(project_path)
+        if found is None:
             settings = _load_settings()
             default = settings.get("default_template", "")
             if not default:
@@ -564,6 +606,8 @@ def _do_open(projectpath: str, template, container_folder, timeout: int, dry_run
                 )
                 sys.exit(1)
             config_file = resolve_template(default)
+        else:
+            config_file = found
 
     if not container_folder:
         data = parse_devcontainer_json(config_file, cwd=project_path)
@@ -642,7 +686,20 @@ def _complete_templates(ctx, param, incomplete):
     ]
 
 
-@click.group(invoke_without_command=True)
+class _DevCodeGroup(click.Group):
+    """Custom CLI group: loads settings eagerly and prepends banner to help output."""
+    def main(self, *args, **kwargs):
+        # Trigger settings file creation/validation before any CLI output (including --help).
+        _load_settings()
+        return super().main(*args, **kwargs)
+
+    def format_help(self, ctx, formatter):
+        formatter.write(BANNER)
+        formatter.write_paragraph()
+        super().format_help(ctx, formatter)
+
+
+@click.group(invoke_without_command=True, cls=_DevCodeGroup)
 @click.version_option(package_name="dev-code", prog_name="devcode")
 @click.option(
     "-v", "--verbose",
@@ -653,17 +710,28 @@ def _complete_templates(ctx, param, incomplete):
 )
 @click.pass_context
 def cli(ctx):
-    """project · editor · container — simplified."""
+    """Open projects in VS Code Dev Containers using reusable local templates."""
     if not shutil.which("devcontainer"):
         click.echo("error: devcontainer CLI not found on PATH", err=True)
         raise click.exceptions.Exit(1)
     if ctx.invoked_subcommand is None:
-        click.echo(BANNER)
         click.echo(ctx.get_help())
 
 
+@cli.group("template")
+def template_group():
+    """Manage dev container templates."""
+    pass
+
+
+@template_group.group("source")
+def source_group():
+    """Manage template search paths."""
+    pass
+
+
 @cli.command("open")
-@click.argument("projectpath")
+@click.argument("projectpath", type=click.Path(file_okay=False, resolve_path=True))
 @click.argument("template", required=False, shell_complete=_complete_templates)
 @click.option("--container-folder", default=None, help="Path inside the container. Default: resolved from devcontainer config.")
 @click.option("--timeout", type=int, default=300, show_default=True,
@@ -674,13 +742,14 @@ def open_command(projectpath, template, container_folder, timeout, dry_run):
     _do_open(projectpath, template, container_folder, timeout, dry_run)
 
 
-@cli.command("new")
+@template_group.command("new")
 @click.argument("name")
-@click.argument("base", required=False)
+@click.argument("base", required=False, shell_complete=_complete_templates)
 @click.option("--edit", is_flag=True, help="Open the new template in VS Code after creating it.")
-def new_command(name, base, edit):
+@click.option("--path", "write_path", default=None, help="Directory to write the new template into.")
+def new_command(name, base, edit, write_path):
     """Create a new template by copying a base template."""
-    write_dir = _write_template_dir()
+    write_dir = _resolve_write_target(write_path)
     dest = os.path.join(write_dir, name)
 
     # Step 1: fail if name already exists
@@ -712,6 +781,15 @@ def new_command(name, base, edit):
     shutil.copytree(base_src, dest)
     print(f"Created template '{name}' at {dest}")
 
+    # Warn if write_dir is not discoverable
+    # resolve_template_search_path already returns realpath'd entries
+    search_paths = resolve_template_search_path()
+    if os.path.realpath(write_dir) not in search_paths:
+        logger.warning(
+            "write dir '%s' is not in template_sources — new template may not be discoverable",
+            write_dir,
+        )
+
     # Step 6: --edit
     if edit:
         _do_open(
@@ -723,7 +801,7 @@ def new_command(name, base, edit):
         )
 
 
-@cli.command("edit")
+@template_group.command("edit")
 @click.argument("template", shell_complete=_complete_templates)
 def edit_command(template):
     """Open a template directory in VS Code for editing."""
@@ -734,9 +812,9 @@ def edit_command(template):
     subprocess.run(["code", template_root])
 
 
-@cli.command("list")
+@template_group.command("list")
 @click.option("--long", is_flag=True, help="Show description and path for each template.")
-def list_command(long):
+def template_list_command(long):
     """List available templates."""
     if not long:
         names = _list_template_names()
@@ -775,10 +853,77 @@ def list_command(long):
         print(_fmt_row(row, widths))
 
 
-@cli.command("ps")
+@template_group.command("default")
+@click.argument("name", required=False)
+def template_default_command(name):
+    """Get or set the default template."""
+    settings = _load_settings()
+    if name is None:
+        current = settings.get("default_template", "")
+        if current:
+            click.echo(current)
+        return
+    settings["default_template"] = name
+    _save_settings(settings)
+    click.echo(f"default template set to '{name}'")
+
+
+@source_group.command("list")
+def source_list_command():
+    """List configured template search paths."""
+    settings = _load_settings()
+    for path in settings.get("template_sources", []):
+        click.echo(path)
+
+
+@source_group.command("add")
+@click.argument("path", type=click.Path())
+def source_add_command(path):
+    """Add a template search path."""
+    path = os.path.expanduser(path)
+    path = os.path.abspath(path)
+    settings = _load_settings()
+    sources = settings.get("template_sources", [])
+    if path not in sources:
+        sources.append(path)
+        settings["template_sources"] = sources
+        _save_settings(settings)
+        click.echo(f"added '{path}' to template_sources")
+    else:
+        click.echo(f"'{path}' is already in template_sources")
+
+
+@source_group.command("remove")
+@click.argument("path", type=click.Path())
+def source_remove_command(path):
+    """Remove a template search path."""
+    path = os.path.expanduser(path)
+    path = os.path.abspath(path)
+    settings = _load_settings()
+    sources = settings.get("template_sources", [])
+    if path not in sources:
+        logger.error("'%s' not found in template_sources", path)
+        sys.exit(1)
+    sources.remove(path)
+    settings["template_sources"] = sources
+    _save_settings(settings)
+    click.echo(f"removed '{path}' from template_sources")
+
+
+@cli.command("completion")
+@click.argument("shell", type=click.Choice(["bash", "zsh", "fish"]))
+def completion_command(shell):
+    """Print shell completion setup command."""
+    if shell == "fish":
+        click.echo("eval (env _DEVCODE_COMPLETE=fish_source devcode)")
+    else:
+        click.echo(f'eval "$(_DEVCODE_COMPLETE={shell}_source devcode)"')
+
+
+@cli.command("list")
 @click.option("-a", "--all", "show_all", is_flag=True, help="Show all containers (not just running).")
 @click.option("-i", "--interactive", is_flag=True, help="Prompt to reopen a listed container.")
-def ps_command(show_all, interactive):
+def list_command(show_all, interactive):
     """List dev containers."""
     fmt = "{{.CreatedAt}}\t{{.ID}}\t{{.Label \"devcontainer.local_folder\"}}\t{{.Label \"devcontainer.config_file\"}}\t{{.Status}}"
     result = subprocess.run(
@@ -871,5 +1016,65 @@ def ps_command(show_all, interactive):
     )
 
 
+@cli.command("prune")
+@click.argument("path", required=False, type=click.Path(file_okay=False, resolve_path=True))
+@click.option("--all-projects", is_flag=True, help="Prune containers across all projects.")
+@click.option("--include-recent", is_flag=True, help="Also prune the most recently used container.")
+def prune_command(path, all_projects, include_recent):
+    """Remove stopped containers."""
+    if not path and not all_projects:
+        click.echo(
+            "error: specify a project path or use --all-projects to prune across all projects",
+            err=True,
+        )
+        sys.exit(1)
+
+    fmt = "{{.CreatedAt}}\t{{.ID}}\t{{.Label \"devcontainer.local_folder\"}}\t{{.Label \"devcontainer.config_file\"}}\t{{.Status}}"
+    filter_args = ["--filter", "label=devcontainer.local_folder"]
+    if path:
+        label_value = wsl_to_windows(path) if is_wsl() else path
+        filter_args = ["--filter", f"label=devcontainer.local_folder={label_value}"]
+
+    result = subprocess.run(
+        ["docker", "container", "ls", "-a"] + filter_args + ["--format", fmt],
+        capture_output=True, text=True,
+    )
+    if result.returncode != 0:
+        logger.error("docker ls failed — is Docker running?")
+        sys.exit(1)
+
+    rows = [line.split("\t") for line in result.stdout.splitlines() if line.strip()]
+    stopped = [r for r in rows if len(r) >= 5 and not r[4].startswith("Up")]
+
+    if not stopped:
+        click.echo("no stopped containers to prune")
+        return
+
+    # Sort ascending by CreatedAt; keep the last (most recent) unless --include-recent
+    stopped.sort(key=lambda r: r[0])
+    to_prune = stopped if include_recent else stopped[:-1]
+
+    if not to_prune:
+        click.echo("no containers to prune (use --include-recent to also prune the most recent)")
+        return
+
+    click.echo(f"Containers to remove ({len(to_prune)}):")
+    for r in to_prune:
+        cid, folder = r[1][:12], r[2]
+        click.echo(f"  {cid}  {folder}")
+
+    if not click.confirm(f"\nRemove {len(to_prune)} container(s)?", default=False):
+        click.echo("aborted")
+        return
+
+    for r in to_prune:
+        cid = r[1]
+        rm_result = subprocess.run(["docker", "rm", cid], capture_output=True, text=True)
+        if rm_result.returncode != 0:
+            logger.warning("failed to remove %s: %s", cid[:12], rm_result.stderr.strip())
+        else:
+            click.echo(f"removed {cid[:12]}")
+
+
 if __name__ == "__main__":
     cli()
diff --git a/tests/test_dev_code.py b/tests/test_dev_code.py
index 2fe0320..f2a6450 100644
--- a/tests/test_dev_code.py
+++ b/tests/test_dev_code.py
@@ -1,9 +1,8 @@
 import importlib.util
-import io
 import json
+import logging
 import os
 import shutil
-import subprocess
 import sys
 import tempfile
 import unittest
@@ -27,7 +26,7 @@ def test_existing_helpers_present(self):
         assert callable(devcode.wsl_to_windows)
         assert callable(devcode.build_devcontainer_uri)
         assert callable(devcode.resolve_template_search_path)
-        assert callable(devcode._write_template_dir)
+        assert callable(devcode._resolve_write_target)
         assert callable(devcode.resolve_template)
 
     def test_banner_is_string(self):
@@ -229,7 +228,9 @@ def fake_popen(cmd, **kw):
         uri = launched[0][2]
         hex_part = uri.split("vscode-remote://dev-container+")[1].split("/")[0]
         decoded = bytes.fromhex(hex_part).decode("utf-8")
-        self.assertIn(real_dir, decoded)
+        # decoded is raw JSON — backslashes are doubled on Windows
+        expected = os.path.realpath(real_dir).replace("\\", "\\\\")
+        self.assertIn(expected, decoded)
         self.assertNotIn(link_dir, decoded)
 
     def test_uses_explicit_template(self):
@@ -335,10 +336,35 @@ def test_invalid_json_returns_defaults(self):
         self.assertEqual(settings["default_template"], "dev-code")
 
 
+class TestSaveSettings(unittest.TestCase):
+    def test_writes_json_to_settings_path(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            with patch.object(devcode, "_conf_dir", return_value=tmpdir):
+                devcode._save_settings({"foo": "bar"})
+            path = os.path.join(tmpdir, "settings.json")
+            self.assertTrue(os.path.exists(path))
+            with open(path) as f:
+                data = json.load(f)
+            self.assertEqual(data, {"foo": "bar"})
+
+    def test_creates_conf_dir_if_missing(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            nested = os.path.join(tmpdir, "deep", "dir")
+            with patch.object(devcode, "_conf_dir", return_value=nested):
+                devcode._save_settings({})
+            self.assertTrue(os.path.exists(os.path.join(nested, "settings.json")))
+
+    def test_exits_on_write_failure(self):
+        with patch.object(devcode, "_conf_dir", return_value="/no/such/path"):
+            with patch("os.makedirs", side_effect=OSError("denied")):
+                with self.assertRaises(SystemExit):
+                    devcode._save_settings({"x": 1})
+
+
 class TestResolveTemplateSearchPath(unittest.TestCase):
     def test_uses_template_sources_from_settings(self):
         with patch.object(devcode, "_load_settings", return_value={"template_sources": ["/a", "/b"]}):
-            self.assertEqual(devcode.resolve_template_search_path(), ["/a", "/b"])
+            self.assertEqual(devcode.resolve_template_search_path(), [os.path.realpath("/a"), os.path.realpath("/b")])
 
     def test_expands_tilde_in_sources(self):
         with patch.object(devcode, "_load_settings", return_value={"template_sources": ["~/templates"]}):
@@ -352,15 +378,76 @@ def test_falls_back_to_xdg_data_home_when_no_sources(self):
         with patch.object(devcode, "_load_settings", return_value={}):
             with patch.dict(os.environ, env, clear=True):
                 result = devcode.resolve_template_search_path()
-        self.assertEqual(result, [os.path.join("/xdg/data", "dev-code", "templates")])
+        self.assertEqual(result, [os.path.realpath(os.path.join("/xdg/data", "dev-code", "templates"))])
 
     def test_skips_empty_entries(self):
         with patch.object(devcode, "_load_settings", return_value={"template_sources": ["/a", "", "/b"]}):
-            self.assertEqual(devcode.resolve_template_search_path(), ["/a", "/b"])
+            self.assertEqual(devcode.resolve_template_search_path(), [os.path.realpath("/a"), os.path.realpath("/b")])
+
+
+
+class TestResolveWriteTarget(unittest.TestCase):
+    def test_path_override_wins(self):
+        """--path overrides everything."""
+        with tempfile.TemporaryDirectory() as d:
+            result = devcode._resolve_write_target(path_override=d)
+            self.assertEqual(result, os.path.realpath(d))
+
+    def test_path_override_expands_dot(self):
+        """--path . resolves to cwd."""
+        result = devcode._resolve_write_target(path_override=".")
+        self.assertEqual(result, os.path.realpath("."))
+
+    def test_path_override_expands_tilde(self):
+        result = devcode._resolve_write_target(path_override="~/foo")
+        self.assertEqual(result, os.path.realpath(os.path.expanduser("~/foo")))
+
+    def test_path_override_exits_if_existing_file(self):
+        """--path pointing to an existing file (not dir) must exit with error."""
+        with tempfile.NamedTemporaryFile() as f:
+            with self.assertRaises(SystemExit):
+                devcode._resolve_write_target(path_override=f.name)
+
+    def test_settings_write_dir_used_when_no_override(self):
+        with tempfile.TemporaryDirectory() as d:
+            with patch.object(devcode, "_load_settings", return_value={"template_write_dir": d}):
+                result = devcode._resolve_write_target()
+            self.assertEqual(result, os.path.realpath(d))
+
+    def test_settings_write_dir_expands_tilde(self):
+        home = os.path.expanduser("~")
+        with patch.object(devcode, "_load_settings", return_value={"template_write_dir": "~/mydir"}):
+            result = devcode._resolve_write_target()
+        self.assertEqual(result, os.path.realpath(os.path.join(home, "mydir")))
+
+    def test_settings_write_dir_is_file_falls_back_to_xdg(self):
+        """If template_write_dir resolves to a file, fall back to XDG."""
+        with tempfile.NamedTemporaryFile() as f:
+            with patch.object(devcode, "_load_settings", return_value={"template_write_dir": f.name}):
+                with patch.dict(os.environ, {"XDG_DATA_HOME": "/xdg"}, clear=False):
+                    result = devcode._resolve_write_target()
+            self.assertEqual(result, os.path.join("/xdg", "dev-code", "templates"))
+
+    def test_xdg_data_home_used_as_fallback(self):
+        with patch.object(devcode, "_load_settings", return_value={"template_write_dir": None}):
+            with patch.dict(os.environ, {"XDG_DATA_HOME": "/custom/xdg"}, clear=False):
+                result = devcode._resolve_write_target()
+        self.assertEqual(result, os.path.join("/custom/xdg", "dev-code", "templates"))
+
+    def test_xdg_default_when_no_env(self):
+        with patch.object(devcode, "_load_settings", return_value={"template_write_dir": None}):
+            env = {k: v for k, v in os.environ.items() if k != "XDG_DATA_HOME"}
+            with patch.dict(os.environ, env, clear=True):
+                result = devcode._resolve_write_target()
+        home = os.path.expanduser("~")
+        self.assertEqual(result, os.path.join(home, ".local", "share", "dev-code", "templates"))
 
-    def test_write_template_dir_returns_first_entry(self):
-        with patch.object(devcode, "_load_settings", return_value={"template_sources": ["/first", "/second"]}):
-            self.assertEqual(devcode._write_template_dir(), "/first")
+    def test_none_write_dir_key_absent_falls_back_to_xdg(self):
+        """Settings without template_write_dir key behaves like None."""
+        with patch.object(devcode, "_load_settings", return_value={}):
+            with patch.dict(os.environ, {"XDG_DATA_HOME": "/xdg"}, clear=False):
+                result = devcode._resolve_write_target()
+        self.assertEqual(result, os.path.join("/xdg", "dev-code", "templates"))
 
 
 class TestGetBuiltinTemplatePath(unittest.TestCase):
@@ -455,7 +542,7 @@ def test_finds_user_template(self):
             open(cfg, "w").close()
             with patch.object(devcode, "_load_settings", return_value={"template_sources": [d]}):
                 result = devcode.resolve_template("mytemplate")
-        self.assertEqual(result, cfg)
+        self.assertEqual(result, os.path.realpath(cfg))
 
     def test_exits_when_not_found(self):
         with tempfile.TemporaryDirectory() as d:
@@ -538,7 +625,7 @@ def test_ambiguity_warns_and_uses_template(self):
                             result = devcode.resolve_template(dirname)
             finally:
                 os.chdir(old_cwd)
-        self.assertEqual(result, template_cfg)
+        self.assertEqual(result, os.path.realpath(template_cfg))
         self.assertTrue(any("matches both" in line for line in cm.output))
         self.assertTrue(any("Use './" in line for line in cm.output))
 
@@ -578,7 +665,7 @@ def test_finds_template_via_search_path(self):
             open(cfg, "w").close()
             with patch.object(devcode, "_load_settings", return_value={"template_sources": [d]}):
                 result = devcode.resolve_template("mytemplate")
-        self.assertEqual(result, cfg)
+        self.assertEqual(result, os.path.realpath(cfg))
 
     def test_does_not_fall_back_to_builtin(self):
         """Built-in is no longer a fallback for resolve_template."""
@@ -601,7 +688,7 @@ def test_finds_in_second_search_dir(self):
                 open(cfg, "w").close()
                 with patch.object(devcode, "_load_settings", return_value={"template_sources": [d1, d2]}):
                     result = devcode.resolve_template("mytemplate")
-        self.assertEqual(result, cfg)
+        self.assertEqual(result, os.path.realpath(cfg))
 
 
 class TestResolveAsPath(unittest.TestCase):
@@ -1058,7 +1145,7 @@ def test_missing_source_warns_and_skips(self):
     def test_missing_target_warns_and_skips(self):
         entries = [{"source": "/home/.claude"}]
         with self.assertLogs("devcode", level="WARNING") as cm:
-            calls = self._run(entries)
+            self._run(entries)
         self.assertTrue(any("target" in line.lower() for line in cm.output))
 
     def test_override_false_skips_when_target_exists(self):
@@ -1374,7 +1461,6 @@ def fake_run(cmd, **kw):
                     with patch("os.path.exists", return_value=True):
                         with patch("os.path.isdir", return_value=False):
                             calls = []
-                            original_run = subprocess.run
                             def tracking_run(cmd, **kw):
                                 calls.append(cmd)
                                 return fake_run(cmd, **kw)
@@ -1412,7 +1498,7 @@ def fake_parse(config_file):
         with patch.object(devcode, "_load_settings", return_value={"template_sources": dirs}):
             with patch.object(devcode, "parse_devcontainer_json", side_effect=fake_parse):
                 with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                    devcode.list_command.callback(long=long)
+                    devcode.template_list_command.callback(long=long)
         return lines
 
     def test_short_lists_user_templates(self):
@@ -1465,7 +1551,7 @@ def test_long_shows_header_and_rows(self):
     def test_long_no_templates_shows_hint(self):
         with tempfile.TemporaryDirectory() as d:
             lines = self._run_list(d, long=True)
-        combined = "\n".join(str(l) for l in lines)
+        combined = "\n".join(str(line) for line in lines)
         self.assertIn("(no templates)", combined)
         self.assertNotIn("devcode init", combined)
 
@@ -1481,7 +1567,7 @@ def test_long_ignores_nonexistent_dirs(self):
     def test_no_templates_shows_empty_message(self):
         with tempfile.TemporaryDirectory() as d:
             lines = self._run_list(d)
-        combined = "\n".join(str(l) for l in lines)
+        combined = "\n".join(str(line) for line in lines)
         self.assertIn("(no templates)", combined)
         self.assertNotIn("devcode init", combined)
 
@@ -1510,9 +1596,8 @@ def test_long_empty_desc_when_no_name_field(self):
         self.assertEqual(len(lines), 2)
         data_row = lines[1]
         self.assertIn("mytemplate", data_row)
-        # PATH appears in data row; no desc value between name and path
-        template_path = os.path.join(d, "mytemplate")
-        self.assertIn(template_path, data_row)
+        # PATH column contains the temp dir name (robust against ~ abbreviation and 8.3 paths)
+        self.assertIn(os.path.basename(d), data_row)
 
     def test_long_malformed_json_shows_empty_desc(self):
         with tempfile.TemporaryDirectory() as d:
@@ -1524,8 +1609,8 @@ def test_long_malformed_json_shows_empty_desc(self):
         self.assertEqual(len(lines), 2)  # header + 1 data row
         data_row = lines[1]
         self.assertIn("broken", data_row)
-        template_path = os.path.join(d, "broken")
-        self.assertIn(template_path, data_row)
+        # PATH column contains the temp dir name (robust against ~ abbreviation and 8.3 paths)
+        self.assertIn(os.path.basename(d), data_row)
 
     def test_long_deduplication_first_match_wins(self):
         with tempfile.TemporaryDirectory() as d1:
@@ -1540,6 +1625,200 @@ def test_long_deduplication_first_match_wins(self):
         self.assertEqual(len(lines), 2)
 
 
+class TestCmdTemplateDefault(unittest.TestCase):
+    def test_no_arg_prints_current_default(self):
+        runner = CliRunner()
+        with patch.object(devcode, "_load_settings", return_value={"default_template": "my-tpl"}):
+            result = runner.invoke(devcode.cli, ["template", "default"])
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("my-tpl", result.output)
+
+    def test_no_arg_empty_default_prints_nothing(self):
+        runner = CliRunner()
+        with patch.object(devcode, "_load_settings", return_value={"default_template": ""}):
+            result = runner.invoke(devcode.cli, ["template", "default"])
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(result.output.strip(), "")
+
+    def test_with_arg_sets_default(self):
+        runner = CliRunner()
+        saved = {}
+        def fake_save(s):
+            saved.update(s)
+        with patch.object(devcode, "_load_settings", return_value={"default_template": ""}):
+            with patch.object(devcode, "_save_settings", side_effect=fake_save):
+                result = runner.invoke(devcode.cli, ["template", "default", "my-tpl"])
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(saved.get("default_template"), "my-tpl")
+
+    def test_with_arg_prints_confirmation(self):
+        runner = CliRunner()
+        with patch.object(devcode, "_load_settings", return_value={"default_template": ""}):
+            with patch.object(devcode, "_save_settings"):
+                result = runner.invoke(devcode.cli, ["template", "default", "my-tpl"])
+        self.assertIn("my-tpl", result.output)
+
+
+class TestCmdTemplateSource(unittest.TestCase):
+    def test_source_list_prints_paths(self):
+        runner = CliRunner()
+        with patch.object(devcode, "_load_settings", return_value={"template_sources": ["/a", "/b"]}):
+            result = runner.invoke(devcode.cli, ["template", "source", "list"])
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("/a", result.output)
+        self.assertIn("/b", result.output)
+
+    def test_source_list_empty_shows_nothing(self):
+        runner = CliRunner()
+        with patch.object(devcode, "_load_settings", return_value={"template_sources": []}):
+            result = runner.invoke(devcode.cli, ["template", "source", "list"])
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(result.output.strip(), "")
+
+    def test_source_add_appends_path(self):
+        runner = CliRunner()
+        saved = {}
+        with tempfile.TemporaryDirectory() as da:
+            with tempfile.TemporaryDirectory() as db:
+                a, b = os.path.abspath(da), os.path.abspath(db)
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [a]}):
+                    with patch.object(devcode, "_save_settings", side_effect=lambda s: saved.update(s)):
+                        result = runner.invoke(devcode.cli, ["template", "source", "add", b])
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn(b, saved.get("template_sources", []))
+        self.assertIn(a, saved.get("template_sources", []))
+
+    def test_source_add_expands_tilde(self):
+        runner = CliRunner()
+        saved = {}
+        home = os.path.expanduser("~")
+        with patch.object(devcode, "_load_settings", return_value={"template_sources": []}):
+            with patch.object(devcode, "_save_settings", side_effect=lambda s: saved.update(s)):
+                result = runner.invoke(devcode.cli, ["template", "source", "add", "~/mytemplates"])
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn(os.path.join(home, "mytemplates"), saved.get("template_sources", []))
+
+    def test_source_add_idempotent(self):
+        """Adding an already-present path does not duplicate it."""
+        runner = CliRunner()
+        with tempfile.TemporaryDirectory() as d:
+            a = os.path.abspath(d)
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [a]}):
+                with patch.object(devcode, "_save_settings") as mock_save:
+                    result = runner.invoke(devcode.cli, ["template", "source", "add", a])
+        self.assertEqual(result.exit_code, 0)
+        # _save_settings should not be called when path is already present
+        mock_save.assert_not_called()
+
+    def test_source_remove_removes_path(self):
+        runner = CliRunner()
+        saved = {}
+        with tempfile.TemporaryDirectory() as da:
+            with tempfile.TemporaryDirectory() as db:
+                a, b = os.path.abspath(da), os.path.abspath(db)
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [a, b]}):
+                    with patch.object(devcode, "_save_settings", side_effect=lambda s: saved.update(s)):
+                        result = runner.invoke(devcode.cli, ["template", "source", "remove", a])
+        self.assertEqual(result.exit_code, 0)
+        self.assertNotIn(a, saved.get("template_sources", []))
+        self.assertIn(b, saved.get("template_sources", []))
+
+    def test_source_remove_exits_if_not_found(self):
+        runner = CliRunner()
+        with patch.object(devcode, "_load_settings", return_value={"template_sources": ["/a"]}):
+            result = runner.invoke(devcode.cli, ["template", "source", "remove", "/no-such"])
+        self.assertNotEqual(result.exit_code, 0)
+
+
+class TestCmdPrune(unittest.TestCase):
+    def _stopped_row(self, created, cid, folder, config="/some/config"):
+        return f"{created}\t{cid}\t{folder}\t{config}\tExited (0) 2 hours ago"
+
+    def _running_row(self, created, cid, folder, config="/some/config"):
+        return f"{created}\t{cid}\t{folder}\t{config}\tUp 2 hours"
+
+    def test_no_path_and_no_all_projects_exits(self):
+        runner = CliRunner()
+        result = runner.invoke(devcode.cli, ["prune"])
+        self.assertNotEqual(result.exit_code, 0)
+        self.assertIn("--all-projects", result.output + (result.stderr or ""))
+
+    def test_no_stopped_containers_message(self):
+        runner = CliRunner()
+        mock_result = MagicMock(returncode=0, stdout="")
+        with patch("subprocess.run", return_value=mock_result):
+            result = runner.invoke(devcode.cli, ["prune", "--all-projects"])
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("no stopped containers", result.output)
+
+    def test_running_containers_not_pruned(self):
+        runner = CliRunner()
+        row = self._running_row("2026-01-01 10:00:00 +0000 UTC", "abc123", "/home/user/app")
+        mock_result = MagicMock(returncode=0, stdout=row + "\n")
+        with patch("subprocess.run", return_value=mock_result):
+            result = runner.invoke(devcode.cli, ["prune", "--all-projects"])
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("no stopped containers", result.output)
+
+    def test_keeps_most_recent_by_default(self):
+        """With two stopped containers, the more recent one is kept."""
+        runner = CliRunner()
+        row_old = self._stopped_row("2026-01-01 10:00:00 +0000 UTC", "old111", "/home/user/app")
+        row_new = self._stopped_row("2026-01-02 10:00:00 +0000 UTC", "new222", "/home/user/app")
+        mock_list = MagicMock(returncode=0, stdout=row_old + "\n" + row_new + "\n")
+        mock_rm = MagicMock(returncode=0, stdout="")
+        removed = []
+        def fake_run(cmd, **kwargs):
+            if cmd[0] == "docker" and cmd[1] == "rm":
+                removed.append(cmd[2])
+                return mock_rm
+            return mock_list
+        with patch("subprocess.run", side_effect=fake_run):
+            runner.invoke(devcode.cli, ["prune", "--all-projects"], input="y\n")
+        self.assertIn("old111", removed)
+        self.assertNotIn("new222", removed)
+
+    def test_include_recent_prunes_all(self):
+        runner = CliRunner()
+        row_old = self._stopped_row("2026-01-01 10:00:00 +0000 UTC", "old111", "/home/user/app")
+        row_new = self._stopped_row("2026-01-02 10:00:00 +0000 UTC", "new222", "/home/user/app")
+        mock_list = MagicMock(returncode=0, stdout=row_old + "\n" + row_new + "\n")
+        mock_rm = MagicMock(returncode=0, stdout="")
+        removed = []
+        def fake_run(cmd, **kwargs):
+            if cmd[0] == "docker" and cmd[1] == "rm":
+                removed.append(cmd[2])
+                return mock_rm
+            return mock_list
+        with patch("subprocess.run", side_effect=fake_run):
+            runner.invoke(devcode.cli, ["prune", "--all-projects", "--include-recent"], input="y\n")
+        self.assertIn("old111", removed)
+        self.assertIn("new222", removed)
+
+    def test_user_declines_confirmation(self):
+        runner = CliRunner()
+        row_old = self._stopped_row("2026-01-01 10:00:00 +0000 UTC", "old111", "/home/user/app")
+        row_new = self._stopped_row("2026-01-02 10:00:00 +0000 UTC", "new222", "/home/user/app")
+        mock_list = MagicMock(returncode=0, stdout=row_old + "\n" + row_new + "\n")
+        removed = []
+        def fake_run(cmd, **kwargs):
+            if cmd[0] == "docker" and cmd[1] == "rm":
+                removed.append(cmd[2])
+            return mock_list
+        with patch("subprocess.run", side_effect=fake_run):
+            result = runner.invoke(devcode.cli, ["prune", "--all-projects"], input="N\n")
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(removed, [])
+        self.assertIn("aborted", result.output)
+
+    def test_docker_failure_exits(self):
+        runner = CliRunner()
+        mock_result = MagicMock(returncode=1, stdout="")
+        with patch("subprocess.run", return_value=mock_result):
+            result = runner.invoke(devcode.cli, ["prune", "--all-projects"])
+        self.assertNotEqual(result.exit_code, 0)
+
+
 class TestCmdNew(unittest.TestCase):
     def _setup_pkg(self, pkg_dir):
         """Create a fake dev-code built-in in pkg_dir."""
@@ -1551,9 +1830,9 @@ def test_creates_template_from_default_base_legacy_env(self):
         with tempfile.TemporaryDirectory() as pkg_dir:
             self._setup_pkg(pkg_dir)
             with tempfile.TemporaryDirectory() as user_dir:
-                with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir], "template_write_dir": user_dir}):
                     with patch.object(devcode, "__file__", os.path.join(pkg_dir, "devcode.py")):
-                        devcode.new_command.callback(name="myapp", base=None, edit=False)
+                        devcode.new_command.callback(name="myapp", base=None, edit=False, write_path=None)
                 self.assertTrue(os.path.isdir(os.path.join(user_dir, "myapp")))
 
     def test_creates_template_from_explicit_base(self):
@@ -1563,57 +1842,144 @@ def test_creates_template_from_explicit_base(self):
             os.makedirs(base_path)
             open(os.path.join(base_path, "devcontainer.json"), "w").close()
 
-            with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
-                devcode.new_command.callback(name="myapp", base="mybase", edit=False)
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir], "template_write_dir": user_dir}):
+                devcode.new_command.callback(name="myapp", base="mybase", edit=False, write_path=None)
             self.assertTrue(os.path.isdir(os.path.join(user_dir, "myapp")))
 
     def test_exits_if_name_already_exists(self):
         with tempfile.TemporaryDirectory() as user_dir:
             existing = os.path.join(user_dir, "myapp")
             os.makedirs(existing)
-            with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir], "template_write_dir": user_dir}):
                 with self.assertRaises(SystemExit):
-                    devcode.new_command.callback(name="myapp", base=None, edit=False)
+                    devcode.new_command.callback(name="myapp", base=None, edit=False, write_path=None)
 
     def test_exits_if_base_not_found(self):
         with tempfile.TemporaryDirectory() as pkg_dir:
             with tempfile.TemporaryDirectory() as user_dir:
-                with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir], "template_write_dir": user_dir}):
                     with patch.object(devcode, "__file__", os.path.join(pkg_dir, "devcode.py")):
                         with self.assertRaises(SystemExit):
-                            devcode.new_command.callback(name="myapp", base="no-such-base", edit=False)
+                            devcode.new_command.callback(name="myapp", base="no-such-base", edit=False, write_path=None)
 
     def test_edit_flag_calls_do_open(self):
         with tempfile.TemporaryDirectory() as pkg_dir:
             self._setup_pkg(pkg_dir)
             with tempfile.TemporaryDirectory() as user_dir:
-                with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir], "template_write_dir": user_dir}):
                     with patch.object(devcode, "__file__", os.path.join(pkg_dir, "devcode.py")):
                         with patch.object(devcode, "_do_open") as mock_open:
-                            devcode.new_command.callback(name="myapp", base=None, edit=True)
+                            devcode.new_command.callback(name="myapp", base=None, edit=True, write_path=None)
                 mock_open.assert_called_once()
                 self.assertEqual(mock_open.call_args.kwargs["template"], "myapp")
-                self.assertEqual(mock_open.call_args.kwargs["projectpath"], os.path.join(user_dir, "myapp"))
+                self.assertEqual(mock_open.call_args.kwargs["projectpath"], os.path.realpath(os.path.join(user_dir, "myapp")))
 
     def test_creates_template_from_default_base(self):
         with tempfile.TemporaryDirectory() as pkg_dir:
             self._setup_pkg(pkg_dir)
             with tempfile.TemporaryDirectory() as user_dir:
-                with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir], "template_write_dir": user_dir}):
                     with patch.object(devcode, "__file__", os.path.join(pkg_dir, "devcode.py")):
-                        devcode.new_command.callback(name="myapp", base=None, edit=False)
+                        devcode.new_command.callback(name="myapp", base=None, edit=False, write_path=None)
                 self.assertTrue(os.path.isdir(os.path.join(user_dir, "myapp")))
 
     def test_base_found_in_second_search_dir(self):
         with tempfile.TemporaryDirectory() as d1:
             with tempfile.TemporaryDirectory() as d2:
-                base = os.path.join(d2, "mybase", ".devcontainer")
-                os.makedirs(base)
-                open(os.path.join(base, "devcontainer.json"), "w").close()
-                with patch.object(devcode, "_load_settings", return_value={"template_sources": [d1, d2]}):
-                    devcode.new_command.callback(name="myapp", base="mybase", edit=False)
-                # writes to first dir
-                self.assertTrue(os.path.isdir(os.path.join(d1, "myapp")))
+                with tempfile.TemporaryDirectory() as write_dir:
+                    base = os.path.join(d2, "mybase", ".devcontainer")
+                    os.makedirs(base)
+                    open(os.path.join(base, "devcontainer.json"), "w").close()
+                    with patch.object(devcode, "_load_settings", return_value={
+                        "template_sources": [d1, d2],
+                        "template_write_dir": write_dir,
+                    }):
+                        devcode.new_command.callback(name="myapp", base="mybase", edit=False, write_path=None)
+                    # writes to template_write_dir, not to first source
+                    self.assertTrue(os.path.isdir(os.path.join(write_dir, "myapp")))
+                    self.assertFalse(os.path.isdir(os.path.join(d1, "myapp")))
+
+    def test_path_flag_overrides_write_dir(self):
+        """--path writes the template to the given directory."""
+        with tempfile.TemporaryDirectory() as pkg_dir:
+            self._setup_pkg(pkg_dir)
+            with tempfile.TemporaryDirectory() as default_dir:
+                with tempfile.TemporaryDirectory() as override_dir:
+                    with patch.object(devcode, "_load_settings", return_value={
+                        "template_sources": [default_dir, override_dir],
+                        "template_write_dir": default_dir,
+                    }):
+                        with patch.object(devcode, "__file__", os.path.join(pkg_dir, "devcode.py")):
+                            devcode.new_command.callback(name="myapp", base=None, edit=False, write_path=override_dir)
+                    self.assertTrue(os.path.isdir(os.path.join(override_dir, "myapp")))
+                    self.assertFalse(os.path.isdir(os.path.join(default_dir, "myapp")))
+
+    def test_warns_when_write_dir_not_in_sources(self):
+        """A warning is emitted if the write dir is not in template_sources."""
+        with tempfile.TemporaryDirectory() as pkg_dir:
+            self._setup_pkg(pkg_dir)
+            with tempfile.TemporaryDirectory() as sources_dir:
+                with tempfile.TemporaryDirectory() as write_dir:
+                    with patch.object(devcode, "_load_settings", return_value={
+                        "template_sources": [sources_dir],
+                        "template_write_dir": write_dir,
+                    }):
+                        with patch.object(devcode, "__file__", os.path.join(pkg_dir, "devcode.py")):
+                            with self.assertLogs("devcode", level="WARNING") as cm:
+                                devcode.new_command.callback(name="myapp", base=None, edit=False, write_path=None)
+                    self.assertTrue(any("not in template_sources" in line for line in cm.output))
+
+    def test_no_warning_when_write_dir_in_sources(self):
+        """No warning when write dir is one of the template_sources."""
+        with tempfile.TemporaryDirectory() as pkg_dir:
+            self._setup_pkg(pkg_dir)
+            with tempfile.TemporaryDirectory() as user_dir:
+                with patch.object(devcode, "_load_settings", return_value={
+                    "template_sources": [user_dir],
+                    "template_write_dir": user_dir,
+                }):
+                    with patch.object(devcode, "__file__", os.path.join(pkg_dir, "devcode.py")):
+                        with self.assertLogs("devcode", level="WARNING") as cm:
+                            logging.getLogger("devcode").warning("sentinel")
+                            devcode.new_command.callback(name="myapp", base=None, edit=False, write_path=None)
+                        # Only the sentinel warning — none from new_command
+                        self.assertFalse(any("not in template_sources" in line for line in cm.output))
+
+    def test_path_dot_writes_to_cwd(self):
+        """--path . resolves to cwd."""
+        with tempfile.TemporaryDirectory() as pkg_dir:
+            self._setup_pkg(pkg_dir)
+            with tempfile.TemporaryDirectory() as cwd:
+                orig = os.getcwd()
+                os.chdir(cwd)
+                try:
+                    with patch.object(devcode, "_load_settings", return_value={
+                        "template_sources": [],
+                        "template_write_dir": None,
+                    }):
+                        with patch.object(devcode, "__file__", os.path.join(pkg_dir, "devcode.py")):
+                            with self.assertLogs("devcode", level="WARNING"):
+                                devcode.new_command.callback(name="myapp", base=None, edit=False, write_path=".")
+                    self.assertTrue(os.path.isdir(os.path.join(cwd, "myapp")))
+                finally:
+                    os.chdir(orig)
+
+    def test_path_flag_warns_when_not_in_sources(self):
+        """--path pointing outside template_sources still triggers the warning."""
+        with tempfile.TemporaryDirectory() as pkg_dir:
+            self._setup_pkg(pkg_dir)
+            with tempfile.TemporaryDirectory() as sources_dir:
+                with tempfile.TemporaryDirectory() as override_dir:
+                    with patch.object(devcode, "_load_settings", return_value={
+                        "template_sources": [sources_dir],
+                        "template_write_dir": sources_dir,
+                    }):
+                        with patch.object(devcode, "__file__", os.path.join(pkg_dir, "devcode.py")):
+                            with self.assertLogs("devcode", level="WARNING") as cm:
+                                devcode.new_command.callback(
+                                    name="myapp", base=None, edit=False, write_path=override_dir
+                                )
+                    self.assertTrue(any("not in template_sources" in line for line in cm.output))
 
 
 class TestCmdEdit(unittest.TestCase):
@@ -1630,7 +1996,7 @@ def test_named_template_opens_root_in_code(self):
             with patch.object(devcode, "_load_settings", return_value={"template_sources": [d]}):
                 with patch("subprocess.run") as mock_run:
                     devcode.edit_command.callback(template="mytemplate")
-            mock_run.assert_called_once_with(["code", root])
+            mock_run.assert_called_once_with(["code", os.path.realpath(root)])
 
     def test_named_template_found_in_second_dir(self):
         with tempfile.TemporaryDirectory() as d1:
@@ -1639,7 +2005,7 @@ def test_named_template_found_in_second_dir(self):
                 with patch.object(devcode, "_load_settings", return_value={"template_sources": [d1, d2]}):
                     with patch("subprocess.run") as mock_run:
                         devcode.edit_command.callback(template="mytemplate")
-                mock_run.assert_called_once_with(["code", root])
+                mock_run.assert_called_once_with(["code", os.path.realpath(root)])
 
     def test_named_template_not_found_exits(self):
         with tempfile.TemporaryDirectory() as d:
@@ -1650,7 +2016,7 @@ def test_named_template_not_found_exits(self):
     def test_no_arg_is_missing_argument_error(self):
         """edit requires a template argument; omitting it should exit non-zero."""
         runner = CliRunner()
-        result = runner.invoke(devcode.cli, ["edit"])
+        result = runner.invoke(devcode.cli, ["template", "edit"])
         self.assertNotEqual(result.exit_code, 0)
 
     def test_does_not_call_do_open(self):
@@ -1688,7 +2054,7 @@ def test_lists_containers(self):
         lines = []
         with patch("subprocess.run", return_value=mock_result):
             with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                devcode.ps_command.callback(show_all=False, interactive=False)
+                devcode.list_command.callback(show_all=False, interactive=False)
         combined = "\n".join(lines)
         self.assertIn("claude", combined)
         self.assertIn("abc123def456", combined)
@@ -1700,14 +2066,14 @@ def test_no_containers_message(self):
         lines = []
         with patch("subprocess.run", return_value=mock_result):
             with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                devcode.ps_command.callback(show_all=False, interactive=False)
-        self.assertTrue(any("no running devcontainers" in str(l) for l in lines))
+                devcode.list_command.callback(show_all=False, interactive=False)
+        self.assertTrue(any("no running devcontainers" in str(line) for line in lines))
 
     def test_docker_unavailable_exits(self):
         mock_result = MagicMock(returncode=1, stdout="")
         with patch("subprocess.run", return_value=mock_result):
             with self.assertRaises(SystemExit):
-                devcode.ps_command.callback(show_all=False, interactive=False)
+                devcode.list_command.callback(show_all=False, interactive=False)
 
     def test_malformed_row_skipped(self):
         # A row with fewer than 4 fields after dropping CreatedAt should be skipped silently
@@ -1718,7 +2084,7 @@ def test_malformed_row_skipped(self):
         lines = []
         with patch("subprocess.run", return_value=mock_result):
             with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                devcode.ps_command.callback(show_all=False, interactive=False)  # must not raise
+                devcode.list_command.callback(show_all=False, interactive=False)  # must not raise
         combined = "\n".join(lines)
         self.assertIn("bbb222", combined)  # good row shown
         self.assertNotIn("abc123", combined)  # malformed row skipped
@@ -1736,7 +2102,7 @@ def test_all_flag_includes_stopped(self):
         lines = []
         with patch("subprocess.run", return_value=mock_result):
             with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                devcode.ps_command.callback(show_all=True, interactive=False)
+                devcode.list_command.callback(show_all=True, interactive=False)
         combined = "\n".join(lines)
         self.assertIn("aaa111", combined)   # stopped container included
         self.assertIn("bbb222", combined)   # running container included
@@ -1754,7 +2120,7 @@ def test_no_all_flag_excludes_stopped(self):
         lines = []
         with patch("subprocess.run", return_value=mock_result):
             with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                devcode.ps_command.callback(show_all=False, interactive=False)
+                devcode.list_command.callback(show_all=False, interactive=False)
         combined = "\n".join(lines)
         self.assertNotIn("aaa111", combined)   # stopped excluded
         self.assertIn("bbb222", combined)      # running shown
@@ -1764,8 +2130,8 @@ def test_all_flag_empty_message(self):
         lines = []
         with patch("subprocess.run", return_value=mock_result):
             with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                devcode.ps_command.callback(show_all=True, interactive=False)
-        self.assertTrue(any("no devcontainers" in str(l) and "running" not in str(l) for l in lines))
+                devcode.list_command.callback(show_all=True, interactive=False)
+        self.assertTrue(any("no devcontainers" in str(line) and "running" not in str(line) for line in lines))
 
     def test_interactive_valid_selection_opens_container(self):
         rows = [
@@ -1781,7 +2147,7 @@ def test_interactive_valid_selection_opens_container(self):
         with patch("subprocess.run", side_effect=[ls_result, inspect_result]):
             with patch("builtins.input", return_value="1"):
                 with patch("devcode._do_open") as mock_open:
-                    devcode.ps_command.callback(show_all=False, interactive=True)
+                    devcode.list_command.callback(show_all=False, interactive=True)
         mock_open.assert_called_once_with(
             projectpath="/home/user/myapp",
             template="/home/user/.local/share/dev-code/templates/python/.devcontainer/devcontainer.json",
@@ -1805,7 +2171,7 @@ def test_interactive_mount_fallback(self):
         with patch("subprocess.run", side_effect=[ls_result, inspect_result]):
             with patch("builtins.input", return_value="1"):
                 with patch("devcode._do_open") as mock_open:
-                    devcode.ps_command.callback(show_all=False, interactive=True)
+                    devcode.list_command.callback(show_all=False, interactive=True)
         self.assertIsNone(mock_open.call_args.kwargs["container_folder"])
 
     def test_interactive_invalid_selection_exits(self):
@@ -1818,7 +2184,7 @@ def test_interactive_invalid_selection_exits(self):
         with patch("subprocess.run", return_value=ls_result):
             with patch("builtins.input", return_value="99"):
                 with self.assertRaises(SystemExit):
-                    devcode.ps_command.callback(show_all=False, interactive=True)
+                    devcode.list_command.callback(show_all=False, interactive=True)
 
     def test_interactive_non_integer_exits(self):
         rows = [
@@ -1830,7 +2196,7 @@ def test_interactive_non_integer_exits(self):
         with patch("subprocess.run", return_value=ls_result):
             with patch("builtins.input", return_value="abc"):
                 with self.assertRaises(SystemExit):
-                    devcode.ps_command.callback(show_all=False, interactive=True)
+                    devcode.list_command.callback(show_all=False, interactive=True)
 
     def test_interactive_missing_config_label_exits(self):
         rows = [
@@ -1842,14 +2208,14 @@ def test_interactive_missing_config_label_exits(self):
         with patch("subprocess.run", return_value=ls_result):
             with patch("builtins.input", return_value="1"):
                 with self.assertRaises(SystemExit):
-                    devcode.ps_command.callback(show_all=False, interactive=True)
+                    devcode.list_command.callback(show_all=False, interactive=True)
 
     def test_interactive_empty_table_no_prompt(self):
         ls_result = MagicMock(returncode=0, stdout="")
         prompted = []
         with patch("subprocess.run", return_value=ls_result):
             with patch("builtins.input", side_effect=lambda _: prompted.append(True) or "1"):
-                devcode.ps_command.callback(show_all=False, interactive=True)
+                devcode.list_command.callback(show_all=False, interactive=True)
         self.assertEqual(prompted, [])   # input() was never called
 
     def test_interactive_all_with_malformed_row_correct_selection(self):
@@ -1862,7 +2228,7 @@ def test_interactive_all_with_malformed_row_correct_selection(self):
         with patch("subprocess.run", side_effect=[ls_result, inspect_result]):
             with patch("builtins.input", return_value="1"):
                 with patch("devcode._do_open") as mock_open:
-                    devcode.ps_command.callback(show_all=True, interactive=True)
+                    devcode.list_command.callback(show_all=True, interactive=True)
         mock_open.assert_called_once()
         self.assertEqual(mock_open.call_args.kwargs["projectpath"], "/home/user/myapp")
 
@@ -1880,13 +2246,13 @@ def test_sort_ascending_by_created_at(self):
         lines = []
         with patch("subprocess.run", return_value=mock_result):
             with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                devcode.ps_command.callback(show_all=False, interactive=False)
+                devcode.list_command.callback(show_all=False, interactive=False)
         # Find data rows (skip header)
-        data_rows = [l for l in lines if "older222" in l or "newer111" in l]
+        data_rows = [line for line in lines if "older222" in line or "newer111" in line]
         self.assertEqual(len(data_rows), 2)
         # older222 must appear before newer111
-        idx_older = next(i for i, l in enumerate(lines) if "older222" in l)
-        idx_newer = next(i for i, l in enumerate(lines) if "newer111" in l)
+        idx_older = next(i for i, line in enumerate(lines) if "older222" in line)
+        idx_newer = next(i for i, line in enumerate(lines) if "newer111" in line)
         self.assertLess(idx_older, idx_newer)
         # older222 must be row #1
         self.assertIn("1", lines[idx_older])
@@ -2003,6 +2369,32 @@ def test_help_contains_tagline(self):
         self.assertIn("project · editor · container", result.output)
 
 
+class TestBannerInHelp(unittest.TestCase):
+    def test_help_shows_ascii_art(self):
+        """Full ASCII banner must appear in --help output."""
+        runner = CliRunner()
+        result = runner.invoke(devcode.cli, ["--help"])
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("__| | _____", result.output)
+
+    def test_banner_has_trailing_newline(self):
+        """BANNER must end with a newline for bottom padding."""
+        self.assertTrue(devcode.BANNER.endswith("\n"))
+
+    def test_help_description_is_not_tagline(self):
+        """The old tagline docstring must be replaced with a proper description."""
+        runner = CliRunner()
+        result = runner.invoke(devcode.cli, ["--help"])
+        self.assertIn("Open projects in VS Code Dev Containers", result.output)
+
+    def test_no_args_shows_banner(self):
+        """Banner must appear when devcode is run with no arguments."""
+        runner = CliRunner()
+        result = runner.invoke(devcode.cli, [])
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("__| | _____", result.output)
+
+
 class TestListTemplateNames(unittest.TestCase):
     def _make_template(self, base_dir, name):
         p = os.path.join(base_dir, name, ".devcontainer")
@@ -2093,7 +2485,7 @@ def test_open_dry_run(self):
     def test_list_command(self):
         runner = CliRunner()
         with patch.object(devcode, "_list_template_names", return_value=["tmpl-a", "tmpl-b"]):
-            result = runner.invoke(devcode.cli, ["list"])
+            result = runner.invoke(devcode.cli, ["template", "list"])
         self.assertEqual(result.exit_code, 0)
         self.assertIn("tmpl-a", result.output)
         self.assertIn("tmpl-b", result.output)
@@ -2103,16 +2495,50 @@ def test_new_command_unknown_base_exits(self):
         with runner.isolated_filesystem():
             with patch.object(devcode, "_load_settings",
                                return_value={"template_sources": [os.path.abspath(".")]}):
-                result = runner.invoke(devcode.cli, ["new", "myapp", "no-such-base"])
+                result = runner.invoke(devcode.cli, ["template", "new", "myapp", "no-such-base"])
         self.assertNotEqual(result.exit_code, 0)
 
-    def test_ps_no_docker_exits(self):
+    def test_list_no_docker_exits(self):
         runner = CliRunner()
         with patch("subprocess.run", return_value=MagicMock(returncode=1, stdout="")):
-            result = runner.invoke(devcode.cli, ["ps"])
+            result = runner.invoke(devcode.cli, ["list"])
         self.assertNotEqual(result.exit_code, 0)
 
 
+class TestCLIV2Structure(unittest.TestCase):
+    def test_template_group_exists(self):
+        self.assertIn("template", devcode.cli.commands)
+
+    def test_source_group_exists_under_template(self):
+        template_cmd = devcode.cli.commands["template"]
+        self.assertIn("source", template_cmd.commands)
+
+    def test_template_list_exists(self):
+        self.assertIn("list", devcode.cli.commands["template"].commands)
+
+    def test_open_at_top_level(self):
+        self.assertIn("open", devcode.cli.commands)
+
+    def test_ps_no_longer_exists(self):
+        self.assertNotIn("ps", devcode.cli.commands)
+
+    def test_list_at_top_level_is_containers(self):
+        """Top-level 'list' must exist (container listing, replaces ps)."""
+        self.assertIn("list", devcode.cli.commands)
+
+    def test_template_new_exists(self):
+        self.assertIn("new", devcode.cli.commands["template"].commands)
+
+    def test_new_not_at_top_level(self):
+        self.assertNotIn("new", devcode.cli.commands)
+
+    def test_template_edit_exists(self):
+        self.assertIn("edit", devcode.cli.commands["template"].commands)
+
+    def test_edit_not_at_top_level(self):
+        self.assertNotIn("edit", devcode.cli.commands)
+
+
 class TestCompleteTemplates(unittest.TestCase):
     def test_returns_all_when_incomplete_is_empty(self):
         with patch.object(devcode, "_list_template_names", return_value=["alpha", "beta", "gamma"]):
@@ -2142,6 +2568,33 @@ def test_code_on_path_by_default(self):
         self.assertIsNotNone(shutil.which("code"))
 
 
+class TestShellCompletion(unittest.TestCase):
+    def test_open_projectpath_is_path_type(self):
+        """open's projectpath must use click.Path() so shells offer filesystem completion."""
+        import click
+        open_cmd = devcode.cli.commands["open"]
+        param = next(p for p in open_cmd.params if p.name == "projectpath")
+        self.assertIsInstance(param.type, click.Path)
+
+    def test_new_base_has_template_completion(self):
+        """new's base argument must have _complete_templates as its shell_complete callback."""
+        new_cmd = devcode.cli.commands["template"].commands["new"]
+        param = next(p for p in new_cmd.params if p.name == "base")
+        self.assertIs(param._custom_shell_complete, devcode._complete_templates)
+
+    def test_open_template_has_template_completion(self):
+        """open's template argument must use _complete_templates for shell completion."""
+        open_cmd = devcode.cli.commands["open"]
+        param = next(p for p in open_cmd.params if p.name == "template")
+        self.assertIs(param._custom_shell_complete, devcode._complete_templates)
+
+    def test_edit_template_has_template_completion(self):
+        """edit's template argument must use _complete_templates for shell completion."""
+        edit_cmd = devcode.cli.commands["template"].commands["edit"]
+        param = next(p for p in edit_cmd.params if p.name == "template")
+        self.assertIs(param._custom_shell_complete, devcode._complete_templates)
+
+
 class TestStartupCheck(unittest.TestCase):
     def test_exits_if_devcontainer_not_on_path(self):
         runner = CliRunner()
@@ -2154,3 +2607,36 @@ def test_error_message_when_devcontainer_missing(self):
         with patch("shutil.which", side_effect=lambda x: None if x == "devcontainer" else "/usr/bin/code"):
             result = runner.invoke(devcode.cli, ["open", "/myproject", "claude"])
         self.assertIn("devcontainer CLI not found on PATH", result.stderr)
+
+    def test_load_settings_called_on_every_invocation(self):
+        """_load_settings() must run even when only --help is passed."""
+        runner = CliRunner()
+        with patch.object(devcode, "_load_settings", return_value={}) as mock_settings:
+            runner.invoke(devcode.cli, ["--help"])
+        mock_settings.assert_called_once()
+
+
+class TestCompletionCommand(unittest.TestCase):
+    def test_bash_output(self):
+        runner = CliRunner()
+        result = runner.invoke(devcode.cli, ["completion", "bash"])
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(result.output.strip(), 'eval "$(_DEVCODE_COMPLETE=bash_source devcode)"')
+
+    def test_zsh_output(self):
+        runner = CliRunner()
+        result = runner.invoke(devcode.cli, ["completion", "zsh"])
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(result.output.strip(), 'eval "$(_DEVCODE_COMPLETE=zsh_source devcode)"')
+
+    def test_fish_output(self):
+        runner = CliRunner()
+        result = runner.invoke(devcode.cli, ["completion", "fish"])
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(result.output.strip(), "eval (env _DEVCODE_COMPLETE=fish_source devcode)")
+
+    def test_invalid_shell_exits_nonzero(self):
+        runner = CliRunner()
+        result = runner.invoke(devcode.cli, ["completion", "powershell"])
+        self.assertNotEqual(result.exit_code, 0)
+        self.assertIn("Invalid value", result.output)