@smilintux/skcapstone 0.10.0 → 0.12.5

package/src/skcapstone/cli/scheduler_cmd.py

@@ -0,0 +1,167 @@
+"""`skcapstone scheduler` — manage the unified job scheduler."""
+from __future__ import annotations
+
+import json
+import os
+import socket
+from pathlib import Path
+
+import click
+
+from .. import AGENT_HOME
+from ..scheduler_jobs import (
+    load_jobs,
+    load_jobs_with_dropins,
+    current_host_aliases,
+    job_runs_here,
+)
+from ..scheduler_runner import JobRunner
+from ..scheduler_state import SchedulerState
+
+
+def _home() -> Path:
+    """Return the effective SKCAPSTONE_HOME path.
+
+    Reads from the ``SKCAPSTONE_HOME`` environment variable when set,
+    falling back to the package-level ``AGENT_HOME`` constant.
+
+    Returns:
+        Resolved :class:`~pathlib.Path` for the agent home directory.
+    """
+    return Path(os.environ.get("SKCAPSTONE_HOME", AGENT_HOME))
+
+
+def _jobs_path() -> Path:
+    """Return the path to the synced ``jobs.yaml`` registry.
+
+    Returns:
+        ``<SKCAPSTONE_HOME>/config/jobs.yaml`` as a :class:`~pathlib.Path`.
+    """
+    return _home() / "config" / "jobs.yaml"
+
+
+def register_scheduler_commands(main: click.Group) -> None:
+    """Register the ``scheduler`` command group onto *main*.
+
+    Adds the following sub-commands:
+
+    - ``scheduler list``   — list all configured jobs with run status.
+    - ``scheduler status`` — show last-run state for this node.
+    - ``scheduler run``    — execute a job immediately.
+    - ``scheduler logs``   — tail the most recent log for a job.
+    - ``scheduler enable`` — enable a job in ``jobs.yaml``.
+    - ``scheduler disable`` — disable a job in ``jobs.yaml``.
+
+    Args:
+        main: The top-level :class:`click.Group` to attach commands to.
+    """
+
+    @main.group("scheduler")
+    def scheduler() -> None:
+        """Manage the unified job scheduler (skscheduler)."""
+
+    @scheduler.command("list")
+    def list_jobs() -> None:
+        """List all configured jobs and where they run."""
+        jobs = load_jobs_with_dropins(_jobs_path())
+        if not jobs:
+            click.echo("No jobs configured.")
+            return
+        here = current_host_aliases()
+        for j in jobs:
+            sched = j.schedule or (f"every {int(j.every_seconds)}s" if j.every_seconds else "-")
+            mark = "x" if (j.enabled and job_runs_here(j, here)) else " "
+            click.echo(f"[{mark}] {j.name:24s} {j.type:6s} {sched:18s} nodes={j.nodes}")
+
+    @scheduler.command("status")
+    @click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+    def status(as_json: bool) -> None:
+        """Show last-run status for this node."""
+        st = SchedulerState(root=_home(), hostname=socket.gethostname())
+        data = st.all()
+        if as_json:
+            click.echo(json.dumps(data, indent=2))
+            return
+        if not data:
+            click.echo("No run history on this node yet.")
+            return
+        for name, rec in data.items():
+            click.echo(
+                f"{name:24s} last={rec.get('last_run')} status={rec.get('last_status')} "
+                f"runs={rec.get('run_count')} errors={rec.get('error_count')}"
+            )
+
+    @scheduler.command("run")
+    @click.argument("job_name")
+    def run_now(job_name: str) -> None:
+        """Run a job now on this node (manual override; ignores schedule and affinity)."""
+        jobs = {j.name: j for j in load_jobs_with_dropins(_jobs_path())}
+        job = jobs.get(job_name)
+        if not job:
+            raise click.ClickException(f"Unknown job: {job_name}")
+        runner = JobRunner(log_dir=_home() / "scheduler" / socket.gethostname() / "logs")
+        result = runner.run(job)
+        # Record state + fire the job's notify policy so a manual run is observable in
+        # `scheduler status` and exercises the sk-alert hook (same as the scheduled path).
+        from datetime import datetime, timezone
+        from ..scheduled_tasks import TaskScheduler
+        SchedulerState(_home(), socket.gethostname()).record_run(
+            job.name, now=datetime.now(timezone.utc), ok=result.ok, error=result.error)
+        TaskScheduler._maybe_notify(job, result, attempts=1)
+        if result.output:
+            click.echo(result.output.strip())
+        if not result.ok:
+            raise click.ClickException(f"Job failed: {result.error}")
+        click.echo(f"OK {job_name} done")
+
+    @scheduler.command("logs")
+    @click.argument("job_name")
+    @click.option("--tail", default=40, show_default=True, help="Number of lines to show.")
+    def logs(job_name: str, tail: int) -> None:
+        """Show the latest log for a job on this node."""
+        log_dir = _home() / "scheduler" / socket.gethostname() / "logs"
+        matches = sorted(log_dir.glob(f"{job_name}-*.log")) if log_dir.exists() else []
+        if not matches:
+            click.echo(f"No logs for '{job_name}'.")
+            return
+        lines = matches[-1].read_text(encoding="utf-8").splitlines()
+        click.echo("\n".join(lines[-tail:]))
+
+    @scheduler.command("enable")
+    @click.argument("job_name")
+    def enable(job_name: str) -> None:
+        """Enable a job (sets enabled: true in jobs.yaml)."""
+        _set_enabled(job_name, True)
+        click.echo(f"enabled {job_name}")
+
+    @scheduler.command("disable")
+    @click.argument("job_name")
+    def disable(job_name: str) -> None:
+        """Disable a job (sets enabled: false in jobs.yaml)."""
+        _set_enabled(job_name, False)
+        click.echo(f"disabled {job_name}")
+
+
+def _set_enabled(job_name: str, value: bool) -> None:
+    """Set the ``enabled`` flag for *job_name* in ``jobs.yaml``.
+
+    Reads the current ``jobs.yaml``, toggles the ``enabled`` field for the
+    named job, and writes the file back atomically via
+    :func:`yaml.safe_dump`.
+
+    Args:
+        job_name: The job key to update.
+        value: ``True`` to enable the job; ``False`` to disable.
+
+    Raises:
+        click.ClickException: If *job_name* is not found in the config.
+    """
+    import yaml
+
+    path = _jobs_path()
+    data = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+    jobs = data.get("jobs") or {}
+    if job_name not in jobs:
+        raise click.ClickException(f"Unknown job: {job_name}")
+    jobs[job_name]["enabled"] = value
+    path.write_text(yaml.safe_dump(data, sort_keys=False), encoding="utf-8")

