agent-notes 2.15.1__tar.gz → 2.16.0__tar.gz

{agent_notes-2.15.1 → agent_notes-2.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-notes
-Version: 2.15.1
+Version: 2.16.0
 Summary: AI agent configuration manager for Claude Code, OpenCode, and Copilot
 Author-email: Eugene Naumov <min.verkligheten@gmail.com>
 License-Expression: MIT
@@ -115,7 +115,6 @@ agent-notes <command> [options]
 |---------|-------------|
 | `install [--local] [--copy]` | Interactive wizard or direct install |
 | `uninstall [--local]` | Remove installed components |
-| `update` | Pull latest, rebuild, reinstall |
 | `doctor [--local] [--fix]` | Check installation health |
 | `info` | Show status and component counts |
 | `list [clis\|models\|roles\|agents\|skills\|rules\|all]` | List engine components or installed |

{agent_notes-2.15.1 → agent_notes-2.16.0}/README.md

@@ -85,7 +85,6 @@ agent-notes <command> [options]
 |---------|-------------|
 | `install [--local] [--copy]` | Interactive wizard or direct install |
 | `uninstall [--local]` | Remove installed components |
-| `update` | Pull latest, rebuild, reinstall |
 | `doctor [--local] [--fix]` | Check installation health |
 | `info` | Show status and component counts |
 | `list [clis\|models\|roles\|agents\|skills\|rules\|all]` | List engine components or installed |

agent_notes-2.16.0/agent_notes/VERSION

@@ -0,0 +1 @@
+2.16.0

{agent_notes-2.15.1 → agent_notes-2.16.0}/agent_notes/cli.py

@@ -237,15 +237,6 @@ def main():
     p_uninstall = subparsers.add_parser("uninstall", help="Remove installed components")
     p_uninstall.add_argument("--local", action="store_true", help="Remove from current project")
     
-    # update
-    p_update = subparsers.add_parser("update", help="Pull latest, show diff, reinstall")
-    p_update.add_argument("--dry-run", action="store_true", help="Show diff only, do not reinstall")
-    p_update.add_argument("-y", "--yes", action="store_true", help="Skip confirmation prompt")
-    p_update.add_argument("--only", action="append", choices=["agents","skills","rules","commands","config","settings"],
-        help="Filter diff to these component types (repeatable)")
-    p_update.add_argument("--since", help="Override 'before' commit label (cosmetic only for now)")
-    p_update.add_argument("--skip-pull", action="store_true", help="Skip git pull")
-    
     # doctor
     p_doctor = subparsers.add_parser("doctor", help="Check installation health")
     p_doctor.add_argument("--local", action="store_true", help="Check local installation")
@@ -325,15 +316,6 @@ def main():
     elif args.command == "uninstall":
         from .commands.install import uninstall
         uninstall(local=args.local)
-    elif args.command == "update":
-        from .commands.update import update
-        update(
-            dry_run=args.dry_run,
-            yes=args.yes,
-            only=args.only,
-            since=args.since,
-            skip_pull=args.skip_pull,
-        )
     elif args.command == "doctor":
         from .commands.doctor import doctor
         doctor(local=args.local, fix=args.fix)

{agent_notes-2.15.1 → agent_notes-2.16.0}/agent_notes/commands/__init__.py

@@ -14,14 +14,13 @@ from . import uninstall
 from . import build
 from . import doctor
 from . import validate
-from . import update
 from . import regenerate
 from . import list as list_cmd
 from . import memory as memory_cmd
 
 __all__ = [
     "install", "uninstall", "show_info",
-    "build", "doctor", "validate", "update",
+    "build", "doctor", "validate",
     "regenerate", "set_role", "interactive_install",
     "list_cmd", "memory_cmd",
 ]

{agent_notes-2.15.1 → agent_notes-2.16.0}/agent_notes/commands/doctor.py

@@ -62,25 +62,60 @@ def _check_session_hook(scope: str, issues: list) -> None:
         ))
 
 
