@smilintux/skcapstone 0.10.0 → 0.12.5

package/src/skcapstone/service_health.py

@@ -21,10 +21,13 @@ from __future__ import annotations
 import json
 import logging
 import os
+import re
 import socket
 import time
 import urllib.error
+from pathlib import Path
 import urllib.request
+from urllib.parse import urlparse
 from typing import Any
 
 logger = logging.getLogger("skcapstone.service_health")
@@ -32,6 +35,86 @@ logger = logging.getLogger("skcapstone.service_health")
 # Default timeout per service check (seconds).
 CHECK_TIMEOUT = 3
 
+# Hostname tag used to attribute one-time state-transition notes (e.g. a
+# service recovering) to the reporting node. Recurring "still down" notes are
+# intentionally never written — see _create_incident_for_down_service and
+# prb-7810b08e for why that churn caused Syncthing conflicts.
+_HOSTNAME = socket.gethostname()
+
+
+
+# ---------------------------------------------------------------------------
+# Per-agent YAML config fallback
+# ---------------------------------------------------------------------------
+
+def _load_agent_yaml(config_name: str, agent: str | None = None) -> dict:
+    """Load ~/.skcapstone/agents/<agent>/config/<config_name>.yaml.
+
+    Falls back gracefully when the file or yaml lib is unavailable. Used by
+    check_all_services() so the laptop's jarvis daemon can read the same
+    correctly-populated skvector.yaml / skgraph.yaml that skmemory uses,
+    instead of probing localhost defaults that don't exist here.
+    """
+    if not agent:
+        agent = (
+            os.environ.get("SKAGENT")
+            or os.environ.get("SKCAPSTONE_AGENT")
+            or os.environ.get("SKMEMORY_AGENT")
+            or "lumina"
+        )
+    path = os.path.expanduser(f"~/.skcapstone/agents/{agent}/config/{config_name}.yaml")
+    if not os.path.exists(path):
+        return {}
+    try:
+        import yaml  # type: ignore
+        with open(path) as f:
+            data = yaml.safe_load(f) or {}
+        return data if isinstance(data, dict) else {}
+    except Exception as exc:
+        logger.debug("Failed to load %s: %s", path, exc)
+        return {}
+
+
+
+def _load_syncthing_config() -> tuple[str | None, str | None]:
+    """Read ~/.config/syncthing/config.xml to get GUI URL + API key.
+
+    Returns (url, api_key) tuple — either may be None if the config can't
+    be parsed. Uses regex (no XML lib dep) since we only need 2 small fields.
+    """
+    candidates = [
+        Path.home() / ".config" / "syncthing" / "config.xml",
+        Path.home() / ".local" / "state" / "syncthing" / "config.xml",
+    ]
+    cfg_path = next((p for p in candidates if p.exists()), None)
+    if cfg_path is None:
+        return None, None
+    try:
+        text = cfg_path.read_text()
+    except Exception:
+        return None, None
+
+    # Find <gui ...> ... <address>HOST:PORT</address> ... </gui>
+    gui_match = re.search(
+        r"<gui[^>]*>(.*?)</gui>", text, re.S | re.I
+    )
+    addr_in_gui = None
+    if gui_match:
+        body = gui_match.group(1)
+        addr_match = re.search(r"<address>\s*([^<]+?)\s*</address>", body, re.I)
+        if addr_match:
+            addr_in_gui = addr_match.group(1).strip()
+
+    api_match = re.search(r"<apikey>\s*([^<]+?)\s*</apikey>", text, re.I)
+    api_key = api_match.group(1).strip() if api_match else None
+
+    if not addr_in_gui:
+        return None, api_key
+    # GUI tls flag
+    tls = bool(gui_match and ("tls=\"true\"" in gui_match.group(0) or "tls='true'" in gui_match.group(0)))
+    proto = "https" if tls else "http"
+    return f"{proto}://{addr_in_gui}", api_key
+
 
 # ---------------------------------------------------------------------------
 # Individual service checks