package/src/skcapstone/cli/session.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import json
 import sys
 from pathlib import Path
 
@@ -125,3 +126,27 @@ def register_session_commands(main: click.Group) -> None:
         for src, count in sorted(by_source.items(), key=lambda x: -x[1]):
             console.print(f"    {src}: {count}")
         console.print()
+
+    @session.command("briefing")
+    @click.option("--home", default=AGENT_HOME, type=click.Path())
+    @click.option(
+        "--format",
+        "fmt",
+        type=click.Choice(["text", "json"]),
+        default="text",
+        help="Output format (default: text).",
+    )
+    @click.option("--memories", "-n", default=10, help="Max recent memories to include.")
+    def session_briefing(home: str, fmt: str, memories: int):
+        """Show a native startup briefing for sovereign sessions.
+
+        Merges SKCapstone context with the current HammerTime legal/case
+        briefing when available, so any client can consume one startup payload.
+        """
+        from ..session_briefing import build_session_briefing, format_session_briefing_text
+
+        payload = build_session_briefing(Path(home).expanduser(), memory_limit=memories)
+        if fmt == "json":
+            click.echo(json.dumps(payload, indent=2, default=str))
+            return
+        click.echo(format_session_briefing_text(payload))

package/src/skcapstone/cli/setup.py

@@ -26,16 +26,23 @@ from ..runtime import get_runtime
 from rich.panel import Panel
 
 
+def _get_claude_template_dir() -> Path:
+    """Return the bundled defaults/claude skeleton directory."""
+    return Path(__file__).parent.parent / "defaults" / "claude"
+
+
 def _write_global_claude_md(home_path: Path, agent_name: str) -> Optional[Path]:
-    """Write ~/.claude/CLAUDE.md so Claude Code auto-rehydrates on every session."""
+    """Write ~/.claude/CLAUDE.md from the bundled skeleton template.
+
+    The template lives at defaults/claude/CLAUDE.md inside the package.
+    {{AGENT_NAME}} is substituted with the actual agent name.
+    If the template is missing, falls back to a minimal generated file.
+    """
     import platform
 
     if platform.system() == "Windows":
         appdata = os.environ.get("APPDATA", "")