+def check_version_drift(scope: str, issues: list, fix_actions: list) -> None:
+    """Check if the installed package version matches the current running version."""
+    from .. import install_state
+    from ..config import get_version
+    from ..domain.diagnostics import Issue, FixAction
+    from ..services.state_store import get_scope
+    from pathlib import Path
+
+    state = install_state.load_current_state()
+    if state is None:
+        return
+
+    project_path = Path.cwd() if scope == "local" else None
+    scope_state = get_scope(state, scope, project_path)
+    if scope_state is None:
+        return
+
+    installed_version = scope_state.installed_version
+    if not installed_version:
+        return
+
+    current_version = get_version()
+    if installed_version != current_version:
+        issues.append(Issue(
+            "version_drift",
+            "state.json",
+            f"Installed with v{installed_version} but running v{current_version}. "
+            "Run `agent-notes doctor --fix` or `agent-notes install` to update.",
+        ))
+        fix_actions.append(FixAction("_TRIGGER_INSTALL", "state.json", "reinstall to update"))
+
+
 def diagnose(scope: str, fix: bool = False) -> bool:
     """Run all diagnostic checks and optionally apply fixes."""
     from .. import install_state
-    
+
     print_summary(scope)
-    
+
     issues = []
     fix_actions = []
-    
+
     # Run checks
     check_stale_files(scope, issues, fix_actions)
-    check_broken_symlinks(scope, issues, fix_actions) 
+    check_broken_symlinks(scope, issues, fix_actions)
     check_shadowed_files(scope, issues, fix_actions)
     check_missing_files(scope, issues, fix_actions)
     check_content_drift(scope, issues, fix_actions)
-    
+
     # Build freshness check (scope-independent)
     check_build_freshness(issues, fix_actions)
 
+    # Version drift check
+    check_version_drift(scope, issues, fix_actions)
+
     # SessionStart hook check (Claude Code only)
     _check_session_hook(scope, issues)
 

{agent_notes-2.15.1 → agent_notes-2.16.0}/agent_notes/commands/wizard.py

@@ -8,6 +8,7 @@ from .build import build
 from ._install_helpers import (
     count_agents, count_global, count_skills
 )
