diff --git a/packages/create-awesome-python-app/src/create_awesome_python_app/cache.py b/packages/create-awesome-python-app/src/create_awesome_python_app/cache.py
new file mode 100644
index 0000000..bc4b35e
--- /dev/null
+++ b/packages/create-awesome-python-app/src/create_awesome_python_app/cache.py
@@ -0,0 +1,405 @@
+"""Local template/extension cache management (CNA cache.ts parity)."""
+
+from __future__ import annotations
+
+import contextlib
+import shutil
+import subprocess
+import time
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from create_python_app_core.git_cache import (
+    CacheMeta,
+    read_cache_meta,
+    write_cache_meta,
+)
+from create_python_app_core.paths import default_cache_dir
+
+from create_awesome_python_app.catalog import catalog_url
+
+
+@dataclass
+class CacheEntry:
+    id: str
+    path: Path
+    url: str | None = None
+    ref: str | None = None
+    fetched_at: float | None = None
+    commit: str | None = None
+    size_bytes: int = 0
+    fsck_ok: bool | None = None
+
+
+@dataclass
+class RemoteTipResult:
+    id: str
+    behind: bool
+    url: str | None = None
+    ref: str | None = None
+    local_sha: str | None = None
+    remote_sha: str | None = None
+    error: str | None = None
+
+
+@dataclass
+class DoctorResult:
+    check: str
+    ok: bool
+    detail: str = ""
+
+
+@dataclass
+class CleanResult:
+    removed: list[str]
+    not_found: list[str]
+
+
+def repos_root(cache_root: Path | None = None) -> Path:
+    return (cache_root or default_cache_dir()) / "repos"
+
+
+def _dir_size(path: Path) -> int:
+    total = 0
+    stack = [path]
+    while stack:
+        current = stack.pop()
+        try:
+            for child in current.iterdir():
+                if child.is_dir():
+                    stack.append(child)
+                elif child.is_file():
+                    with contextlib.suppress(OSError):
+                        total += child.stat().st_size
+        except OSError:
+            continue
+    return total
+
+
+def _run_git(
+    args: list[str],
+    *,
+    cwd: Path | None = None,
+    check: bool = True,
+    timeout: float | None = None,
+) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        ["git", *args],
+        cwd=str(cwd) if cwd else None,
+        check=check,
+        capture_output=True,
+        text=True,
+        timeout=timeout,
+    )
+
+
+def run_git_fsck(entry_path: Path) -> bool:
+    try:
+        _run_git(["fsck", "--no-progress"], cwd=entry_path, check=True)
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError, OSError):
+        return False
+
+
+def list_cache_entries(cache_root: Path | None = None) -> list[CacheEntry]:
+    root = repos_root(cache_root)
+    if not root.is_dir():
+        return []
+    out: list[CacheEntry] = []
+    for child in sorted(root.iterdir()):
+        if not child.is_dir():
+            continue
+        meta = read_cache_meta(child)
+        out.append(
+            CacheEntry(
+                id=child.name,
+                path=child,
+                url=meta.url if meta else None,
+                ref=meta.ref if meta else None,
+                fetched_at=meta.fetched_at if meta else None,
+                commit=meta.commit if meta else None,
+                size_bytes=_dir_size(child),
+            )
+        )
+    return out
+
+
+def clean_cache(
+    entry_id: str | None = None,
+    *,
+    cache_root: Path | None = None,
+    catalog: bool = False,
+) -> CleanResult:
+    root = cache_root or default_cache_dir()
+    removed: list[str] = []
+    not_found: list[str] = []
+
+    if catalog:
+        target = root / "catalog" / "templates.json"
+        if target.is_file():
+            target.unlink()
+            removed.append(str(target))
+        catalog_dir = root / "catalog"
+        if catalog_dir.is_dir() and not any(catalog_dir.iterdir()):
+            catalog_dir.rmdir()
+        return CleanResult(removed=removed, not_found=not_found)
+
+    repos = root / "repos"
+    if entry_id:
+        target = repos / entry_id
+        if not target.exists():
+            return CleanResult(removed=[], not_found=[entry_id])
+        shutil.rmtree(target)
+        return CleanResult(removed=[str(target)], not_found=[])
+
+    if not repos.is_dir():
+        return CleanResult(removed=[], not_found=[])
+
+    for child in list(repos.iterdir()):
+        if child.is_dir():
+            shutil.rmtree(child)
+            removed.append(str(child))
+    return CleanResult(removed=removed, not_found=[])
+
+
+def verify_cache(
+    entry_id: str | None = None,
+    *,
+    cache_root: Path | None = None,
+) -> list[CacheEntry]:
+    entries = list_cache_entries(cache_root)
+    if entry_id:
+        entries = [e for e in entries if e.id == entry_id]
+    for entry in entries:
+        entry.fsck_ok = run_git_fsck(entry.path)
+    return entries
+
+
+def _remote_tip_sha(git_url: str, ref: str) -> str | None:
+    try:
+        result = _run_git(
+            ["ls-remote", git_url, ref],
+            check=True,
+            timeout=15,
+        )
+    except (
+        subprocess.CalledProcessError,
+        FileNotFoundError,
+        OSError,
+        subprocess.TimeoutExpired,
+    ):
+        return None
+    first = result.stdout.strip().splitlines()
+    if not first:
+        return None
+    return first[0].split()[0]
+
+
+def check_outdated(cache_root: Path | None = None) -> list[RemoteTipResult]:
+    results: list[RemoteTipResult] = []
+    for entry in list_cache_entries(cache_root):
+        if not entry.url or not entry.ref:
+            results.append(
+                RemoteTipResult(
+                    id=entry.id,
+                    behind=False,
+                    url=entry.url,
+                    ref=entry.ref,
+                    error="no remote URL in meta"
+                    if not entry.url
+                    else "no branch/ref in meta",
+                )
+            )
+            continue
+        remote_sha = _remote_tip_sha(entry.url, entry.ref)
+        if not remote_sha:
+            results.append(
+                RemoteTipResult(
+                    id=entry.id,
+                    behind=False,
+                    url=entry.url,
+                    ref=entry.ref,
+                    local_sha=entry.commit,
+                    error="unable to fetch remote tip",
+                )
+            )
+            continue
+        behind = bool(entry.commit and remote_sha != entry.commit)
+        results.append(
+            RemoteTipResult(
+                id=entry.id,
+                behind=behind,
+                url=entry.url,
+                ref=entry.ref,
+                local_sha=entry.commit,
+                remote_sha=remote_sha,
+            )
+        )
+    return results
+
+
+def update_cache(
+    entry_id: str | None = None,
+    *,
+    cache_root: Path | None = None,
+) -> tuple[list[str], list[str]]:
+    """Fetch/merge cached repos. Returns (updated_ids, failed_ids)."""
+    entries = list_cache_entries(cache_root)
+    targets = [e for e in entries if e.id == entry_id] if entry_id else entries
+    updated: list[str] = []
+    failed: list[str] = []
+    for entry in targets:
+        if not entry.url:
+            failed.append(entry.id)
+            continue
+        try:
+            _run_git(["fetch", "--all", "--tags"], cwd=entry.path, check=True)
+            ref = entry.ref
+            if ref:
+                branch_ref = ref if ref.startswith("refs/") else f"origin/{ref}"
+                try:
+                    _run_git(
+                        ["merge", "--ff-only", branch_ref],
+                        cwd=entry.path,
+                        check=True,
+                    )
+                except subprocess.CalledProcessError:
+                    _run_git(["checkout", ref], cwd=entry.path, check=True)
+            commit = _run_git(
+                ["rev-parse", "HEAD"], cwd=entry.path, check=True
+            ).stdout.strip()
+            write_cache_meta(
+                entry.path,
+                CacheMeta(
+                    url=entry.url,
+                    ref=entry.ref,
+                    fetched_at=time.time(),
+                    commit=commit,
+                ),
+            )
+            updated.append(entry.id)
+        except (subprocess.CalledProcessError, FileNotFoundError, OSError):
+            failed.append(entry.id)
+    return updated, failed
+
+
+def _probe_network() -> DoctorResult:
+    url = catalog_url()
+    try:
+        req = urllib.request.Request(url, method="HEAD")
+        with urllib.request.urlopen(req, timeout=10) as resp:  # noqa: S310
+            status = getattr(resp, "status", 200)
+            if 200 <= int(status) < 400:
+                return DoctorResult(
+                    check="network",
+                    ok=True,
+                    detail=f"catalog reachable ({url})",
+                )
+            return DoctorResult(
+                check="network",
+                ok=False,
+                detail=f"HTTP {status} for {url}",
+            )
+    except urllib.error.HTTPError as exc:
+        # Some hosts reject HEAD; treat 4xx/405 as reachable enough for doctor.
+        if exc.code in {403, 404, 405}:
+            return DoctorResult(
+                check="network",
+                ok=True,
+                detail=f"catalog host reachable ({url})",
+            )
+        return DoctorResult(check="network", ok=False, detail=str(exc))
+    except Exception as exc:  # noqa: BLE001 — doctor surfaces any probe failure
+        return DoctorResult(check="network", ok=False, detail=str(exc))
+
+
+def run_doctor(cache_root: Path | None = None) -> list[DoctorResult]:
+    results: list[DoctorResult] = []
+    root = cache_root or default_cache_dir()
+
+    try:
+        ver = _run_git(["--version"], check=True).stdout.strip()
+        results.append(DoctorResult(check="git", ok=True, detail=ver))
+    except (subprocess.CalledProcessError, FileNotFoundError, OSError) as exc:
+        results.append(
+            DoctorResult(check="git", ok=False, detail=f"git not found on PATH ({exc})")
+        )
+
+    results.append(_probe_network())
+
+    try:
+        root.mkdir(parents=True, exist_ok=True)
+        probe = root / ".doctor-probe"
+        probe.write_text("ok", encoding="utf-8")
+        probe.unlink(missing_ok=True)
+        results.append(DoctorResult(check="cache-dir", ok=True, detail=str(root)))
+    except OSError as exc:
+        results.append(DoctorResult(check="cache-dir", ok=False, detail=str(exc)))
+
+    entries = list_cache_entries(root)
+    corrupt = [e for e in entries if not run_git_fsck(e.path)]
+    if not corrupt:
+        results.append(
+            DoctorResult(
+                check="cache-integrity",
+                ok=True,
+                detail=f"{len(entries)} entries, all clean",
+            )
+        )
+    else:
+        ids = ", ".join(e.id for e in corrupt)
+        results.append(
+            DoctorResult(
+                check="cache-integrity",
+                ok=False,
+                detail=f"{len(corrupt)}/{len(entries)} entries failed git fsck: {ids}",
+            )
+        )
+    return results
+
+
+def format_bytes(num: int) -> str:
+    if num < 1024:
+        return f"{num} B"
+    if num < 1024 * 1024:
+        return f"{num / 1024:.1f} KB"
+    if num < 1024 * 1024 * 1024:
+        return f"{num / (1024 * 1024):.1f} MB"
+    return f"{num / (1024 * 1024 * 1024):.2f} GB"
+
+
+def format_age(fetched_at: float | None) -> str:
+    if fetched_at is None:
+        return "—"
+    minutes = int((time.time() - fetched_at) / 60)
+    if minutes < 1:
+        return "just now"
+    if minutes < 60:
+        return f"{minutes}m ago"
+    hours = minutes // 60
+    if hours < 24:
+        return f"{hours}h ago"
+    days = hours // 24
+    return f"{days}d ago"
+
+
+def short_sha(sha: str | None) -> str:
+    if not sha:
+        return "—"
+    return sha[:7]
+
+
+def entry_as_dict(entry: CacheEntry) -> dict[str, Any]:
+    return {
+        "id": entry.id,
+        "path": str(entry.path),
+        "url": entry.url,
+        "ref": entry.ref,
+        "fetched_at": entry.fetched_at,
+        "commit": entry.commit,
+        "size_bytes": entry.size_bytes,
+        "fsck_ok": entry.fsck_ok,
+    }
diff --git a/packages/create-awesome-python-app/src/create_awesome_python_app/cli.py b/packages/create-awesome-python-app/src/create_awesome_python_app/cli.py
index 1400f3c..75a1d22 100644
--- a/packages/create-awesome-python-app/src/create_awesome_python_app/cli.py
+++ b/packages/create-awesome-python-app/src/create_awesome_python_app/cli.py
@@ -414,12 +414,42 @@ def cache_dir_cmd() -> None:
 
 @cache_app.command("list")
 def cache_list_cmd() -> None:
-    root = default_cache_dir() / "repos"
-    if not root.exists():
-        console.print("(empty)")
+    from create_awesome_python_app.cache import (
+        format_age,
+        format_bytes,
+        list_cache_entries,
+        short_sha,
+    )
+
+    entries = list_cache_entries()
+    if not entries:
+        console.print("[dim]No cached templates or extensions.[/dim]")
+        console.print(
+            f"[dim]Cache root: {default_cache_dir()}\n"
+            "Run 'create-awesome-python-app my-app -t <template>' to populate it.[/dim]"
+        )
         return
-    for p in sorted(root.iterdir()):
-        console.print(p.name)
+    id_width = max(2, *(len(e.id) for e in entries))
+    console.print(
+        f"{'ID'.ljust(id_width)}  "
+        f"{'URL'.ljust(50)}  "
+        f"{'REF'.ljust(8)}  "
+        f"{'LAST FETCHED'.ljust(14)}  "
+        f"{'SHA'.ljust(8)}  "
+        "SIZE"
+    )
+    for entry in entries:
+        url = (entry.url or "—")[:50].ljust(50)
+        ref = (entry.ref or "—")[:8].ljust(8)
+        console.print(
+            f"[cyan]{entry.id.ljust(id_width)}[/cyan]  "
+            f"[dim]{url}[/dim]  "
+            f"[dim]{ref}[/dim]  "
+            f"[dim]{format_age(entry.fetched_at).ljust(14)}[/dim]  "
+            f"[dim]{short_sha(entry.commit).ljust(8)}[/dim]  "
+            f"[dim]{format_bytes(entry.size_bytes)}[/dim]"
+        )
+    console.print(f"[dim]\nCache root: {default_cache_dir()}[/dim]")
 
 
 @cache_app.command("clean")
