refactor(cleanup): compose-ls driven, plus orphan state-dir reaping

PRD 0018 chunk 4. `claude-bottle cleanup` now derives its work
from `docker compose ls --all --format json`, filtered to projects
whose name starts with `claude-bottle-`. Per project: one `compose
down --volumes` removes the containers + the compose-managed
networks atomically.

The plan also enumerates three fallback buckets:

  - Stray containers — `claude-bottle-*` containers with no
    `com.docker.compose.project` label (left over from pre-compose
    code paths). Cleared via `docker rm -f`.
  - Stray networks — `claude-bottle-*` networks with no compose
    project label. Cleared via `docker network rm`.
  - Orphan state dirs — per-bottle `~/.claude-bottle/state/<id>/`
    dirs with no live project AND no `.preserve` marker. The
    `.preserve` marker (capability-block or auto-preserve-on-crash)
    explicitly opts-out of reaping; manual `rm -rf` is the only
    path for preserved state.

cli/cleanup.py collapses to a single y/N prompt — backend.prepare_cleanup
returns everything in one plan, backend.cleanup processes everything,
no more double-prompt for state. The CLI-side state-dir enumeration
+ `_state_summary` flags from PR #25 are gone; the backend's
orphan-detection rules subsume them.

claude_bottle/cli/cleanup.py

@@ -1,19 +1,22 @@
-"""cleanup: stop and remove all orphaned claude-bottle resources
-(containers + networks) left behind by previous bottles, plus
-optionally the per-bottle state dirs under ~/.claude-bottle/state/.
+"""cleanup: stop and remove all orphaned claude-bottle resources.
 
-State cleanup is prompted separately from container cleanup because
-the trade-off is different: containers + networks are pure debris,
-but a state dir may carry a resumable bottle (capability-block
-rebuild + transcript snapshot) the operator still wants."""
+PRD 0018 chunk 4: backend's prepare_cleanup carries everything in
+one plan — live compose projects (whose `compose down` removes
+containers + networks atomically), legacy stray containers/networks
+that aren't in any project, and orphan state dirs (per-bottle
+state with no live project AND no `.preserve` marker). One prompt,
+one cleanup call.
+
+State dirs with `.preserve` are intentionally never touched — they
+hold capability-block rebuilds or crash snapshots the operator may
+want to `resume`. Manual `rm -rf ~/.claude-bottle/state/<identity>`
+is the path for those.
+"""
 
 from __future__ import annotations
 
-import shutil
 import sys
-from pathlib import Path
 
-from .. import supervise as _supervise
 from ..backend import get_bottle_backend
 from ..log import info
 from ._common import read_tty_line
@@ -22,74 +25,21 @@ from ._common import read_tty_line
 def cmd_cleanup(_argv: list[str]) -> int:
     backend = get_bottle_backend()
     plan = backend.prepare_cleanup()
-    state_dirs = _enumerate_state_dirs()
 
-    if plan.empty and not state_dirs:
+    if plan.empty:
         info("no claude-bottle resources to clean up")
         return 0
 
-    if not plan.empty:
-        plan.print()
-        if _prompt_yes("remove all of the above?"):
-            backend.cleanup(plan)
-            info("containers + networks: cleaned")
-        else:
-            info("containers + networks: skipped")
-
-    if state_dirs:
-        _print_state(state_dirs)
-        if _prompt_yes(
-            "remove per-bottle state? (loses resumable bottles)",
-        ):
-            for d in state_dirs:
-                shutil.rmtree(d, ignore_errors=True)
-            info(f"state: removed {len(state_dirs)} dir(s)")
-        else:
-            info("state: skipped")
+    plan.print()
+    if not _prompt_yes("remove all of the above?"):
+        info("cleanup: skipped")
+        return 0
 
+    backend.cleanup(plan)
+    info("cleanup: done")
     return 0
 
 
-# --- State enumeration + display ------------------------------------------
-
-
-def _enumerate_state_dirs() -> list[Path]:
-    """All per-bottle state dirs under ~/.claude-bottle/state/.
-    Sorted for stable preflight output."""
-    state_root = _supervise.claude_bottle_root() / "state"
-    if not state_root.is_dir():
-        return []
-    return sorted(p for p in state_root.iterdir() if p.is_dir())
-
-
-def _state_summary(path: Path) -> str:
-    """One-line description suitable for the cleanup prompt. Calls
-    out resumability so the operator can decide whether removing it
-    loses anything they care about."""
-    flags: list[str] = []
-    if (path / "metadata.json").is_file():
-        flags.append("resumable")
-    else:
-        flags.append("no metadata.json (orphan)")
-    if (path / "Dockerfile").is_file():
-        flags.append("rebuilt Dockerfile")
-    if (path / "transcript").is_dir():
-        flags.append("transcript snapshot")
-    if (path / ".preserve").is_file():
-        flags.append("preserve marker")
-    return f"state:     {path.name} ({', '.join(flags)})"
-
-
-def _print_state(dirs: list[Path]) -> None:
-    print(file=sys.stderr)
-    for d in dirs:
-        info(_state_summary(d))
-    print(file=sys.stderr)
-
-
-# --- Prompt ----------------------------------------------------------------
-
-
 def _prompt_yes(message: str) -> bool:
     sys.stderr.write(f"claude-bottle: {message} [y/N] ")
     sys.stderr.flush()