@@ -76,8 +159,8 @@ def _http_check(
                 try:
                     body = json.loads(resp.read().decode("utf-8"))
                     result["version"] = body.get(version_key)
-                except Exception:
-                    pass
+                except Exception as exc:
+                    logger.warning("Failed to parse version from service health response: %s", exc)
     except urllib.error.HTTPError as exc:
         latency = (time.monotonic() - t0) * 1000
         result["latency_ms"] = round(latency, 1)
@@ -130,6 +213,34 @@ def _tcp_check(name: str, host: str, port: int) -> dict[str, Any]:
     return result
 
 
+def _pid_check(name: str, pid_path: Path) -> dict[str, Any]:
+    """Check a local daemon that advertises health through a PID file."""
+    result: dict[str, Any] = {
+        "name": name,
+        "url": f"pid://{pid_path}",
+        "status": "unknown",
+        "latency_ms": 0,
+        "version": None,
+        "error": None,
+    }
+    t0 = time.monotonic()
+    try:
+        pid = int(pid_path.read_text(encoding="utf-8").strip())
+        os.kill(pid, 0)
+        result["status"] = "up"
+    except FileNotFoundError:
+        result["status"] = "down"
+        result["error"] = "PID file missing"
+    except ProcessLookupError:
+        result["status"] = "down"
+        result["error"] = "process not found"
+    except Exception as exc:
+        result["status"] = "down"
+        result["error"] = str(exc)[:200]
+    result["latency_ms"] = round((time.monotonic() - t0) * 1000, 1)
+    return result
+
+
 # ---------------------------------------------------------------------------
 # Aggregate check
 # ---------------------------------------------------------------------------
@@ -138,14 +249,22 @@ def _tcp_check(name: str, host: str, port: int) -> dict[str, Any]:
 def check_all_services() -> list[dict[str, Any]]:
     """Ping every known service and return a list of status dicts.
 
-    Environment variables override default URLs:
-        SKMEMORY_SKVECTOR_URL   — Qdrant REST base (default http://localhost:6333)
-        SKMEMORY_SKGRAPH_HOST   — FalkorDB host   (default localhost)
-        SKMEMORY_SKGRAPH_PORT   — FalkorDB port   (default 6379)
-        SYNCTHING_API_URL       — Syncthing REST   (default http://localhost:8384)
-        SYNCTHING_API_KEY       — Syncthing API key (optional)
-        SKCAPSTONE_DAEMON_URL   — Daemon HTTP base (default http://localhost:9383)
-        SKCHAT_DAEMON_URL       — SKChat daemon    (default http://localhost:9385)
+    Environment variables override default URLs (set any to "disabled" to skip):
+        SKMEMORY_SKVECTOR_URL     — Qdrant REST base (default: read from
+                                    ~/.skcapstone/agents/<agent>/config/skvector.yaml,
+                                    else http://localhost:6333)
+        SKMEMORY_SKVECTOR_API_KEY — Qdrant API key (default: from skvector.yaml)
+        SKMEMORY_SKGRAPH_HOST     — FalkorDB host   (default: read from
+                                    ~/.skcapstone/agents/<agent>/config/skgraph.yaml,
+                                    else localhost)
+        SKMEMORY_SKGRAPH_PORT     — FalkorDB port   (default: from skgraph.yaml,
+                                    else 6379)
+        SYNCTHING_API_URL         — Syncthing REST   (default: discovered from
+                                    ~/.config/syncthing/config.xml gui address,
+                                    else http://localhost:8384)
+        SYNCTHING_API_KEY         — Syncthing API key (default: from config.xml)
+        SKCAPSTONE_DAEMON_URL     — Daemon HTTP base (default http://localhost:9383)
+        SKCHAT_DAEMON_URL         — SKChat daemon    (default http://localhost:9385)
 
     Returns:
         List of dicts, each containing: name, url, status ("up"|"down"|"unknown"),
@@ -154,30 +273,85 @@ def check_all_services() -> list[dict[str, Any]]:
     results: list[dict[str, Any]] = []
 
     # -- SKVector (Qdrant) --------------------------------------------------
-    qdrant_base = os.environ.get("SKMEMORY_SKVECTOR_URL", "http://localhost:6333")
-    qdrant_url = qdrant_base.rstrip("/") + "/healthz"
-    results.append(_http_check("skvector (Qdrant)", qdrant_url))
+    qdrant_base = os.environ.get("SKMEMORY_SKVECTOR_URL", "")
+    qdrant_api_key = os.environ.get("SKMEMORY_SKVECTOR_API_KEY", "")
+    # Fall back to per-agent skvector.yaml when env vars are absent
+    if not qdrant_base or not qdrant_api_key:
+        cfg = _load_agent_yaml("skvector")
+        if cfg.get("enabled", True):
+            if not qdrant_base:
+                if cfg.get("url"):
+                    qdrant_base = str(cfg["url"])
+                else:
+                    # Reconstruct URL from host/port/https
+                    host = cfg.get("host", "localhost")
+                    port = cfg.get("port", 6333)
+                    proto = "https" if cfg.get("https") or int(port) == 443 else "http"
+                    if int(port) in (80, 443):
+                        qdrant_base = f"{proto}://{host}"
+                    else:
+                        qdrant_base = f"{proto}://{host}:{port}"
+            if not qdrant_api_key and cfg.get("api_key") and cfg["api_key"] != "CHANGE_ME":
+                qdrant_api_key = cfg["api_key"]
+    if not qdrant_base:
+        qdrant_base = "http://localhost:6333"
+    if qdrant_base.lower() != "disabled":
+        qdrant_url = qdrant_base.rstrip("/") + "/healthz"
+        qdrant_headers: dict[str, str] = {}
+        if qdrant_api_key:
+            qdrant_headers["api-key"] = qdrant_api_key
+        results.append(_http_check("skvector (Qdrant)", qdrant_url, headers=qdrant_headers))
 
     # -- SKGraph (FalkorDB) — TCP check on Redis protocol port ---------------
-    graph_host = os.environ.get("SKMEMORY_SKGRAPH_HOST", "localhost")
-    graph_port = int(os.environ.get("SKMEMORY_SKGRAPH_PORT", "6379"))
-    results.append(_tcp_check("skgraph (FalkorDB)", graph_host, graph_port))
+    graph_host = os.environ.get("SKMEMORY_SKGRAPH_HOST", "")
+    graph_port_str = os.environ.get("SKMEMORY_SKGRAPH_PORT", "")
+    # Fall back to per-agent skgraph.yaml when env vars are absent
+    if not graph_host or not graph_port_str:
+        cfg = _load_agent_yaml("skgraph")
+        if cfg.get("enabled", True):
+            if cfg.get("url") and (not graph_host or not graph_port_str):
+                parsed = urlparse(str(cfg["url"]))
+                if not graph_host and parsed.hostname:
+                    graph_host = parsed.hostname
+                if not graph_port_str and parsed.port:
+                    graph_port_str = str(parsed.port)
+            if not graph_host and cfg.get("host"):
+                graph_host = str(cfg["host"])
+            if not graph_port_str and cfg.get("port"):
+                graph_port_str = str(cfg["port"])
+    if not graph_host:
+        graph_host = "localhost"
+    if not graph_port_str:
+        graph_port_str = "6379"
+    if graph_host.lower() != "disabled":
+        graph_port = int(graph_port_str)
+        results.append(_tcp_check("skgraph (FalkorDB)", graph_host, graph_port))
 
     # -- Syncthing -----------------------------------------------------------
-    syncthing_base = os.environ.get("SYNCTHING_API_URL", "http://localhost:8384")
-    syncthing_url = syncthing_base.rstrip("/") + "/rest/system/status"
-    syncthing_headers: dict[str, str] = {}
+    syncthing_base = os.environ.get("SYNCTHING_API_URL", "")
     api_key = os.environ.get("SYNCTHING_API_KEY", "")
-    if api_key:
-        syncthing_headers["X-API-Key"] = api_key
-    results.append(
-        _http_check(
-            "syncthing",
-            syncthing_url,
-            headers=syncthing_headers,
-            version_key="version",
+    # Fall back to ~/.config/syncthing/config.xml discovery
+    if not syncthing_base or not api_key:
+        discovered_url, discovered_key = _load_syncthing_config()
+        if not syncthing_base and discovered_url:
+            syncthing_base = discovered_url
+        if not api_key and discovered_key:
+            api_key = discovered_key
+    if not syncthing_base:
+        syncthing_base = "http://localhost:8384"
+    if syncthing_base.lower() != "disabled":
+        syncthing_url = syncthing_base.rstrip("/") + "/rest/system/status"
+        syncthing_headers: dict[str, str] = {}
+        if api_key:
+            syncthing_headers["X-API-Key"] = api_key
+        results.append(
+            _http_check(
+                "syncthing",
+                syncthing_url,
+                headers=syncthing_headers,
+                version_key="version",
+            )
         )
-    )
 
     # -- skcapstone daemon ---------------------------------------------------
     daemon_base = os.environ.get("SKCAPSTONE_DAEMON_URL", "http://localhost:9383")
@@ -185,13 +359,70 @@ def check_all_services() -> list[dict[str, Any]]:
     results.append(_http_check("skcapstone daemon", daemon_url))
 
     # -- skchat daemon -------------------------------------------------------
-    chat_base = os.environ.get("SKCHAT_DAEMON_URL", "http://localhost:9385")
-    chat_url = chat_base.rstrip("/") + "/health"
-    results.append(_http_check("skchat daemon", chat_url))
+    chat_base = os.environ.get("SKCHAT_DAEMON_URL", "")
+    if not chat_base:
+        results.append(_pid_check("skchat daemon", Path.home() / ".skchat" / "daemon.pid"))
+    elif chat_base.lower() != "disabled":
+        chat_url = chat_base.rstrip("/") + "/health"
+        results.append(_http_check("skchat daemon", chat_url))
+
+    # -- self-registered services (~/.skcapstone/registry/*.json) ------------
+    # Services that called sdk.register_service() become discoverable here
+    # without being hardcoded above. Names already covered by a built-in
+    # check are skipped (built-in wins) so there are no duplicates.
+    known = {r["name"] for r in results}
+    for entry in _load_registry_entries():
+        name = entry.get("name")
+        if not name or name in known:
+            continue
+        health_url = entry.get("health_url")
+        pid_file = entry.get("pid_file")
+        if health_url and str(health_url).lower() != "disabled":
+            results.append(_http_check(name, str(health_url).rstrip("/")))
+        elif pid_file:
+            results.append(_pid_check(name, Path(pid_file).expanduser()))
+        else:
+            results.append({
+                "name": name, "url": None, "status": "unknown",
+                "latency_ms": None, "version": None,
+                "error": "registered without health_url or pid_file",
+            })
+        known.add(name)
 
     return results
 
 
+def _load_registry_entries() -> list[dict[str, Any]]:
+    """Load service self-registration entries from the discovery registry.
+
+    Reads every ``<shared_home>/registry/*.json`` file written by
+    :func:`skcapstone.sdk.register_service`. Missing directory or malformed
+    files are skipped silently — discovery is best-effort.
+
+    Returns:
+        A list of registry entry dicts (each with at least a ``name`` key).
+    """
+    import json
+
+    try:
+        from . import shared_home
+
+        registry_dir = shared_home() / "registry"
+    except Exception:
+        return []
+
+    if not registry_dir.is_dir():
+        return []
+
+    entries: list[dict[str, Any]] = []
+    for path in sorted(registry_dir.glob("*.json")):
+        try:
+            entries.append(json.loads(path.read_text(encoding="utf-8")))
+        except (json.JSONDecodeError, OSError):
+            continue
+    return entries
+
+
 # ---------------------------------------------------------------------------
 # Scheduled-task factory
 # ---------------------------------------------------------------------------
@@ -209,18 +440,23 @@ def _create_incident_for_down_service(service_result: dict[str, Any]) -> None:
         from .itil import ITILManager
 
         svc_name = service_result["name"]
+        error_info = service_result.get("error") or "unreachable"
         mgr = ITILManager(os.path.expanduser(SHARED_ROOT))
 
-        # Dedup: skip if there's already an open incident for this service
+        # Dedup: already tracked by an open incident → do nothing.
+        # We deliberately do NOT append recurring "still down" notes. That
+        # read-modify-write churn on a Syncthing-synced incident file, from
+        # multiple nodes every health cycle, is exactly what produced the
+        # sync-conflicts and 80+-entry timelines tracked in prb-7810b08e.
+        # Outage duration is derivable from the incident's created_at; the
+        # recovery (down->up) edge is handled by _auto_resolve_recovered_service.
         existing = mgr.find_open_incident_for_service(svc_name)
         if existing:
             logger.debug(
-                "Skipping incident creation for %s — open incident %s exists",
+                "Service %s already tracked by incident %s; no note appended",
                 svc_name, existing.id,
             )
             return
-
-        error_info = service_result.get("error") or "unreachable"
         mgr.create_incident(
             title=f"{svc_name} down",
             severity="sev3",
@@ -258,10 +494,14 @@ def _auto_resolve_recovered_service(service_result: dict[str, Any]) -> None:
             logger.info("Auto-resolved sev4 incident %s for recovered service %s",
                         existing.id, svc_name)
         else:
-            mgr.update_incident(
-                existing.id, "service_health",
-                note=f"Service {svc_name} appears to be back up",
-            )
+            # Skip if this host already noted recovery recently
+            last_notes = [e.get("note", "") for e in (existing.timeline or [])[-3:]]
+            host_tag = f"[{_HOSTNAME}]"
+            if not any(host_tag in n and "back up" in n for n in last_notes):
+                mgr.update_incident(
+                    existing.id, "service_health",
+                    note=f"[{_HOSTNAME}] Service {svc_name} appears to be back up",
+                )
     except Exception as exc:
         logger.debug("Failed to auto-resolve incident for %s: %s",
                       service_result.get("name"), exc)

package/src/skcapstone/session_briefing.py

@@ -0,0 +1,108 @@
+"""Session briefing helpers for SKCapstone startup flows."""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from .context_loader import format_text, gather_context
+
+
+DEFAULT_HAMMERTIME_ROOT = Path("/mnt/cloud/onedrive/projects/DAVE AI/hammerTime")
+
+
+def _resolve_hammertime_root() -> Path:
+    """Resolve the HammerTime workspace root."""
+    return Path(os.environ.get("HAMMERTIME_ROOT", DEFAULT_HAMMERTIME_ROOT)).expanduser()
+
+
+def load_hammertime_briefing(
+    *,
+    python_bin: str | None = None,
+    root: Path | None = None,
+) -> dict[str, Any] | None:
+    """Load the HammerTime case briefing if the repo is available."""
+    if os.environ.get("SK_INCLUDE_HAMMERTIME_BRIEFING", "1") == "0":
+        return None
+
+    hammer_root = root or _resolve_hammertime_root()
+    script = hammer_root / "scripts" / "case-briefing.py"
+    if not script.exists():
+        return None
+
+    try:
+        completed = subprocess.run(
+            [python_bin or sys.executable, str(script)],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+    except (OSError, subprocess.CalledProcessError):
+        return None
+
+    try:
+        payload = json.loads(completed.stdout)
+    except json.JSONDecodeError:
+        return None
+    return payload if isinstance(payload, dict) else None
+
+
+def build_session_briefing(
+    home: Path,
+    *,
+    memory_limit: int = 10,
+    python_bin: str | None = None,
+) -> dict[str, Any]:
+    """Build a native session briefing payload."""
+    return {
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "agent_home": str(home),
+        "skcapstone_context": gather_context(home, memory_limit=memory_limit),
+        "hammertime_briefing": load_hammertime_briefing(python_bin=python_bin),
+    }
+
+
+def format_session_briefing_text(payload: dict[str, Any]) -> str:
+    """Render a human-readable session briefing."""
+    lines = [
+        "# SKCapstone Session Briefing",
+        "",
+        f"generated_at={payload.get('generated_at')}",
+        f"agent_home={payload.get('agent_home')}",
+        "",
+        "## skcapstone context",
+        format_text(payload["skcapstone_context"]).rstrip(),
+    ]
+
+    briefing = payload.get("hammertime_briefing")
+    if briefing:
+        top = briefing.get("top_priority") or {}
+        lines.extend(
+            [
+                "",
+                "## hammertime briefing",
+                f"- alert_count: {briefing.get('alert_count', 0)}",
+                f"- queue_size: {briefing.get('summary', {}).get('queue_size', 0)}",
+            ]
+        )
+        if top:
+            lines.extend(
+                [
+                    f"- do_this_now_incident: {top.get('incident_id')} ({top.get('problem_slug')})",
+                    f"- do_this_now_action: {top.get('action')}",
+                    f"- do_this_now_status: {top.get('status')}",
+                ]
+            )
+        for item in (briefing.get("focus_items") or [])[:3]:
+            lines.append(
+                f"- focus: {item.get('incident_id')} -> {item.get('action')} [{item.get('status')}]"
+            )
+    else:
+        lines.extend(["", "## hammertime briefing", "- unavailable"])
+
+    return "\n".join(lines).rstrip() + "\n"

package/src/skcapstone/session_capture.py

@@ -70,7 +70,7 @@ _TAG_PATTERNS: list[tuple[re.Pattern, str]] = [
     (re.compile(r"\bcapauth\b", re.I), "capauth"),
     (re.compile(r"\bskcapstone\b", re.I), "skcapstone"),
     (re.compile(r"\bskmemory\b", re.I), "skmemory"),
-    (re.compile(r"\bskcomm\b", re.I), "skcomm"),
+    (re.compile(r"\bskcomms\b", re.I), "skcomms"),
     (re.compile(r"\bskchat\b", re.I), "skchat"),
     (re.compile(r"\bsyncthing\b", re.I), "syncthing"),
     (re.compile(r"\bMCP\b", re.I), "mcp"),

package/src/skcapstone/shell.py

@@ -43,6 +43,9 @@ from rich.table import Table
 
 from . import AGENT_HOME, __version__
 
+import logging
+logger = logging.getLogger(__name__)
+
 console = Console()
 
 COMMANDS = [
@@ -98,7 +101,8 @@ def _agent_name() -> str:
         from .runtime import get_runtime
         runtime = get_runtime(_home())
         return runtime.manifest.name or "unknown"
-    except Exception:
+    except Exception as e:
+        logger.warning("shell.py: %s", e)
         return "unknown"
 
 
@@ -354,6 +358,7 @@ def _handle_chat(args: list[str]) -> None:
         except ImportError:
             console.print("  [yellow]Chat module not available[/]")
         except Exception as e:
+            logger.warning("shell.py: %s", e)
             console.print(f"  [red]{e}[/]")
 
     elif sub == "inbox":
@@ -669,6 +674,7 @@ def _dispatch_line(line: str) -> None:
         except _ExitShell:
             raise
         except Exception as exc:
+            logger.warning("shell.py: %s", exc)
             console.print(f"  [red]Error:[/] {exc}")
     else:
         console.print(f"  Unknown: [yellow]{cmd}[/].  Type [bold]help[/] for options.")

package/src/skcapstone/soul.py

@@ -435,6 +435,7 @@ def load_yaml_blueprint(path: Path) -> SoulBlueprint:
     try:
         return SoulBlueprint.model_validate(data)
     except Exception as exc:
+        logger.warning("soul.py: %s", exc)
         raise ValueError(f"Invalid blueprint data in {path}: {exc}") from exc
 
 
@@ -855,7 +856,8 @@ class SoulManager:
                                 "source": "github",
                                 "description": "",
                             }
-            except Exception:
+            except Exception as e:
+                logger.warning("soul.py: %s", e)
                 pass  # offline — show only installed souls
 
         # Sort by category, then name

package/src/skcapstone/soul_switch.py

@@ -102,7 +102,8 @@ def _load_state(home: Path) -> SoulSwitchState:
     try:
         data = json.loads(path.read_text(encoding="utf-8"))
         return SoulSwitchState.model_validate(data)
-    except Exception:
+    except Exception as e:
+        logger.warning("soul_switch.py: %s", e)
         return SoulSwitchState()
 
 
@@ -161,6 +162,7 @@ def load_switch_soul(home: Path, name: str) -> SoulSwitchBlueprint:
     try:
         return SoulSwitchBlueprint.model_validate(data)
     except Exception as exc:
+        logger.warning("soul_switch.py: %s", exc)
         raise ValueError(f"Invalid soul blueprint in {blueprint_path}: {exc}") from exc
 
 

package/src/skcapstone/summary.py

@@ -197,17 +197,17 @@ def _health_summary(home: Path) -> dict:
 
 
 def _inbox_summary(home: Path) -> dict:
-    """Count unread messages in the SKComm and SKChat inboxes."""
+    """Count unread messages in the SKComms and SKChat inboxes."""
     total = 0
     sources: list[str] = []
 
-    # SKComm file transport inbox
-    skcomm_inbox = home / "comms" / "inbox"
-    if skcomm_inbox.exists():
-        count = sum(1 for f in skcomm_inbox.iterdir() if f.is_file())
+    # SKComms file transport inbox
+    skcomms_inbox = home / "comms" / "inbox"
+    if skcomms_inbox.exists():
+        count = sum(1 for f in skcomms_inbox.iterdir() if f.is_file())
         if count:
             total += count
-            sources.append(f"skcomm:{count}")
+            sources.append(f"skcomms:{count}")
 
     # SKChat local inbox (skchat daemon stores messages here)
     skchat_inbox = home / "skchat" / "inbox"