@@ -427,35 +457,116 @@ def cache_clean_cmd(
     id: str | None = typer.Argument(None),
     catalog: bool = typer.Option(False, "--catalog"),
 ) -> None:
-    import shutil
+    from create_awesome_python_app.cache import clean_cache
 
-    root = default_cache_dir()
-    target = root / "repos" / id if id else root / "repos"
-    if target.exists():
-        shutil.rmtree(target)
-    if catalog:
-        cat = root / "catalog"
-        if cat.exists():
-            shutil.rmtree(cat)
-    console.print("cleaned")
+    result = clean_cache(id, catalog=catalog)
+    if result.not_found:
+        console.print(f"[yellow]No cache entry found for id: {id}[/yellow]")
+        return
+    if not result.removed:
+        console.print("[dim]Nothing to remove.[/dim]")
+        return
+    for path in result.removed:
+        console.print(f"[green]✓ Removed {path}[/green]")
 
 
 @cache_app.command("verify")
 def cache_verify_cmd(id: str | None = typer.Argument(None)) -> None:
-    console.print("verify: ok (stub fsck)" if not id else f"verify {id}: ok")
+    from create_awesome_python_app.cache import verify_cache
+
+    results = verify_cache(id)
+    if not results:
+        console.print("[dim]No cached entries.[/dim]")
+        raise typer.Exit(0)
+    all_ok = True
+    for entry in results:
+        ok = bool(entry.fsck_ok)
+        if not ok:
+            all_ok = False
+        mark = "[green]✓[/green]" if ok else "[red]✗[/red]"
+        console.print(f"{mark} [cyan]{entry.id}[/cyan]  [dim]{entry.url or '—'}[/dim]")
+    if not all_ok:
+        console.print()
+        console.print(
+            "[red]Some entries failed git fsck. "
+            "Consider 'create-awesome-python-app cache clean' and re-run.[/red]"
+        )
+        raise typer.Exit(1)
 
 
 @cache_app.command("outdated")
 def cache_outdated_cmd() -> None:
-    console.print("(none)")
+    from create_awesome_python_app.cache import check_outdated
+
+    results = check_outdated()
+    if not results:
+        console.print("[dim]No cached entries to check.[/dim]")
+        return
+    id_width = max(2, *(len(r.id) for r in results))
+    behind_count = 0
+    for row in results:
+        if row.error:
+            console.print(
+                f"[dim]?[/dim] [cyan]{row.id.ljust(id_width)}[/cyan]  "
+                f"[dim]{row.error}[/dim]"
+            )
+            continue
+        icon = "[yellow]▼[/yellow]" if row.behind else "[green]✓[/green]"
+        local = (row.local_sha or "—")[:7]
+        remote = (row.remote_sha or "—")[:7]
+        console.print(
+            f"{icon} [cyan]{row.id.ljust(id_width)}[/cyan]  "
+            f"local={local}  remote={remote}"
+        )
+        if row.behind:
+            behind_count += 1
+    if behind_count:
+        noun = "entry is" if behind_count == 1 else "entries are"
+        console.print(
+            f"[yellow]\n{behind_count} {noun} behind remote. "
+            "Run 'create-awesome-python-app cache update [id]' to refresh.[/yellow]"
+        )
 
 
 @cache_app.command("update")
 def cache_update_cmd(id: str | None = typer.Argument(None)) -> None:
-    console.print(f"updated {id or 'all'}")
+    from create_awesome_python_app.cache import list_cache_entries, update_cache
+
+    entries = list_cache_entries()
+    targets = [e for e in entries if e.id == id] if id else entries
+    if not targets:
+        label = f"y matching '{id}'" if id else "ies"
+        console.print(f"[dim]No cached entr{label} found.[/dim]")
+        raise typer.Exit(0)
+
+    updated, failed = update_cache(id)
+    by_id = {e.id: e for e in targets}
+    for entry_id in updated:
+        entry = by_id.get(entry_id)
+        console.print(
+            f"[green]✓[/green] [cyan]{entry_id}[/cyan]  "
+            f"[dim]{entry.url if entry else ''}[/dim]"
+        )
+    for entry_id in failed:
+        entry = by_id.get(entry_id)
+        detail = "missing url or refresh failed"
+        if entry and not entry.url:
+            detail = "missing url in meta"
+        console.print(f"[red]✗[/red] [cyan]{entry_id}[/cyan]  [dim]{detail}[/dim]")
+    if failed:
+        raise typer.Exit(1)
 
 
 @cache_app.command("doctor")
 def cache_doctor_cmd() -> None:
-    console.print(f"cache: {default_cache_dir()}")
-    console.print("git: ok")
+    from create_awesome_python_app.cache import run_doctor
+
+    results = run_doctor()
+    all_ok = True
+    for row in results:
+        mark = "[green]✓[/green]" if row.ok else "[red]✗[/red]"
+        console.print(f"{mark} {row.check}: {row.detail}")
+        if not row.ok:
+            all_ok = False
+    if not all_ok:
+        raise typer.Exit(1)
diff --git a/packages/create-awesome-python-app/tests/test_cache_cmds.py b/packages/create-awesome-python-app/tests/test_cache_cmds.py
index 2393a46..44fe091 100644
--- a/packages/create-awesome-python-app/tests/test_cache_cmds.py
+++ b/packages/create-awesome-python-app/tests/test_cache_cmds.py
@@ -1,10 +1,79 @@
+"""Tests for cache verify/outdated/update/doctor (CNA cache parity)."""
+
+from __future__ import annotations
+
+import subprocess
+import time
+from pathlib import Path
+
+import pytest
+from create_awesome_python_app.cache import (
+    check_outdated,
+    clean_cache,
+    list_cache_entries,
+    run_doctor,
+    update_cache,
+    verify_cache,
+)
 from create_awesome_python_app.cli import cache_app
+from create_python_app_core.git_cache import CacheMeta, write_cache_meta
 from typer.testing import CliRunner
 
 runner = CliRunner()
 
 