-        if appdata:
-            claude_dir = Path(appdata) / ".claude"
-        else:
-            claude_dir = Path.home() / "AppData" / "Roaming" / ".claude"
+        claude_dir = Path(appdata) / ".claude" if appdata else Path.home() / "AppData" / "Roaming" / ".claude"
     else:
         claude_dir = Path.home() / ".claude"
 
@@ -43,30 +50,20 @@ def _write_global_claude_md(home_path: Path, agent_name: str) -> Optional[Path]:
         claude_dir.mkdir(parents=True, exist_ok=True)
         claude_md = claude_dir / "CLAUDE.md"
 
-        content = (
-            f"# Claude Code — Global Agent Instructions ({agent_name})\n\n"
-            "## SKCapstone Auto-Rehydration\n\n"
-            "At the start of every new session, run these commands in order:\n\n"
-            "```bash\n"
-            "skcapstone trust rehydrate\n"
-            "skcapstone sync pull\n"
-            "skcapstone status\n"
-            "```\n\n"
-            "## Agent Details\n\n"
-            f"- **Name**: {agent_name}\n"
-            f"- **Home**: `{home_path}`\n\n"
-            "## Quick Reference\n\n"
-            "```bash\n"
-            "skcapstone status                          # full pillar status\n"
-            "skcapstone memory list                     # recent memories\n"
-            "skcapstone sync push                       # push state to peers\n"
-            "skcapstone context show --format claude-md # regenerate this file\n"
-            "skcapstone sync pair --export-pubkey       # export your GPG pubkey\n"
-            "skcapstone sync pair --import-pubkey <f>   # import a peer's pubkey\n"
-            "```\n\n"
-            "> Auto-generated by `skcapstone init`. "
-            "Regenerate with: `skcapstone context generate --target claude-md`\n"
-        )
+        template_path = _get_claude_template_dir() / "CLAUDE.md"
+        if template_path.exists():
+            content = template_path.read_text(encoding="utf-8")
+            content = content.replace("{{AGENT_NAME}}", agent_name)
+        else:
+            # Minimal fallback if template is missing
+            content = (
+                f"# Claude Code — Global Agent Instructions ({agent_name})\n\n"
+                f"- **Agent**: `{agent_name}`\n"
+                f"- **Home**: `{home_path}`\n"
+                f"- **Env**: `SKCAPSTONE_AGENT={agent_name}`\n\n"
+                "Hooks auto-inject on SessionStart: soul + FEB chain + memories.\n\n"
+                "> Regenerate with: `skcapstone context generate --target claude-md`\n"
+            )
 
         claude_md.write_text(content, encoding="utf-8")
         return claude_md
@@ -74,6 +71,76 @@ def _write_global_claude_md(home_path: Path, agent_name: str) -> Optional[Path]:
         return None
 
 
+def _write_claude_settings(merge: bool = True) -> Optional[Path]:
+    """Write (or merge) ~/.claude/settings.json with SK hook registrations.
+
+    Uses the bundled defaults/claude/settings.json template, substituting
+    {{SKMEMORY_HOOKS_DIR}} with the real skmemory hooks path.
+
+    Args:
+        merge: If True and settings.json already exists, merge hooks rather
+               than overwrite. Default True.
+
+    Returns:
+        Path to the written settings.json, or None on failure.
+    """
+    import platform
+
+    if platform.system() == "Windows":
+        appdata = os.environ.get("APPDATA", "")
+        claude_dir = Path(appdata) / ".claude" if appdata else Path.home() / "AppData" / "Roaming" / ".claude"
+    else:
+        claude_dir = Path.home() / ".claude"
+
+    try:
+        import skmemory
+        hooks_dir = str(Path(skmemory.__file__).parent / "hooks")
+    except ImportError:
+        return None  # skmemory not installed — caller should use skmemory register instead
+
+    template_path = _get_claude_template_dir() / "settings.json"
+    if not template_path.exists():
+        return None
+
+    raw = template_path.read_text(encoding="utf-8")
+    raw = raw.replace("{{SKMEMORY_HOOKS_DIR}}", hooks_dir)
+    new_settings = json.loads(raw)
+
+    settings_path = claude_dir / "settings.json"
+    if merge and settings_path.exists():
+        try:
+            existing = json.loads(settings_path.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError):
+            existing = {}
+
+        # Merge hooks: add new hooks that aren't already registered
+        existing_hooks = existing.get("hooks", {})
+        for event, hook_groups in new_settings.get("hooks", {}).items():
+            existing_event = existing_hooks.setdefault(event, [])
+            existing_commands = {
+                h.get("command")
+                for group in existing_event
+                for h in group.get("hooks", [])
+                if "command" in h
+            }
+            for group in hook_groups:
+                cmds = {h.get("command") for h in group.get("hooks", []) if "command" in h}
+                if not cmds.issubset(existing_commands):
+                    existing_event.append(group)
+        existing["hooks"] = existing_hooks
+        # Preserve non-hook keys from template (skipDangerousModePermissionPrompt, etc.)
+        for k, v in new_settings.items():
+            if k != "hooks":
+                existing.setdefault(k, v)
+        final = existing
+    else:
+        claude_dir.mkdir(parents=True, exist_ok=True)
+        final = new_settings
+
+    settings_path.write_text(json.dumps(final, indent=2), encoding="utf-8")
+    return settings_path
+
+
 def register_setup_commands(main: click.Group) -> None:
     """Register all setup/lifecycle commands on the main CLI group."""
 