+from ..services.counts import count_rules_total as _count_rules_total
 from ..services.fs import place_file, place_dir_contents
 from ..services.ui import (
     _can_interactive, _safe_input, _checkbox_select, _radio_select,
@@ -79,22 +80,7 @@ def _get_skill_groups() -> Dict[str, List[str]]:
 
 def _count_rules() -> int:
     """Count rule files."""
-    # For testing, allow bypassing the registry
-    import os
-    if os.environ.get('_WIZARD_TEST_MODE'):
-        if not DIST_RULES_DIR.exists():
-            return 0
-        return len(list(DIST_RULES_DIR.glob("*.md")))
-    else:
-        try:
-            from ..registries import default_rule_registry
-            registry = default_rule_registry()
-            return len(registry.all())
-        except Exception:
-            # Fallback to old behavior if registry fails
-            if not DIST_RULES_DIR.exists():
-                return 0
-            return len(list(DIST_RULES_DIR.glob("*.md")))
+    return _count_rules_total()
 
 
 def _select_cli(step: int = 0, total: int = 0, version: str = '') -> Set[str]:
@@ -629,7 +615,27 @@ def _interactive_install() -> None:
         print(f"{Color.RED}Build failed: {e}{Color.NC}")
         return
 
-    # Execute installation
+    _execute_install(
+        clis=clis,
+        scope=scope,
+        copy_mode=copy_mode,
+        selected_skills=selected_skills,
+        role_models=role_models,
+        memory_backend=memory_backend,
+        memory_path=memory_path,
+    )
+
+
+def _execute_install(
+    clis: Set[str],
+    scope: str,
+    copy_mode: bool,
+    selected_skills: List[str],
+    role_models: Dict[str, Dict[str, str]],
+    memory_backend: str,
+    memory_path: str,
+) -> None:
+    """Run all installation steps after parameters have been collected and the build is done."""
     print(f"\nInstalling ({scope}, {'copy' if copy_mode else 'symlink'}) ...\n")
 
     from ..services import fs as _fs

{agent_notes-2.15.1 → agent_notes-2.16.0}/agent_notes/config.py

@@ -91,56 +91,46 @@ def global_output_path(backend) -> Optional[Path]:
     return dist_dir_for(backend) / backend.layout["config"]
 
 
-# === Backward compatibility - lazy evaluation of old constants ===
-def _lazy_backend_attr(backend_name: str, attr_func):
-    """Helper for creating lazy attributes that depend on registry.
-
-    Note: at initial config-module import time, ``agent_notes.cli_backend`` is
-    NOT safe to import (circular). In that case we fall back to hardcoded
-    values that match the shipped YAMLs. Later callers who import these
-    constants after initial module load get the correct values via this same
-    function (the registry is then importable).
-    """
-    def get_attr():
-        try:
-            from .registries.cli_registry import default_registry
-            backend = default_registry().get(backend_name)
-            return attr_func(backend)
-        except (ImportError, KeyError):
-            # Fallback to hardcoded values if registry not available (e.g. circular
-            # import at initial module-load time). These match the shipped YAMLs.
-            fallbacks = {
-                'claude': {'home': Path.home() / ".claude", 'template': "global-claude.md", 'dist': "claude"},
-                'opencode': {'home': Path.home() / ".config" / "opencode", 'template': "global-opencode.md", 'dist': "opencode"},
-                'copilot': {'home': Path.home() / ".github", 'template': "global-copilot.md", 'dist': "github"},
-            }
-            fb = fallbacks.get(backend_name, {})
-            # Match by the attr_func's role — we encode intent via __name__ for named
-            # functions, or by returning the generic dist/home/template via the lambdas
-            # below (see DIST_*/GLOBAL_*/*_HOME assignments).
-            name = attr_func.__name__
-            if name == 'global_home' or name == '_fb_home':
-                return fb.get('home')
-            elif name == 'template_path' or name == '_fb_template':
-                return DATA_DIR / fb.get('template', '')
-            elif name == 'dist_dir' or name == '_fb_dist':
-                return DIST_DIR / fb.get('dist', backend_name)
-    return get_attr
-
-
-# Create backward-compatibility constants. We give the lambdas named stand-ins
-# so the fallback branch in _lazy_backend_attr can classify them correctly even
-# when the registry isn't importable yet (circular import during config init).
-def _fb_home(b):    return b.global_home
-def _fb_dist(b):    return dist_dir_for(b)
-def _fb_template(b): return global_template_path(b)
-
-CLAUDE_HOME       = _lazy_backend_attr('claude',   _fb_home)()
-OPENCODE_HOME     = _lazy_backend_attr('opencode', _fb_home)()
-GITHUB_HOME       = _lazy_backend_attr('copilot',  _fb_home)()
-DIST_CLAUDE_DIR   = _lazy_backend_attr('claude',   _fb_dist)()
-DIST_OPENCODE_DIR = _lazy_backend_attr('opencode', _fb_dist)()
-DIST_GITHUB_DIR   = _lazy_backend_attr('copilot',  _fb_dist)()
-GLOBAL_CLAUDE_MD  = _lazy_backend_attr('claude',   _fb_template)()
-GLOBAL_OPENCODE_MD = _lazy_backend_attr('opencode', _fb_template)()
-GLOBAL_COPILOT_MD = _lazy_backend_attr('copilot',  _fb_template)()
+# === Backward compatibility constants ===
+# Hardcoded fallbacks match the shipped YAMLs and protect against circular
+# imports if this module is ever imported very early in the load sequence.
+_FALLBACKS = {
+    'claude':   {'home': Path.home() / ".claude",               'template': "global-claude.md",   'dist': "claude"},
+    'opencode': {'home': Path.home() / ".config" / "opencode",  'template': "global-opencode.md", 'dist': "opencode"},
+    'copilot':  {'home': Path.home() / ".github",               'template': "global-copilot.md",  'dist': "github"},
+}
+
+
+def _backend_home(name: str) -> Path:
+    try:
+        from .registries.cli_registry import default_registry
+        return default_registry().get(name).global_home
+    except (ImportError, KeyError):
+        return _FALLBACKS[name]['home']
+
+
+def _backend_dist(name: str) -> Path:
+    try:
+        from .registries.cli_registry import default_registry
+        return dist_dir_for(default_registry().get(name))
+    except (ImportError, KeyError):
+        return DIST_DIR / _FALLBACKS[name]['dist']
+
+
+def _backend_template(name: str) -> Path:
+    try:
+        from .registries.cli_registry import default_registry
+        return global_template_path(default_registry().get(name))
+    except (ImportError, KeyError):
+        return DATA_DIR / _FALLBACKS[name]['template']
+
+
+CLAUDE_HOME        = _backend_home('claude')
+OPENCODE_HOME      = _backend_home('opencode')
+GITHUB_HOME        = _backend_home('copilot')
+DIST_CLAUDE_DIR    = _backend_dist('claude')
+DIST_OPENCODE_DIR  = _backend_dist('opencode')
+DIST_GITHUB_DIR    = _backend_dist('copilot')
+GLOBAL_CLAUDE_MD   = _backend_template('claude')
+GLOBAL_OPENCODE_MD = _backend_template('opencode')
+GLOBAL_COPILOT_MD  = _backend_template('copilot')

{agent_notes-2.15.1 → agent_notes-2.16.0}/agent_notes/data/hooks/session-context.md.tpl

@@ -16,4 +16,4 @@ You have a specialized agent team installed. Delegate work to them — do not tr
 - Docs → tech-writer
 - Infrastructure → devops
 
-**Slash commands:** /plan /review /debug /brainstorm
+{{skills_catalog}}

{agent_notes-2.15.1 → agent_notes-2.16.0}/agent_notes/doctor_checks.py

@@ -1,6 +1,14 @@
 """Scoped health checks for agent-notes — only touches files we own."""
 
 from __future__ import annotations
+
+__all__ = [
+    "expected_paths_for_install",
+    "check_missing",
+    "check_broken",
+    "check_drift",
+    "check_stale",
+]
 from pathlib import Path
 from typing import Optional
 

{agent_notes-2.15.1 → agent_notes-2.16.0}/agent_notes/domain/state.py

@@ -33,6 +33,7 @@ class ScopeState:
     installed_at: str = ""
     updated_at: str = ""
     mode: str = "symlink"
+    installed_version: str = ""
     clis: dict[str, BackendState] = field(default_factory=dict)
 
 

{agent_notes-2.15.1 → agent_notes-2.16.0}/agent_notes/scripts/cost_report.py

@@ -5,6 +5,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 
 from . import _claude_backend, _opencode_backend
+from ._opencode_backend import DB as _OPENCODE_DB
 
 
 def _opencode_active() -> bool:
@@ -21,8 +22,7 @@ def _by_recency(since: float | None = None, session_id: str | None = None) -> in
         if jsonls:
             claude_mtime = max(f.stat().st_mtime for f in jsonls)
 
-    opencode_db = Path.home() / ".local" / "share" / "opencode" / "opencode.db"
-    opencode_mtime = opencode_db.stat().st_mtime if opencode_db.exists() else 0.0
+    opencode_mtime = _OPENCODE_DB.stat().st_mtime if _OPENCODE_DB.exists() else 0.0
 
     if claude_mtime == 0.0 and opencode_mtime == 0.0:
         print("No session data found (no Claude Code transcripts or OpenCode database).")

agent_notes-2.16.0/agent_notes/services/counts.py

@@ -0,0 +1,67 @@
+"""Shared counting helpers for installed components."""
+
+import os
+
+
+def count_rules_total() -> int:
+    """Count total available rule files (for wizard display).
+
+    Uses the rule registry when available; falls back to counting .md files
+    directly from the dist rules directory.
+    """
+    from ..config import DIST_RULES_DIR
+
+    if os.environ.get('_WIZARD_TEST_MODE'):
+        if not DIST_RULES_DIR.exists():
+            return 0
+        return len(list(DIST_RULES_DIR.glob("*.md")))
+
+    try:
+        from ..registries import default_rule_registry
+        registry = default_rule_registry()
+        return len(registry.all())
+    except Exception:
+        if not DIST_RULES_DIR.exists():
+            return 0
+        return len(list(DIST_RULES_DIR.glob("*.md")))
+
+
+def count_skills(backend, scope: str) -> tuple:
+    """Count (installed, expected) skills for a CLI backend. Excludes broken symlinks."""
+    from . import installer
+    from ..config import DIST_SKILLS_DIR
+
+    if not backend.supports("skills"):
+        return 0, 0
+
+    skills_dir = installer.target_dir_for(backend, "skills", scope)
+    if skills_dir and skills_dir.exists():
+        installed = len([d for d in skills_dir.iterdir() if d.is_dir() and d.exists()])
+    else:
+        installed = 0
+
+    expected = (
+        len([d for d in DIST_SKILLS_DIR.iterdir() if d.is_dir()])
+        if DIST_SKILLS_DIR and DIST_SKILLS_DIR.exists()
+        else 0
+    )
+    return installed, expected
+
+
+def count_rules(backend, scope: str) -> tuple:
+    """Count (installed, expected) rules for a CLI backend."""
+    from . import installer
+    from ..config import DIST_RULES_DIR
+
+    if not backend.supports("rules"):
+        return 0, 0
+
+    rules_dir = installer.target_dir_for(backend, "rules", scope)
+    installed = len(list(rules_dir.glob("*.md"))) if rules_dir and rules_dir.exists() else 0
+
+    expected = (
+        len(list(DIST_RULES_DIR.glob("*.md")))
+        if DIST_RULES_DIR and DIST_RULES_DIR.exists()
+        else 0
+    )
+    return installed, expected

{agent_notes-2.15.1 → agent_notes-2.16.0}/agent_notes/services/diagnostics/_checks.py

@@ -7,20 +7,30 @@ from typing import List, Optional
 from ...domain.diagnostics import Issue, FixAction
 
 
-def check_stale_files(scope: str, issues: List[Issue], fix_actions: List[FixAction]):
-    """Check for installed files without matching source - DELEGATED to doctor_checks."""
-    # This function is kept for backwards compatibility but delegates to the new module
-    from ...cli_backend import load_registry
-    from ... import install_state, doctor_checks
+def _load_scope_state(scope: str):
+    """Load registry and scope state for a given scope.
+
+    Returns (registry, scope_state) where scope_state may be None if no
+    state file exists.
+    """
+    from ...registries.cli_registry import load_registry
+    from ... import install_state
     from ...state import get_scope
 
     registry = load_registry()
     state = install_state.load_current_state()
     if state is None:
-        scope_state = None
-    else:
-        project_path = Path.cwd() if scope == "local" else None
-        scope_state = get_scope(state, scope, project_path)
+        return registry, None
+    project_path = Path.cwd() if scope == "local" else None
+    scope_state = get_scope(state, scope, project_path)
+    return registry, scope_state
+
+
+def check_stale_files(scope: str, issues: List[Issue], fix_actions: List[FixAction]):
+    """Check for installed files without matching source - DELEGATED to doctor_checks."""
+    from ... import doctor_checks
+
+    registry, scope_state = _load_scope_state(scope)
     doctor_checks.check_stale(scope, scope_state, registry, issues, fix_actions)
 
 
@@ -30,7 +40,7 @@ def _find_dist_source(symlink: Path, scope: str) -> Optional[Path]:
     Iterates all registered backends; returns first dist source whose
     component and filename match the given symlink.
     """
-    from ...cli_backend import load_registry
+    from ...registries.cli_registry import load_registry
     from ... import installer
     registry = load_registry()
 
@@ -75,35 +85,17 @@ def _find_dist_source(symlink: Path, scope: str) -> Optional[Path]:
 
 def check_broken_symlinks(scope: str, issues: List[Issue], fix_actions: List[FixAction]):
     """Check for symlinks with non-existent targets - DELEGATED to doctor_checks."""
-    # This function is kept for backwards compatibility but delegates to the new module
-    from ...cli_backend import load_registry
-    from ... import install_state, doctor_checks
-    from ...state import get_scope
+    from ... import doctor_checks
 
-    registry = load_registry()
-    state = install_state.load_current_state()
-    if state is None:
-        scope_state = None
-    else:
-        project_path = Path.cwd() if scope == "local" else None
-        scope_state = get_scope(state, scope, project_path)
+    registry, scope_state = _load_scope_state(scope)
     doctor_checks.check_broken(scope, registry, issues, fix_actions, scope_state)
 
 
 def check_shadowed_files(scope: str, issues: List[Issue], fix_actions: List[FixAction]):
     """Check for regular files where symlinks are expected - TARGETED check only."""
-    from ...cli_backend import load_registry
-    from ... import install_state, doctor_checks
-    from ...state import get_scope
+    from ... import doctor_checks
 
-    # Get expected paths and check each one individually
-    registry = load_registry()
-    state = install_state.load_current_state()
-    if state is None:
-        scope_state = None
-    else:
-        project_path = Path.cwd() if scope == "local" else None
-        scope_state = get_scope(state, scope, project_path)
+    registry, scope_state = _load_scope_state(scope)
 
     # Only check paths we know should exist
     for src, dst, backend_name, component in doctor_checks.expected_paths_for_install(registry, scope):
@@ -119,13 +111,14 @@ def check_shadowed_files(scope: str, issues: List[Issue], fix_actions: List[FixA
 
 def check_missing_files(scope: str, issues: List[Issue], fix_actions: List[FixAction]):
     """Check for source files that aren't installed - DELEGATED to doctor_checks."""
-    # This function is kept for backwards compatibility but delegates to the new module
-    from ...cli_backend import load_registry
-    from ... import doctor_checks, install_state
+    from ... import doctor_checks
+    from ...registries.cli_registry import load_registry
+    from ... import install_state
     from ...state import get_scope
 
     registry = load_registry()
     # Pass scope state so opted-out backends aren't flagged as "missing".
+    # Use a try/except here since local scope resolution can raise ValueError/KeyError.
     state = install_state.load_current_state()
     scope_state = None
     if state is not None:
@@ -144,18 +137,9 @@ def check_missing_files(scope: str, issues: List[Issue], fix_actions: List[FixAc
 
 def check_content_drift(scope: str, issues: List[Issue], fix_actions: List[FixAction]):
     """Check for copied files that differ from source - DELEGATED to doctor_checks."""
-    # This function is kept for backwards compatibility but delegates to the new module
-    from ...cli_backend import load_registry
-    from ... import install_state, doctor_checks
-    from ...state import get_scope
+    from ... import doctor_checks
 
-    registry = load_registry()
-    state = install_state.load_current_state()
-    if state is None:
-        scope_state = None
-    else:
-        project_path = Path.cwd() if scope == "local" else None
-        scope_state = get_scope(state, scope, project_path)
+    registry, scope_state = _load_scope_state(scope)
     doctor_checks.check_drift(scope, registry, issues, fix_actions, scope_state)
 
 
@@ -167,7 +151,7 @@ def check_build_freshness(issues: List[Issue], fix_actions: List[FixAction]):
     # Check agents.yaml vs generated agents
     if agents_yaml.exists():
         source_time = agents_yaml.stat().st_mtime
-        from ...cli_backend import load_registry
+        from ...registries.cli_registry import load_registry
         from ...config import dist_dir_for
 
         registry = load_registry()
@@ -184,7 +168,7 @@ def check_build_freshness(issues: List[Issue], fix_actions: List[FixAction]):
     # Check individual source agents
     source_agents_dir = AGENTS_DIR
     if source_agents_dir.exists():
-        from ...cli_backend import load_registry
+        from ...registries.cli_registry import load_registry
         from ...config import dist_dir_for
 
         registry = load_registry()
@@ -202,7 +186,7 @@ def check_build_freshness(issues: List[Issue], fix_actions: List[FixAction]):
                         fix_actions.append(FixAction("BUILD", str(gen_file), "regenerate from source"))
 
     # Check global source files
-    from ...cli_backend import load_registry
+    from ...registries.cli_registry import load_registry
     from ...config import global_template_path, global_output_path
 
     registry = load_registry()

{agent_notes-2.15.1 → agent_notes-2.16.0}/agent_notes/services/diagnostics/_display.py

@@ -1,9 +1,16 @@
 """Display and summary functions for agent-notes diagnostics."""
 
+__all__ = [
+    "count_stale",
+    "print_summary",
+    "print_issues",
+]
+
 from pathlib import Path
 from typing import List, Dict
 
 from ...domain.diagnostics import Issue
+from ..counts import count_skills as _count_skills_impl, count_rules as _count_rules_impl
 
 
 def _cli_base_dir(backend, scope: str) -> Path:
@@ -34,50 +41,12 @@ def _count_agents(backend, scope: str) -> tuple:
 
 def _count_skills(backend, scope: str) -> tuple:
     """Count (installed, expected) skills for a CLI backend. Excludes broken symlinks."""
-    from ... import installer
-
-    # Helper to get DIST_SKILLS_DIR
-    def _get_dist_skills_dir():
-        from ...config import DIST_SKILLS_DIR
-        return DIST_SKILLS_DIR
-
-    if not backend.supports("skills"):
-        return 0, 0
-
-    # Count installed
-    skills_dir = installer.target_dir_for(backend, "skills", scope)
-    if skills_dir and skills_dir.exists():
-        installed = len([d for d in skills_dir.iterdir() if d.is_dir() and d.exists()])
-    else:
-        installed = 0
-
-    # Count expected (universal skills)
-    dist_skills_dir = _get_dist_skills_dir()
-    expected = len([d for d in dist_skills_dir.iterdir() if d.is_dir()]) if dist_skills_dir and dist_skills_dir.exists() else 0
-    return installed, expected
-
+    return _count_skills_impl(backend, scope)
 
 
 def _count_rules(backend, scope: str) -> tuple:
     """Count (installed, expected) rules for a CLI backend."""
-    from ... import installer
-
-    # Helper to get DIST_RULES_DIR
-    def _get_dist_rules_dir():
-        from ...config import DIST_RULES_DIR
-        return DIST_RULES_DIR
-
-    if not backend.supports("rules"):
-        return 0, 0
-
-    # Count installed
-    rules_dir = installer.target_dir_for(backend, "rules", scope)
-    installed = len(list(rules_dir.glob("*.md"))) if rules_dir and rules_dir.exists() else 0
-
-    # Count expected
-    dist_rules_dir = _get_dist_rules_dir()
-    expected = len(list(dist_rules_dir.glob("*.md"))) if dist_rules_dir and dist_rules_dir.exists() else 0
-    return installed, expected
+    return _count_rules_impl(backend, scope)
 
 
 def _check_config(backend, scope: str) -> tuple:
@@ -101,9 +70,9 @@ def _check_config(backend, scope: str) -> tuple:
 
 def _check_role_models(state):
     """Display role→model assignments and check compatibility."""
-    from ...model_registry import load_model_registry
+    from ...registries.model_registry import load_model_registry
     from ...registries.cli_registry import load_registry
-    from ...role_registry import load_role_registry
+    from ...registries.role_registry import load_role_registry
     from ...config import Color
 
     model_registry = load_model_registry()