-def test_cache_subcommands() -> None:
+def _out(result) -> str:
+    return (result.stdout or "") + (result.stderr or "")
+
+
+def _init_git_repo(path: Path) -> str:
+    path.mkdir(parents=True, exist_ok=True)
+    subprocess.run(
+        ["git", "init", "-b", "main"],
+        cwd=path,
+        check=True,
+        capture_output=True,
+    )
+    subprocess.run(
+        ["git", "config", "user.email", "test@example.com"],
+        cwd=path,
+        check=True,
+        capture_output=True,
+    )
+    subprocess.run(
+        ["git", "config", "user.name", "Test"],
+        cwd=path,
+        check=True,
+        capture_output=True,
+    )
+    (path / "README.md").write_text("hi\n", encoding="utf-8")
+    subprocess.run(["git", "add", "."], cwd=path, check=True, capture_output=True)
+    subprocess.run(
+        ["git", "commit", "-m", "init"], cwd=path, check=True, capture_output=True
+    )
+    sha = subprocess.check_output(
+        ["git", "rev-parse", "HEAD"], cwd=path, text=True
+    ).strip()
+    return sha
+
+
+@pytest.fixture()
+def cache_root(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
+    root = tmp_path / "cpa-cache"
+    root.mkdir()
+    monkeypatch.setenv("CPA_CACHE_DIR", str(root))
+    return root
+
+
+def test_cache_subcommands_exit_zero(
+    cache_root: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setattr(
+        "create_awesome_python_app.cache._probe_network",
+        lambda: __import__(
+            "create_awesome_python_app.cache", fromlist=["DoctorResult"]
+        ).DoctorResult(check="network", ok=True, detail="mocked"),
+    )
     for args in (
         ["dir"],
         ["list"],
@@ -15,4 +84,117 @@ def test_cache_subcommands() -> None:
         ["clean", "--catalog"],
     ):
         result = runner.invoke(cache_app, args)
-        assert result.exit_code == 0, (args, result.stdout, result.stderr)
+        assert result.exit_code == 0, (args, _out(result))
+
+
+def test_list_cache_entries_empty(cache_root: Path) -> None:
+    assert list_cache_entries() == []
+
+
+def test_list_and_verify_populated_entry(cache_root: Path) -> None:
+    entry = cache_root / "repos" / "demo-entry"
+    sha = _init_git_repo(entry)
+    write_cache_meta(
+        entry,
+        CacheMeta(
+            url="https://example.com/repo.git",
+            ref="main",
+            fetched_at=time.time(),
+            commit=sha,
+        ),
+    )
+    entries = list_cache_entries()
+    assert len(entries) == 1
+    assert entries[0].id == "demo-entry"
+    assert entries[0].url == "https://example.com/repo.git"
+    assert entries[0].commit == sha
+    assert entries[0].size_bytes > 0
+
+    verified = verify_cache()
+    assert verified[0].fsck_ok is True
+
+    result = runner.invoke(cache_app, ["verify"])
+    assert result.exit_code == 0
+    assert "demo-entry" in _out(result)
+
+
+def test_clean_by_id_and_catalog(cache_root: Path) -> None:
+    a = cache_root / "repos" / "a"
+    b = cache_root / "repos" / "b"
+    _init_git_repo(a)
+    _init_git_repo(b)
+    cat = cache_root / "catalog" / "templates.json"
+    cat.parent.mkdir(parents=True)
+    cat.write_text("{}", encoding="utf-8")
+
+    result = clean_cache("a")
+    assert result.removed == [str(a)]
+    assert not a.exists()
+    assert b.exists()
+
+    missing = clean_cache("missing")
+    assert missing.not_found == ["missing"]
+
+    catalog = clean_cache(catalog=True)
+    assert str(cat) in catalog.removed
+    assert not cat.exists()
+
+
+def test_outdated_reports_missing_meta(cache_root: Path) -> None:
+    entry = cache_root / "repos" / "bare"
+    _init_git_repo(entry)
+    results = check_outdated()
+    assert len(results) == 1
+    assert results[0].error == "no remote URL in meta"
+
+
+def test_update_without_entries(cache_root: Path) -> None:
+    updated, failed = update_cache()
+    assert updated == []
+    assert failed == []
+    result = runner.invoke(cache_app, ["update"])
+    assert result.exit_code == 0
+    assert "No cached" in _out(result)
+
+
+def test_doctor_reports_git_and_cache_dir(
+    cache_root: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setattr(
+        "create_awesome_python_app.cache._probe_network",
+        lambda: __import__(
+            "create_awesome_python_app.cache", fromlist=["DoctorResult"]
+        ).DoctorResult(check="network", ok=True, detail="mocked"),
+    )
+    results = run_doctor()
+    by_check = {r.check: r for r in results}
+    assert by_check["git"].ok
+    assert by_check["cache-dir"].ok
+    assert by_check["cache-dir"].detail == str(cache_root)
+    assert by_check["network"].ok
+    assert by_check["cache-integrity"].ok
+
+    result = runner.invoke(cache_app, ["doctor"])
+    assert result.exit_code == 0
+    text = _out(result)
+    assert "git:" in text
+    assert "cache-dir:" in text
+
+
+def test_list_cli_shows_table(cache_root: Path) -> None:
+    entry = cache_root / "repos" / "demo"
+    sha = _init_git_repo(entry)
+    write_cache_meta(
+        entry,
+        CacheMeta(
+            url="https://github.com/Create-Python-App/cpa-templates.git",
+            ref="main",
+            fetched_at=time.time() - 120,
+            commit=sha,
+        ),
+    )
+    result = runner.invoke(cache_app, ["list"])
+    assert result.exit_code == 0
+    text = _out(result)
+    assert "demo" in text
+    assert "SHA" in text