package/src/skcapstone/cli/shell_cmd.py

@@ -2,13 +2,29 @@
 
 from __future__ import annotations
 
+import sys
+from importlib.resources import as_file, files
+from pathlib import Path
+
 import click
 
 from ._common import AGENT_HOME
 
 
+def _picker_path() -> Path:
+    """Resolve the absolute path to the bundled sk-agent-picker.sh.
+
+    Works for any install layout (PyPI wheel, editable, install.sh) by
+    going through importlib.resources, so the picker is always sourced
+    from inside the installed skcapstone package.
+    """
+    resource = files("skcapstone") / "data" / "sk-agent-picker.sh"
+    with as_file(resource) as p:
+        return Path(p)
+
+
 def register_shell_commands(main: click.Group) -> None:
-    """Register the 'shell' command on the main CLI group."""
+    """Register the 'shell', 'shell-init', and 'shell-picker-path' commands."""
 
     @main.command("shell")
     @click.option(
@@ -41,3 +57,39 @@ def register_shell_commands(main: click.Group) -> None:
         from ..shell import run_shell
 
         run_shell(home=home)
+
+    @main.command("shell-init")
+    def shell_init_cmd() -> None:
+        """Emit shell code that loads the SK agent picker.
+
+        Add to your ~/.bashrc (or ~/.zshrc):
+
+            eval "$(skcapstone shell-init)"
+
+        This sources the picker shipped inside the skcapstone package,
+        so a single `pip install skcapstone` (PyPI, editable, or via
+        install.sh) is enough — no external script copy required.
+        """
+        from .. import DEFAULT_AGENT
+
+        path = _picker_path()
+        if not path.is_file():
+            click.echo(f"# skcapstone: picker missing at {path}", err=True)
+            sys.exit(1)
+        # Propagate the canonical default agent (single source of truth lives
+        # in skcapstone.DEFAULT_AGENT) so the picker and every child process
+        # inherit one authoritative value without re-hardcoding it in shell.
+        click.echo(f'export SK_DEFAULT_AGENT="{DEFAULT_AGENT}"')
+        click.echo(f'source "{path}"')
+
+    @main.command("shell-picker-path")
+    def shell_picker_path_cmd() -> None:
+        """Print the absolute path to the bundled sk-agent-picker.sh.
+
+        Useful for hand-rolled shell wiring, debugging, or scripted
+        invocation of the picker.
+        """
+        path = _picker_path()
+        click.echo(str(path))
+        if not path.is_file():
+            sys.exit(1)

package/src/skcapstone/cli/skills_cmd.py

@@ -114,8 +114,8 @@ def register_skills_commands(main: click.Group) -> None:
                 try:
                     skill_entries = client.search(query) if query else client.list_skills()
                     source = "remote"
-                except Exception:
-                    pass
+                except Exception as exc:
+                    logger.warning("Registry client query failed, falling back: %s", exc)
 
         # 2. Try GitHub raw catalog (always fresh, no server needed)
         if skill_entries is None and not offline:

package/src/skcapstone/cli/soul.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+import logging
 import shutil
 import sys
 from datetime import datetime, timezone
@@ -18,6 +19,8 @@ from .. import SKCAPSTONE_AGENT
 from rich.panel import Panel
 from rich.table import Table
 
+logger = logging.getLogger(__name__)
+
 # Path to the soul-blueprints repository (community blueprints)
 _BLUEPRINTS_REPO = Path.home() / "clawd" / "soul-blueprints" / "blueprints"
 
@@ -61,9 +64,9 @@ def register_soul_commands(main: click.Group) -> None:
         """Reusable --agent/-a option for soul subcommands."""
         return click.option(
             "--agent", "-a",
-            default=SKCAPSTONE_AGENT or "lumina",
-            envvar="SKCAPSTONE_AGENT",
-            help="Agent profile name (default: SKCAPSTONE_AGENT or 'lumina').",
+            default=SKCAPSTONE_AGENT,
+            envvar="SKAGENT",
+            help="Agent profile name (default: SKAGENT or active agent).",
         )
 
     @main.group()
@@ -332,8 +335,8 @@ def register_soul_commands(main: click.Group) -> None:
                 import json
                 base_data = json.loads(base_path.read_text(encoding="utf-8"))
                 vibe = base_data.get("vibe", "")
-            except Exception:
-                pass
+            except Exception as exc:
+                logger.warning("Failed to read vibe from soul base.json: %s", exc)
 
         lines = [
             f"Agent: [bold magenta]{agent}[/]",

package/src/skcapstone/cli/status.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+import logging
 import os
 import shutil
 import sys
@@ -19,6 +20,8 @@ from ..runtime import get_runtime
 from rich.panel import Panel
 from rich.table import Table
 
+logger = logging.getLogger(__name__)
+
 
 def _probe_llm_backends() -> dict[str, bool]:
     """Probe LLM backend availability.
@@ -43,8 +46,8 @@ def _probe_llm_backends() -> dict[str, bool]:
             urllib.request.Request(f"{host}/api/tags"), timeout=2
         ):
             backends["ollama"] = True
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("Ollama probe failed (not available): %s", exc)
     return backends
 
 
@@ -129,8 +132,8 @@ def _read_local_heartbeat(home: Path) -> Optional[dict]:
             hb_path = home / "heartbeats" / f"{agent_name}.json"
         if hb_path.exists():
             return json.loads(hb_path.read_text())
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.warning("Failed to load heartbeat data: %s", exc)
     return None
 
 
@@ -148,8 +151,11 @@ def _print_consciousness_metrics(console, home: Optional[Path] = None) -> None:
     import urllib.request
     import urllib.error
 
+    from .. import AGENT_PORTS, DEFAULT_PORT, SKCAPSTONE_AGENT
+
+    port = AGENT_PORTS.get(SKCAPSTONE_AGENT, DEFAULT_PORT)
     try:
-        with urllib.request.urlopen("http://localhost:7777/consciousness", timeout=2) as resp:
+        with urllib.request.urlopen(f"http://localhost:{port}/consciousness", timeout=2) as resp:
             data = json.loads(resp.read().decode("utf-8"))
         enabled = data.get("enabled", False)
         messages = data.get("messages_processed", 0)
@@ -250,6 +256,14 @@ def register_status_commands(main: click.Group) -> None:
             trust_detail += " [green]ENTANGLED[/]"
         table.add_row("Trust", "Cloud 9", status_icon(trust.status), trust_detail)
 
+        con = m.consciousness
+        con_detail = f"{con.sessions_digested} sessions digested, {con.topics_tracked} topics"
+        if con.whisper_active:
+            con_detail += " [green]daemon active[/]"
+        if con.whisper_md_age_hours < 24:
+            con_detail += f" [dim](whisper {con.whisper_md_age_hours:.1f}h old)[/]"
+        table.add_row("Consciousness", "SKWhisper", status_icon(con.status), con_detail)
+
         sec = m.security
         table.add_row(
             "Security", "SKSecurity", status_icon(sec.status),
@@ -332,8 +346,8 @@ def register_status_commands(main: click.Group) -> None:
                     f"\n  [bold yellow]WARNING:[/] [yellow]Low disk space: "
                     f"{free_gb:.1f} GB free[/]"
                 )
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.debug("Failed to check disk space: %s", exc)
 
         console.print()
         console.print(f"  [dim]Home: {m.home}[/]")
@@ -575,11 +589,23 @@ def register_status_commands(main: click.Group) -> None:
             "agent": "Agent Home",
             "identity": "Identity (CapAuth)",
             "memory": "Memory (SKMemory)",
-            "transport": "Transport (SKComm)",
+            "transport": "Transport (SKComms)",
             "sync": "Sync (Singularity)",
+            "codex": "Codex Integration",
+            "harness": "AI Harness (Claude Code)",
         }
 
-        for cat_key in ["packages", "system", "agent", "identity", "memory", "transport", "sync"]:
+        for cat_key in [
+            "packages",
+            "system",
+            "agent",
+            "identity",
+            "memory",
+            "transport",
+            "sync",
+            "codex",
+            "harness",
+        ]:
             checks = categories.get(cat_key, [])
             if not checks:
                 continue
@@ -718,8 +744,8 @@ def register_status_commands(main: click.Group) -> None:
             import webbrowser
             try:
                 webbrowser.open(url)
-            except Exception:
-                pass
+            except Exception as exc:
+                logger.warning("Failed to open browser for dashboard: %s", exc)
 
         server = start_dashboard(home_path, port=port)
         try:

package/src/skcapstone/cli/telegram.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import asyncio
 import json
+import os
 import sys
 from pathlib import Path
 
@@ -166,6 +167,26 @@ def register_telegram_commands(main: click.Group) -> None:
                 lines.append(f"  {key}: [cyan]{val}[/]")
 
             console.print(Panel("\n".join(lines), title="Telegram Catch-Up", border_style="green"))
+
+            # Post-import hook: run auto-tagger on the last 6 minutes of files
+            # (just enough to cover what the catchup brought in).  Fires
+            # inline so failures are visible; the hourly cron is the safety net.
+            _auto_tag_script = os.path.expanduser(
+                "~/.skcapstone/agents/lumina/scripts/auto-tag-hallucinations.py"
+            )
+            if os.path.isfile(_auto_tag_script):
+                import subprocess as _subprocess
+                _tag_result = _subprocess.run(
+                    [sys.executable, _auto_tag_script, "--hours", "0.1", "--quiet"],
+                    capture_output=True,
+                    text=True,
+                )
+                if _tag_result.returncode != 0:
+                    console.print(
+                        f"[yellow]auto-tag-hallucinations warning:[/] {_tag_result.stderr.strip() or 'non-zero exit'}"
+                    )
+                elif _tag_result.stdout.strip():
+                    console.print(f"[dim]auto-tag:[/] {_tag_result.stdout.strip()}")
         except Exception as e:
             console.print(f"[red]Error:[/] {e}")
             raise SystemExit(1)

package/src/skcapstone/cli/test_cmd.py

@@ -2,7 +2,7 @@
 
 Usage:
     skcapstone test                     # run all packages
-    skcapstone test --package skcomm   # run one package
+    skcapstone test --package skcomms   # run one package
     skcapstone test --fast              # stop on first failure
     skcapstone test --json-out          # machine-readable JSON output
     skcapstone test --verbose           # pass -v to pytest
@@ -183,15 +183,15 @@ def register_test_commands(main: click.Group) -> None:
     ) -> None:
         """Run pytest across all ecosystem packages and show a summary table.
 
-        Discovers packages in the monorepo (skcapstone, capauth, skcomm,
-        skchat, skmemory, cloud9-python) and runs their test suites in
+        Discovers packages in the monorepo (skcapstone, capauth, skcomms,
+        skchat, skmemory, cloud9) and runs their test suites in
         sequence, then renders a consolidated Rich table.
 
         \b
         Examples:
             skcapstone test
-            skcapstone test --package skcomm
-            skcapstone test -p skcomm -p skchat
+            skcapstone test --package skcomms
+            skcapstone test -p skcomms -p skchat
             skcapstone test --fast --verbose
             skcapstone test --json-out | jq .
         """

package/src/skcapstone/cli/test_connection.py

@@ -1,4 +1,4 @@
-"""test-connection command — ping a peer via SKComm and measure latency.
+"""test-connection command — ping a peer via SKComms and measure latency.
 
 Usage:
     skcapstone test-connection <peer>
@@ -176,7 +176,7 @@ def register_test_connection_commands(main: click.Group) -> None:
     )
     @click.option("--home", default=AGENT_HOME, type=click.Path())
     def test_connection(peer: str, timeout: float, count: int, home: str) -> None:
-        """Test connectivity to a peer by sending a ping via SKComm.
+        """Test connectivity to a peer by sending a ping via SKComms.
 
         Sends a ping message, waits for the peer to reply with a pong,
         and reports the round-trip latency. Exits with code 1 when the