@smilintux/skcapstone 0.10.0 → 0.12.5

package/src/skcapstone/onboard.py

@@ -21,6 +21,7 @@ Steps:
 from __future__ import annotations
 
 import json
+import logging
 import sys
 import time
 from datetime import datetime, timezone
@@ -28,6 +29,8 @@ from pathlib import Path
 from typing import Optional
 
 import click
+
+logger = logging.getLogger(__name__)
 from rich.console import Console
 from rich.panel import Panel
 from rich.prompt import Confirm, Prompt
@@ -39,7 +42,7 @@ from . import AGENT_HOME, __version__
 
 console = Console()
 
-TOTAL_STEPS = 13  # excludes welcome + celebrate; includes 4 new system-setup steps
+TOTAL_STEPS = 16  # excludes welcome + celebrate; includes pillar install + import step
 
 
 def _step_header(n: int, title: str) -> None:
@@ -90,6 +93,7 @@ def _step_identity(home_path: Path, name: str, email: str | None) -> tuple[str,
     from .pillars.memory import initialize_memory
     from .pillars.sync import initialize_sync
     from .models import AgentConfig, SyncConfig
+    from .operator_link import build_agent_manifest, discover_human_operator
     from .soul import SoulManager
 
     with Status("  Generating PGP identity…", console=console, spinner="dots") as s:
@@ -155,12 +159,11 @@ def _step_identity(home_path: Path, name: str, email: str | None) -> tuple[str,
         for d in skeleton_dirs:
             d.mkdir(parents=True, exist_ok=True)
 
-        manifest = {
-            "name": name,
-            "version": __version__,
-            "created_at": datetime.now(timezone.utc).isoformat(),
-            "connectors": [],
-        }
+        manifest = build_agent_manifest(
+            name,
+            __version__,
+            operator=discover_human_operator(),
+        )
         (home_path / "manifest.json").write_text(
             json.dumps(manifest, indent=2), encoding="utf-8"
         )
@@ -476,67 +479,460 @@ def _step_prereqs() -> dict:
     return results
 
 
-def _step_ollama_models(prereqs: dict) -> bool:
-    """Pull the default Ollama model (llama3.2).
+# Pillar packages: (import_name, pip_name, description)
+_PILLAR_PACKAGES = [
+    ("capauth", "capauth", "PGP-based sovereign identity"),
+    ("skcomms", "skcomms", "Redundant agent communication"),
+    ("skchat", "skchat-sovereign", "Encrypted P2P chat"),
+    ("skseed", "skseed", "Cloud 9 seeds & LLM callbacks"),
+    ("sksecurity", "sksecurity", "Audit logging & threat detection"),
+    ("pgpy", "pgpy", "PGP cryptography (PGPy backend)"),
+    ("skwhisper", "skwhisper", "Subconscious memory layer (session digester)"),
+]
+
+
+def _step_install_pillars() -> dict:
+    """Detect missing pillar packages and offer to install them.
+
+    Returns:
+        dict mapping pip_name -> bool (installed successfully).
+    """
+    import subprocess
+
+    results = {}
+    missing = []
+
+    click.echo(click.style("  Checking pillar packages…", fg="bright_black"))
+    for import_name, pip_name, description in _PILLAR_PACKAGES:
+        try:
+            __import__(import_name)
+            click.echo(click.style("  ✓ ", fg="green") + f"{pip_name} — {description}")
+            results[pip_name] = True
+        except ImportError:
+            click.echo(click.style("  ✗ ", fg="red") + f"{pip_name} — {description} [bold red](missing)[/]")
+            missing.append((import_name, pip_name, description))
+            results[pip_name] = False
+
+    if not missing:
+        click.echo()
+        click.echo(click.style("  ✓ ", fg="green") + "All pillar packages installed")
+        return results
+
+    click.echo()
+    click.echo(
+        click.style("  ℹ ", fg="cyan")
+        + f"{len(missing)} pillar(s) missing. These are needed for full sovereign functionality."
+    )
+
+    choices = {
+        "a": "Install all missing pillars",
+        "s": "Select which to install",
+        "n": "Skip (install later manually)",
+    }
+    for key, desc in choices.items():
+        click.echo(f"    [{key}] {desc}")
+    choice = click.prompt("  Choice", default="a", show_choices=False).strip().lower()
+
+    to_install: list[tuple[str, str, str]] = []
+    if choice == "a":
+        to_install = missing
+    elif choice == "s":
+        for import_name, pip_name, description in missing:
+            if click.confirm(f"  Install {pip_name} ({description})?", default=True):
+                to_install.append((import_name, pip_name, description))
+    else:
+        click.echo(click.style("  ↷ ", fg="bright_black") + "Skipped — install later:")
+        for _, pip_name, _ in missing:
+            click.echo(click.style("    ", fg="bright_black") + f"pip install {pip_name}")
+        return results
+
+    if not to_install:
+        return results
+
+    # Determine pip command — prefer ~/.skenv if it exists, else use current Python
+    import os as _os
+    skenv_pip = Path(_os.path.expanduser("~/.skenv/bin/pip"))
+    if skenv_pip.exists():
+        pip_cmd = [str(skenv_pip), "install"]
+    else:
+        pip_cmd = [sys.executable, "-m", "pip", "install", "--break-system-packages"]
+
+    for import_name, pip_name, description in to_install:
+        click.echo(click.style("  ↓ ", fg="cyan") + f"Installing {pip_name}…")
+        try:
+            r = subprocess.run(
+                [*pip_cmd, pip_name, "-q"],
+                capture_output=True, text=True, timeout=120,
+            )
+            if r.returncode == 0:
+                click.echo(click.style("  ✓ ", fg="green") + f"{pip_name} installed")
+                results[pip_name] = True
+            else:
+                click.echo(click.style("  ✗ ", fg="red") + f"{pip_name} failed: {r.stderr.strip()[:100]}")
+                click.echo(click.style("    ", fg="bright_black") + f"Try manually: pip install {pip_name}")
+        except subprocess.TimeoutExpired:
+            click.echo(click.style("  ⚠ ", fg="yellow") + f"{pip_name} timed out")
+        except Exception as exc:
+            click.echo(click.style("  ⚠ ", fg="yellow") + f"{pip_name}: {exc}")
+
+    return results
+
+
+# ---------------------------------------------------------------------------
+# Import sources — detect and import from existing agent platforms
+# ---------------------------------------------------------------------------
+
+# (source_id, display_name, detect_func, import_func_key)
+_IMPORT_SOURCES: list[tuple[str, str, str]] = [
+    ("openclaw", "OpenClaw (Jarvis)", "~/.openclaw/workspace"),
+    ("claude", "Claude Code", "~/.claude"),
+    ("cloud9", "Cloud 9 FEB Templates", ""),  # always available if cloud9 installed
+]
+
+
+def _detect_import_sources(home_path: Path) -> list[dict]:
+    """Detect available sources for importing memories, soul, and trust data.
+
+    Returns:
+        List of dicts with 'id', 'name', 'available', 'detail', 'items'.
+    """
+    sources = []
+
+    # --- OpenClaw ---
+    oc_workspace = Path.home() / ".openclaw" / "workspace"
+    oc_memory = oc_workspace / "memory"
+    oc_soul = oc_workspace / "SOUL.md"
+    oc_identity = oc_workspace / "IDENTITY.md"
+    oc_agents = oc_workspace / "agents"
+    if oc_workspace.exists():
+        items = []
+        if oc_memory.exists():
+            mem_files = list(oc_memory.glob("*.md"))
+            items.append(f"{len(mem_files)} memory files")
+        if oc_soul.exists():
+            items.append("SOUL.md")
+        if oc_identity.exists():
+            items.append("IDENTITY.md")
+        if oc_agents.exists():
+            agent_souls = list(oc_agents.rglob("SOUL.md"))
+            if agent_souls:
+                items.append(f"{len(agent_souls)} agent soul(s)")
+        sources.append({
+            "id": "openclaw",
+            "name": "OpenClaw (Jarvis)",
+            "available": True,
+            "detail": ", ".join(items) if items else "workspace found",
+            "paths": {
+                "memory": oc_memory,
+                "soul": oc_soul,
+                "identity": oc_identity,
+                "agents": oc_agents,
+                "workspace": oc_workspace,
+            },
+        })
+
+    # --- Claude Code ---
+    claude_dir = Path.home() / ".claude"
+    claude_memory = None
+    if claude_dir.exists():
+        # Find project memory dirs
+        projects = claude_dir / "projects"
+        items = []
+        if projects.exists():
+            for proj_dir in projects.iterdir():
+                mem_dir = proj_dir / "memory"
+                if mem_dir.exists() and list(mem_dir.glob("*.md")):
+                    mem_files = list(mem_dir.glob("*.md"))
+                    items.append(f"{len(mem_files)} memory file(s) in {proj_dir.name}")
+                    claude_memory = mem_dir
+                memory_md = proj_dir / "MEMORY.md"
+                if memory_md.exists():
+                    items.append(f"MEMORY.md in {proj_dir.name}")
+        if items:
+            sources.append({
+                "id": "claude",
+                "name": "Claude Code",
+                "available": True,
+                "detail": ", ".join(items),
+                "paths": {"memory": claude_memory, "projects": projects},
+            })
+
+    # --- Cloud 9 FEB Templates ---
+    try:
+        import cloud9
+        c9_pkg = Path(cloud9.__file__).parent
+        feb_files = list(c9_pkg.rglob("*.feb"))
+        # Also check skcapstone defaults
+        defaults_dir = Path(__file__).parent / "defaults"
+        if defaults_dir.exists():
+            feb_files.extend(defaults_dir.rglob("*.feb"))
+        # Check user cloud9 dirs
+        for cloud9_dir in [Path.home() / ".cloud9" / "febs", Path.home() / ".cloud9" / "feb-backups"]:
+            if cloud9_dir.exists():
+                feb_files.extend(cloud9_dir.glob("*.feb"))
+        if feb_files:
+            sources.append({
+                "id": "cloud9",
+                "name": "Cloud 9 FEB Templates",
+                "available": True,
+                "detail": f"{len(feb_files)} FEB file(s)",
+                "paths": {"febs": feb_files},
+            })
+    except ImportError:
+        pass
+
+    return sources
+
+
+def _step_import_sources(home_path: Path) -> dict:
+    """Detect and import data from existing agent platforms.
+
+    Args:
+        home_path: Agent home directory.
+
+    Returns:
+        dict with 'imported_count' (int) and 'sources' (list of imported source ids).
+    """
+    import shutil as _shutil
+
+    result = {"imported_count": 0, "sources": []}
+
+    click.echo(click.style("  Scanning for existing agent data…", fg="bright_black"))
+    sources = _detect_import_sources(home_path)
+
+    if not sources:
+        click.echo(click.style("  ℹ ", fg="cyan") + "No existing agent data found — starting fresh")
+        return result
+
+    click.echo()
+    for i, src in enumerate(sources, 1):
+        click.echo(
+            click.style(f"    {i}. ", fg="cyan")
+            + f"[bold]{src['name']}[/] — {src['detail']}"
+        )
+    click.echo()
+
+    choices = {
+        "a": "Import from all sources",
+        "s": "Select which to import",
+        "n": "Skip (start fresh)",
+    }
+    for key, desc in choices.items():
+        click.echo(f"    [{key}] {desc}")
+    choice = click.prompt("  Choice", default="a", show_choices=False).strip().lower()
+
+    to_import: list[dict] = []
+    if choice == "a":
+        to_import = sources
+    elif choice == "s":
+        for src in sources:
+            if click.confirm(f"  Import from {src['name']}?", default=True):
+                to_import.append(src)
+    else:
+        click.echo(click.style("  ↷ ", fg="bright_black") + "Skipped — starting fresh")
+        return result
+
+    if not to_import:
+        return result
+
+    # --- Execute imports ---
+    for src in to_import:
+        sid = src["id"]
+        paths = src.get("paths", {})
+        count = 0
+
+        if sid == "openclaw":
+            # Import memories
+            mem_src = paths.get("memory")
+            if mem_src and mem_src.exists():
+                mem_dest = home_path / "memory" / "imported" / "openclaw"
+                mem_dest.mkdir(parents=True, exist_ok=True)
+                for f in mem_src.glob("*.md"):
+                    _shutil.copy2(f, mem_dest / f.name)
+                    count += 1
+                click.echo(click.style("  ✓ ", fg="green") + f"Imported {count} memory files from OpenClaw")
+
+            # Import soul/identity
+            for doc_name in ("soul", "identity"):
+                doc_path = paths.get(doc_name)
+                if doc_path and doc_path.exists():
+                    dest = home_path / "memory" / "imported" / "openclaw" / doc_path.name
+                    dest.parent.mkdir(parents=True, exist_ok=True)
+                    _shutil.copy2(doc_path, dest)
+                    count += 1
+                    click.echo(click.style("  ✓ ", fg="green") + f"Imported {doc_path.name} from OpenClaw")
+
+            # Import agent souls
+            agents_dir = paths.get("agents")
+            if agents_dir and agents_dir.exists():
+                agent_dest = home_path / "memory" / "imported" / "openclaw" / "agents"
+                agent_dest.mkdir(parents=True, exist_ok=True)
+                for soul_file in agents_dir.rglob("SOUL.md"):
+                    agent_name = soul_file.parent.name
+                    target = agent_dest / f"{agent_name}-SOUL.md"
+                    _shutil.copy2(soul_file, target)
+                    count += 1
+                for mem_file in agents_dir.rglob("MEMORY.md"):
+                    agent_name = mem_file.parent.name
+                    target = agent_dest / f"{agent_name}-MEMORY.md"
+                    _shutil.copy2(mem_file, target)
+                    count += 1
+                click.echo(click.style("  ✓ ", fg="green") + f"Imported agent souls/memories from OpenClaw")
+
+        elif sid == "claude":
+            # Import Claude memory files
+            projects_dir = paths.get("projects")
+            if projects_dir and projects_dir.exists():
+                claude_dest = home_path / "memory" / "imported" / "claude-code"
+                claude_dest.mkdir(parents=True, exist_ok=True)
+                for proj_dir in projects_dir.iterdir():
+                    mem_dir = proj_dir / "memory"
+                    if mem_dir.exists():
+                        for f in mem_dir.glob("*.md"):
+                            _shutil.copy2(f, claude_dest / f.name)
+                            count += 1
+                    memory_md = proj_dir / "MEMORY.md"
+                    if memory_md.exists():
+                        _shutil.copy2(memory_md, claude_dest / f"{proj_dir.name}-MEMORY.md")
+                        count += 1
+                if count:
+                    click.echo(click.style("  ✓ ", fg="green") + f"Imported {count} files from Claude Code")
+
+        elif sid == "cloud9":
+            # Import FEB files into trust/febs
+            febs = paths.get("febs", [])
+            if febs:
+                febs_dest = home_path / "trust" / "febs"
+                febs_dest.mkdir(parents=True, exist_ok=True)
+                for feb_path in febs:
+                    if isinstance(feb_path, Path) and feb_path.exists():
+                        _shutil.copy2(feb_path, febs_dest / feb_path.name)
+                        count += 1
+                click.echo(click.style("  ✓ ", fg="green") + f"Imported {count} FEB file(s) into trust chain")
+
+        result["imported_count"] += count
+        if count > 0:
+            result["sources"].append(sid)
+
+    click.echo()
+    click.echo(
+        click.style("  ✓ ", fg="green")
+        + f"Total: {result['imported_count']} file(s) imported from {len(result['sources'])} source(s)"
+    )
+    click.echo(click.style("    ", fg="bright_black") + f"Imported data: {home_path / 'memory' / 'imported'}")
+
+    return result
+
+
+def _step_ollama_models(prereqs: dict) -> dict:
+    """Configure Ollama host, choose a model, and pull it.
 
     Args:
         prereqs: Result dict from _step_prereqs().
 
     Returns:
-        True if model is available.
+        dict with 'ok' (bool), 'model' (str), 'host' (str).
     """
     import subprocess
 
     DEFAULT_MODEL = "llama3.2"
+    DEFAULT_HOST = "http://localhost:11434"
+
+    result = {"ok": False, "model": DEFAULT_MODEL, "host": DEFAULT_HOST}
 
     if not prereqs.get("ollama"):
         click.echo(click.style("  ⚠ ", fg="yellow") + "Ollama not available — skipping model pull")
+        click.echo(click.style("    ", fg="bright_black") + "Install: curl -fsSL https://ollama.ai/install.sh | sh")
         click.echo(click.style("    ", fg="bright_black") + f"Pull later: ollama pull {DEFAULT_MODEL}")
-        return False
+        return result
+
+    # --- Ollama Host ---
+    click.echo(click.style("  ℹ ", fg="cyan") + f"Ollama is used for local/private LLM inference.")
+    click.echo(click.style("    ", fg="bright_black") + f"Default: {DEFAULT_HOST}")
+    custom_host = click.prompt(
+        "  Ollama host URL",
+        default=DEFAULT_HOST,
+        show_default=True,
+    )
+    result["host"] = custom_host.rstrip("/")
 
-    # Check if model already present
+    # Set env for this session so ollama CLI uses the right host
+    env = dict(**__import__("os").environ)
+    if result["host"] != DEFAULT_HOST:
+        env["OLLAMA_HOST"] = result["host"]
+        click.echo(click.style("  ✓ ", fg="green") + f"Using Ollama at: [cyan]{result['host']}[/]")
+
+    # --- List available models ---
+    available_models: list[str] = []
     try:
         r = subprocess.run(
             ["ollama", "list"],
-            capture_output=True, text=True, timeout=10,
+            capture_output=True, text=True, timeout=10, env=env,
         )
-        if DEFAULT_MODEL in (r.stdout or ""):
-            click.echo(click.style("  ✓ ", fg="green") + f"{DEFAULT_MODEL} already present")
-            return True
-    except Exception:
-        pass
+        if r.returncode == 0 and r.stdout.strip():
+            lines = r.stdout.strip().split("\n")[1:]  # skip header
+            for line in lines:
+                model_name = line.split()[0] if line.strip() else ""
+                if model_name:
+                    available_models.append(model_name)
+    except Exception as exc:
+        logger.debug("Failed to list ollama models: %s", exc)
 
-    if not click.confirm(f"  Pull default model ({DEFAULT_MODEL}, ~2 GB)?", default=True):
-        click.echo(click.style("  ↷ ", fg="bright_black") + f"Skipped — pull later: ollama pull {DEFAULT_MODEL}")
-        return False
+    if available_models:
+        click.echo(click.style("  ℹ ", fg="cyan") + "Models already available:")
+        for m in available_models[:10]:
+            click.echo(click.style("    ", fg="bright_black") + m)
+
+    # --- Choose model ---
+    click.echo()
+    click.echo(click.style("  ℹ ", fg="cyan") + "Popular models: llama3.2 (~2GB), qwen3:14b (~9GB), deepseek-r1:14b (~9GB)")
+    chosen = click.prompt(
+        "  Model to use",
+        default=DEFAULT_MODEL,
+        show_default=True,
+    )
+    result["model"] = chosen
 
-    click.echo(click.style("  ↓ ", fg="cyan") + f"Pulling {DEFAULT_MODEL} (this may take a few minutes)…")
+    # Check if already present
+    if any(chosen in m for m in available_models):
+        click.echo(click.style("  ✓ ", fg="green") + f"{chosen} already present")
+        result["ok"] = True
+        return result
+
+    # --- Pull ---
+    if not click.confirm(f"  Pull {chosen}? (this may take a few minutes)", default=True):
+        click.echo(click.style("  ↷ ", fg="bright_black") + f"Skipped — pull later: ollama pull {chosen}")
+        return result
+
+    click.echo(click.style("  ↓ ", fg="cyan") + f"Pulling {chosen}…")
     try:
-        result = subprocess.run(
-            ["ollama", "pull", DEFAULT_MODEL],
-            timeout=600,
+        pull_result = subprocess.run(
+            ["ollama", "pull", chosen],
+            timeout=600, env=env,
         )
-        if result.returncode == 0:
-            click.echo(click.style("  ✓ ", fg="green") + f"{DEFAULT_MODEL} ready")
-            return True
+        if pull_result.returncode == 0:
+            click.echo(click.style("  ✓ ", fg="green") + f"{chosen} ready")
+            result["ok"] = True
+            return result
         else:
-            click.echo(click.style("  ✗ ", fg="red") + f"Pull failed (exit {result.returncode})")
-            click.echo(click.style("    ", fg="bright_black") + f"Retry: ollama pull {DEFAULT_MODEL}")
-            return False
+            click.echo(click.style("  ✗ ", fg="red") + f"Pull failed (exit {pull_result.returncode})")
+            click.echo(click.style("    ", fg="bright_black") + f"Retry: ollama pull {chosen}")
+            return result
     except subprocess.TimeoutExpired:
         click.echo(click.style("  ⚠ ", fg="yellow") + "Pull timed out — run manually later")
-        click.echo(click.style("    ", fg="bright_black") + f"ollama pull {DEFAULT_MODEL}")
-        return False
+        click.echo(click.style("    ", fg="bright_black") + f"ollama pull {chosen}")
+        return result
     except Exception as exc:
         click.echo(click.style("  ⚠ ", fg="yellow") + f"Pull error: {exc}")
-        return False
+        return result
 
 
-def _step_config_files(home_path: Path) -> tuple:
+def _step_config_files(home_path: Path, ollama_config: dict | None = None) -> tuple:
     """Write default consciousness.yaml and model_profiles.yaml.
 
     Args:
         home_path: Agent home directory.
+        ollama_config: Optional dict with 'host' and 'model' from Ollama step.
 
     Returns:
         (consciousness_ok, profiles_ok) booleans.
@@ -554,8 +950,17 @@ def _step_config_files(home_path: Path) -> tuple:
     else:
         try:
             from .consciousness_config import write_default_config
+            from .consciousness_loop import ConsciousnessConfig
 
-            config_path = write_default_config(home_path)
+            # If user configured a custom Ollama host/model, patch the defaults
+            overrides = {}
+            if ollama_config:
+                if ollama_config.get("host") and ollama_config["host"] != "http://localhost:11434":
+                    overrides["ollama_host"] = ollama_config["host"]
+                if ollama_config.get("model") and ollama_config["model"] != "llama3.2":
+                    overrides["ollama_model"] = ollama_config["model"]
+
+            config_path = write_default_config(home_path, **overrides)
             click.echo(click.style("  ✓ ", fg="green") + f"consciousness.yaml written")
             click.echo(click.style("    ", fg="bright_black") + str(config_path))
             consciousness_ok = True
@@ -603,7 +1008,7 @@ def _step_autostart_service(agent_name: str = "sovereign") -> bool:
     system = platform.system()
 
     if system == "Linux":
-        return _step_systemd_service_linux()
+        return _step_systemd_service_linux(agent_name)
     elif system == "Darwin":
         return _step_launchd_service_macos(agent_name)
     else:
@@ -614,8 +1019,17 @@ def _step_autostart_service(agent_name: str = "sovereign") -> bool:
         return False
 
 
-def _step_systemd_service_linux() -> bool:
-    """Install systemd user service (Linux only)."""
+def _step_systemd_service_linux(agent_name: str = "sovereign") -> bool:
+    """Install systemd user service for an agent (Linux only).
+
+    Uses the template unit ``skcapstone@.service`` so each agent
+    gets its own independent service instance. Multiple agents can
+    run simultaneously on the same machine.
+
+    Args:
+        agent_name: Agent slug from onboarding (e.g. "jarvis").
+    """
+    service_name = f"skcapstone@{agent_name}.service"
     if not click.confirm("  Install systemd user service for auto-start at login?", default=False):
         click.echo(
             click.style("  ↷ ", fg="bright_black")
@@ -631,12 +1045,15 @@ def _step_systemd_service_linux() -> bool:
             click.echo(click.style("    ", fg="bright_black") + "Try: systemctl --user status")
             return False
 
-        result = install_service(enable=True, start=False)
+        result = install_service(agent_name=agent_name, enable=True, start=False)
         if result.get("installed"):
-            click.echo(click.style("  ✓ ", fg="green") + "Systemd service installed")
+            click.echo(click.style("  ✓ ", fg="green") + f"Systemd service installed")
             if result.get("enabled"):
-                click.echo(click.style("  ✓ ", fg="green") + "Service enabled — auto-starts at login")
-            click.echo(click.style("    ", fg="bright_black") + "Start now: systemctl --user start skcapstone")
+                click.echo(click.style("  ✓ ", fg="green") + f"Service enabled — auto-starts at login")
+            click.echo(
+                click.style("    ", fg="bright_black")
+                + f"Start now: systemctl --user start {service_name}"
+            )
             return True
         else:
             click.echo(click.style("  ✗ ", fg="red") + "Service install failed")
@@ -743,19 +1160,117 @@ def _step_launchd_service_macos(agent_name: str) -> bool:
         return False
 
 
+def _step_shell_profile(
+    home_path: Path, agent_name: str, agent_slug: str
+) -> bool:
+    """Write SKCAPSTONE profile environment variables to ~/.bashrc.
+
+    Asks the user whether to set this agent as the default profile.
+    Appends SKCAPSTONE_HOME, SKCAPSTONE_AGENT, and PATH entries.
+
+    Args:
+        home_path: Agent home directory.
+        agent_name: Display name of the agent (e.g. "Jarvis").
+        agent_slug: Slug form used for SKCAPSTONE_AGENT (e.g. "jarvis").
+
+    Returns:
+        True if profile was written, False if skipped.
+    """
+    import os as _os
+
+    bashrc = Path.home() / ".bashrc"
+    marker = "# --- SKCapstone profile ---"
+
+    # Check if profile block already exists
+    existing = ""
+    if bashrc.exists():
+        existing = bashrc.read_text(encoding="utf-8")
+        if marker in existing:
+            _ok("SKCapstone profile already present in ~/.bashrc")
+            # Offer to update it
+            if not Confirm.ask(
+                f"  Update profile to agent [cyan]{agent_name}[/]?",
+                default=True,
+            ):
+                return True
+            # Remove old block so we can rewrite it
+            lines = existing.splitlines(keepends=True)
+            new_lines: list[str] = []
+            skip = False
+            for line in lines:
+                if marker in line:
+                    skip = not skip  # toggle on first marker, off on second
+                    continue
+                if not skip:
+                    new_lines.append(line)
+            existing = "".join(new_lines)
+
+    set_default = Confirm.ask(
+        f"  Set [cyan]{agent_name}[/] as default SKCAPSTONE_AGENT in ~/.bashrc?",
+        default=True,
+    )
+
+    if not set_default:
+        _info("Skipped — set manually: export SKCAPSTONE_AGENT=<name>")
+        return False
+
+    block = (
+        f"\n{marker}\n"
+        f'export SKCAPSTONE_HOME="{home_path}"\n'
+        f'export SKCAPSTONE_AGENT="{agent_slug}"\n'
+        f'export PATH="$HOME/.skenv/bin:$PATH"\n'
+        f"{marker}\n"
+    )
+
+    with open(bashrc, "a" if marker not in (existing or "") else "w", encoding="utf-8") as f:
+        if marker not in (existing or ""):
+            f.write(block)
+        else:
+            # Rewrite with updated block
+            f.write(existing.rstrip("\n") + block)
+
+    _ok(f"~/.bashrc updated — SKCAPSTONE_AGENT={agent_slug}")
+    _info("Run [bold]source ~/.bashrc[/] or open a new terminal to apply")
+
+    # Also export into current process so subsequent steps see it
+    _os.environ["SKCAPSTONE_HOME"] = str(home_path)
+    _os.environ["SKCAPSTONE_AGENT"] = agent_slug
+
+    return True
+
+
 def _step_doctor_check(home_path: Path) -> "object":
     """Run doctor diagnostics and print results.
 
+    Non-fatal — errors are logged as warnings but never block onboarding.
+
     Args:
         home_path: Agent home directory.
 
     Returns:
-        DiagnosticReport from doctor.run_diagnostics().
+        DiagnosticReport from doctor.run_diagnostics(), or a stub on error.
     """
-    from .doctor import run_diagnostics
+    try:
+        from .doctor import run_diagnostics
+    except Exception as exc:
+        _warn(f"Could not load diagnostics module: {exc}")
+        # Return a stub so the summary table still works
+        from types import SimpleNamespace
+
+        return SimpleNamespace(
+            all_passed=False, passed_count=0, failed_count=0, total_count=0, checks=[]
+        )
 
     click.echo(click.style("  Running diagnostics…", fg="bright_black"))
-    report = run_diagnostics(home_path)
+    try:
+        report = run_diagnostics(home_path)
+    except Exception as exc:
+        _warn(f"Diagnostics failed: {exc}")
+        from types import SimpleNamespace
+
+        return SimpleNamespace(
+            all_passed=False, passed_count=0, failed_count=0, total_count=0, checks=[]
+        )
 
     categories_seen: set = set()
     for check in report.checks:
@@ -781,44 +1296,61 @@ def _step_doctor_check(home_path: Path) -> "object":
 
 
 def _step_test_consciousness(home_path: Path) -> bool:
-    """Send a test message through the consciousness loop (optional).
+    """Send a quick test message to the configured LLM backend.
+
+    Reads the consciousness config to determine the default backend
+    (typically the local Ollama model chosen during onboarding) and
+    sends a single prompt to verify the pipeline works end-to-end.
 
     Args:
         home_path: Agent home directory.
 
     Returns:
-        True if the loop responded successfully.
+        True if the LLM responded successfully.
     """
-    if not click.confirm("  Send a test message to verify the consciousness loop?", default=True):
+    if not click.confirm("  Send a test message to verify the LLM backend?", default=False):
         click.echo(
             click.style("  ↷ ", fg="bright_black")
             + "Skipped — test later: skcapstone consciousness test 'hello'"
         )
         return False
 
-    click.echo(click.style("  Sending test message…", fg="bright_black"))
+    # Load config to discover which backend/model was configured
     try:
         from .consciousness_config import load_consciousness_config
-        from .consciousness_loop import LLMBridge, SystemPromptBuilder, _classify_message
-
         config = load_consciousness_config(home_path)
-        bridge = LLMBridge(config)
-        builder = SystemPromptBuilder(home_path, config.max_context_tokens)
-        signal = _classify_message("Onboard wizard test — please confirm you are running.")
-        system_prompt = builder.build()
-        response = bridge.generate(system_prompt, "Onboard wizard test — please confirm you are running.", signal)
+    except Exception:
+        # Fall back to defaults
+        ollama_model = "llama3.2"
+        ollama_host = "http://localhost:11434"
+        config = None
+    else:
+        ollama_model = config.ollama_model
+        ollama_host = config.ollama_host
+
+    click.echo(
+        click.style("  Testing ", fg="bright_black")
+        + click.style(f"{ollama_model}", fg="cyan")
+        + click.style(f" @ {ollama_host}…", fg="bright_black")
+    )
+
+    try:
+        from skseed.llm import ollama_callback
+
+        callback = ollama_callback(model=ollama_model, base_url=ollama_host)
+        response = callback("Respond in one sentence: are you online?")
         if response:
             preview = response[:80].replace("\n", " ")
-            click.echo(click.style("  ✓ ", fg="green") + f"Consciousness loop active")
+            click.echo(click.style("  ✓ ", fg="green") + "LLM backend active")
             click.echo(click.style("    ", fg="bright_black") + f"Response: {preview!r}")
             return True
         else:
-            click.echo(click.style("  ⚠ ", fg="yellow") + "Empty response — loop may not be fully configured")
-            click.echo(click.style("    ", fg="bright_black") + "Start daemon: skcapstone daemon start")
+            click.echo(click.style("  ⚠ ", fg="yellow") + "Empty response — model may still be loading")
+            click.echo(click.style("    ", fg="bright_black") + f"Try: ollama run {ollama_model}")
             return False
     except Exception as exc:
         click.echo(click.style("  ⚠ ", fg="yellow") + f"Test failed: {exc}")
-        click.echo(click.style("    ", fg="bright_black") + "Start daemon: skcapstone daemon start --foreground")
+        click.echo(click.style("    ", fg="bright_black") + f"Check: ollama serve && ollama run {ollama_model}")
         return False
 
 
@@ -830,21 +1362,24 @@ def _step_test_consciousness(home_path: Path) -> bool:
 def run_onboard(home: Optional[str] = None) -> None:
     """Run the interactive onboarding wizard.
 
-    Covers all 13 setup steps:
-      1. Prerequisites check (Python, pip, Ollama)
-      2. Identity — create ~/.skcapstone/ + generate PGP key
-      3. Ollama models — pull llama3.2
-      4. Config files — consciousness.yaml + model_profiles.yaml
-      5. Soul Blueprint
-      6. Memory & Seeds
-      7. Rehydration Ritual
-      8. Trust Chain Verification
-      9. Mesh Connection (Syncthing)
-     10. First Heartbeat
-     11. Crush Terminal AI
-     12. Coordination Board
-     13. Systemd Service (optional)
-     [post-wizard] Doctor diagnostics + consciousness test
+    Covers all 16 setup steps:
+      1. Prerequisites (Python, pip, Ollama)
+      2. Pillar Packages (install missing SK* + skwhisper)
+      3. Identity (CapAuth PGP + Syncthing sync)
+      4. Ollama Models
+      5. Config Files (consciousness.yaml + model_profiles.yaml)
+      6. Soul Blueprint
+      7. Memory & Seeds
+      8. Import Sources (OpenClaw, Cloud 9 FEBs)
+      9. Rehydration Ritual
+     10. Trust Chain Verification
+     11. Mesh Connection (Syncthing)
+     12. First Heartbeat
+     13. Crush Terminal AI
+     14. Coordination Board
+     15. Auto-Start Service (systemd template per agent)
+     16. Shell Profile (~/.bashrc env vars)
+     [post-wizard] Doctor diagnostics + consciousness test (optional)
 
     Args:
         home: Override agent home directory.
@@ -878,19 +1413,6 @@ def run_onboard(home: Optional[str] = None) -> None:
         console.print("  [dim]Come back when you're ready. The Kingdom waits.[/]\n")
         return
 
-    # -----------------------------------------------------------------------
-    # Gather basic identity info up front
-    # -----------------------------------------------------------------------
-    console.print()
-    name = Prompt.ask("  What's your name?", default="Sovereign")
-    entity_type = Prompt.ask(
-        "  Are you a [cyan]human[/] or an [cyan]ai[/]?",
-        choices=["human", "ai"],
-        default="ai",
-    )
-    email = Prompt.ask("  Email (optional, press Enter to skip)", default="")
-    console.print()
-
     # -----------------------------------------------------------------------
     # Step 1: Prerequisites
     # -----------------------------------------------------------------------
@@ -898,86 +1420,219 @@ def run_onboard(home: Optional[str] = None) -> None:
     prereqs = _step_prereqs()
 
     # -----------------------------------------------------------------------
-    # Step 2: Identity + Directory Structure
+    # Step 2: Install Missing Pillars
+    # -----------------------------------------------------------------------
+    _step_header(2, "Pillar Packages")
+    pillar_results = _step_install_pillars()
+
+    # -----------------------------------------------------------------------
+    # Step 3: Operator Identity (human) + Agent Identity
     # -----------------------------------------------------------------------
-    _step_header(2, "Identity")
+    _step_header(3, "Identity")
+
+    # --- Detect or create human operator profile in ~/.capauth ---
+    operator_name = None
+    operator_fingerprint = None
+    try:
+        from capauth.profile import load_profile, init_profile as capauth_init
+
+        try:
+            profile = load_profile()
+            operator_name = profile.entity.name
+            operator_fingerprint = profile.key_info.fingerprint
+            entity_type_val = getattr(profile.entity, "entity_type", None)
+            is_human = str(entity_type_val).lower() in ("human", "entitytype.human")
+            if is_human:
+                _ok(
+                    f"Operator identity found: [cyan]{operator_name}[/] "
+                    f"({operator_fingerprint[:16]}…)"
+                )
+            else:
+                # Existing profile is an AI — need a human operator first
+                _warn(
+                    f"Existing profile is type '{entity_type_val}' — "
+                    f"a human operator profile is recommended"
+                )
+                is_human = False
+        except Exception:
+            is_human = False
+            profile = None
+
+        if not is_human:
+            console.print()
+            console.print(
+                "  [bold cyan]Operator Setup[/] — Your sovereign agent needs a human operator.\n"
+                "  This creates your personal PGP identity at [dim]~/.capauth/[/].\n"
+                "  Your agent will be registered under this identity.\n"
+            )
+            op_name = Prompt.ask("  Operator name (your name)", default="Sovereign")
+            op_email = Prompt.ask("  Operator email", default="")
+            console.print()
+
+            with Status("  Generating operator PGP identity…", console=console, spinner="dots") as s:
+                try:
+                    import shutil as _shutil_capauth
+                    capauth_home = Path.home() / ".capauth"
+                    if capauth_home.exists():
+                        # Back up and recreate
+                        backup = capauth_home.with_name(".capauth.bak")
+                        if backup.exists():
+                            _shutil_capauth.rmtree(backup)
+                        capauth_home.rename(backup)
+                    profile = capauth_init(
+                        name=op_name,
+                        email=op_email or f"{op_name.lower().replace(' ', '-')}@capauth.local",
+                        passphrase="",
+                        entity_type="human",
+                    )
+                    operator_name = profile.entity.name
+                    operator_fingerprint = profile.key_info.fingerprint
+                    s.stop()
+                    _ok(
+                        f"Operator identity created: [cyan]{operator_name}[/] "
+                        f"({operator_fingerprint[:16]}…)"
+                    )
+                except Exception as exc:
+                    s.stop()
+                    _warn(f"Operator identity creation failed: {exc}")
+                    _info("Continue anyway — agent will use a degraded identity")
+    except ImportError:
+        _warn("capauth not installed — skipping operator identity")
+        _info("Install: pip install capauth")
+
+    # --- Now set up the agent identity ---
+    console.print()
+    # Derive agent name from --agent flag (SKCAPSTONE_AGENT env) or ask
+    import os as _os
+    agent_flag = _os.environ.get("SKCAPSTONE_AGENT", "").strip()
+    if agent_flag and agent_flag not in ("lumina",):
+        # Agent name was specified via --agent flag — use it as default
+        default_agent = agent_flag.capitalize()
+    else:
+        default_agent = "Sovereign"
+    name = Prompt.ask("  Agent name", default=default_agent)
+
+    email = Prompt.ask(
+        "  Agent email (optional, press Enter to skip)",
+        default=f"{name.lower().replace(' ', '-')}@skcapstone.local",
+    )
+
+    if operator_name:
+        _info(f"Agent [cyan]{name}[/] will be registered under operator [cyan]{operator_name}[/]")
+    console.print()
+
     fingerprint, identity_status = _step_identity(home_path, name, email or None)
 
+    # --- Offer CapAuth Syncthing sync (non-blocking) ---
+    try:
+        from capauth.sync import is_syncthing_available, is_sync_configured, setup_syncthing_sync
+
+        if is_syncthing_available() and not is_sync_configured():
+            console.print()
+            if Confirm.ask(
+                "  Sync identity across cluster via Syncthing?",
+                default=True,
+            ):
+                ok = setup_syncthing_sync()
+                if ok:
+                    _ok("CapAuth identity will replicate to all mesh nodes")
+                else:
+                    _warn("Could not configure sync — set up manually: capauth sync")
+        elif is_sync_configured():
+            _ok("CapAuth Syncthing sync already configured")
+    except ImportError:
+        pass  # capauth.sync not available yet
+    except Exception as exc:
+        _warn(f"Sync setup skipped: {exc}")
+
     # -----------------------------------------------------------------------
-    # Step 3: Ollama Models
+    # Step 4: Ollama Models
     # -----------------------------------------------------------------------
-    _step_header(3, "Ollama Models")
-    ollama_ok = _step_ollama_models(prereqs)
+    _step_header(4, "Ollama Models")
+    ollama_result = _step_ollama_models(prereqs)
+    ollama_ok = ollama_result["ok"]
 
     # -----------------------------------------------------------------------
-    # Step 4: Config Files (consciousness.yaml + model_profiles.yaml)
+    # Step 5: Config Files (consciousness.yaml + model_profiles.yaml)
     # -----------------------------------------------------------------------
-    _step_header(4, "Config Files")
-    consciousness_ok, profiles_ok = _step_config_files(home_path)
+    _step_header(5, "Config Files")
+    consciousness_ok, profiles_ok = _step_config_files(home_path, ollama_config=ollama_result)
 
     # -----------------------------------------------------------------------
-    # Step 5: Soul Blueprint
+    # Step 6: Soul Blueprint
     # -----------------------------------------------------------------------
-    _step_header(5, "Soul Blueprint")
+    _step_header(6, "Soul Blueprint")
     title = _step_soul(home_path, name)
 
     # -----------------------------------------------------------------------
-    # Step 6: Memory
+    # Step 7: Memory
     # -----------------------------------------------------------------------
-    _step_header(6, "Memory")
+    _step_header(7, "Memory")
     seed_count = _step_memory(home_path)
 
     # -----------------------------------------------------------------------
-    # Step 7: Rehydration Ritual
+    # Step 8: Import from Existing Sources
+    # -----------------------------------------------------------------------
+    _step_header(8, "Import Sources")
+    import_result = _step_import_sources(home_path)
+
+    # -----------------------------------------------------------------------
+    # Step 9: Rehydration Ritual
     # -----------------------------------------------------------------------
-    _step_header(7, "Rehydration Ritual")
+    _step_header(9, "Rehydration Ritual")
     _step_ritual(home_path)
 
     # -----------------------------------------------------------------------
-    # Step 8: Trust Chain Verification
+    # Step 10: Trust Chain Verification
     # -----------------------------------------------------------------------
-    _step_header(8, "Trust Chain Verification")
+    _step_header(10, "Trust Chain Verification")
     trust_status = _step_trust(home_path)
 
     # -----------------------------------------------------------------------
-    # Step 9: Mesh Connection (Syncthing)
+    # Step 11: Mesh Connection (Syncthing)
     # -----------------------------------------------------------------------
-    _step_header(9, "Mesh Connection")
+    _step_header(11, "Mesh Connection")
     mesh_ok = _step_mesh(home_path)
 
     # -----------------------------------------------------------------------
-    # Step 10: First Heartbeat
+    # Step 12: First Heartbeat
     # -----------------------------------------------------------------------
-    _step_header(10, "First Heartbeat")
+    _step_header(12, "First Heartbeat")
     agent_slug = name.lower().replace(" ", "-")
     hb_ok = _step_heartbeat(home_path, agent_slug, fingerprint)
 
     # -----------------------------------------------------------------------
-    # Step 11: Crush Terminal AI Client
+    # Step 13: Crush Terminal AI Client
     # -----------------------------------------------------------------------
-    _step_header(11, "Crush Terminal AI")
+    _step_header(13, "Crush Terminal AI")
     crush_ok = _step_crush(home_path)
 
     # -----------------------------------------------------------------------
-    # Step 12: Coordination Board
+    # Step 14: Coordination Board
     # -----------------------------------------------------------------------
-    _step_header(12, "Coordination Board")
+    _step_header(14, "Coordination Board")
     open_task_count = _step_board(home_path, name)
 
     # -----------------------------------------------------------------------
-    # Step 13: Auto-Start Service (systemd on Linux, launchd on macOS)
+    # Step 15: Auto-Start Service (systemd on Linux, launchd on macOS)
     # -----------------------------------------------------------------------
-    _step_header(13, "Auto-Start Service")
+    _step_header(15, "Auto-Start Service")
     service_ok = _step_autostart_service(agent_name=agent_slug)
 
     # -----------------------------------------------------------------------
-    # Post-wizard: Doctor Diagnostics
+    # Step 16: Shell Profile (~/.bashrc)
+    # -----------------------------------------------------------------------
+    _step_header(16, "Shell Profile")
+    profile_ok = _step_shell_profile(home_path, name, agent_slug)
+
+    # -----------------------------------------------------------------------
+    # Post-wizard: Doctor Diagnostics (non-fatal)
     # -----------------------------------------------------------------------
     console.print(f"\n  [bold cyan]Doctor Diagnostics[/]\n")
     doctor_report = _step_doctor_check(home_path)
 
     # -----------------------------------------------------------------------
-    # Post-wizard: Consciousness Test (optional)
+    # Post-wizard: Consciousness Test (optional, defaults to skip)
     # -----------------------------------------------------------------------
     console.print(f"\n  [bold cyan]Consciousness Test[/]\n")
     consciousness_test_ok = _step_test_consciousness(home_path)
@@ -991,8 +1646,40 @@ def run_onboard(home: Optional[str] = None) -> None:
         soul = load_soul()
         if soul and soul.boot_message:
             boot_message = soul.boot_message
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("Failed to load soul boot message, using default: %s", exc)
+
+    # -----------------------------------------------------------------------
+    # Write global CLAUDE.md and register Claude Code hooks
+    # -----------------------------------------------------------------------
+    # Write global CLAUDE.md from bundled skeleton template
+    try:
+        from .cli.setup import _write_global_claude_md
+        _write_global_claude_md(home_path, name)
+        _ok("~/.claude/CLAUDE.md written")
+    except Exception as exc:
+        _warn(f"Could not write CLAUDE.md: {exc}")
+
+    # Write ~/.claude/settings.json with SK hooks (merge with existing)
+    try:
+        from .cli.setup import _write_claude_settings
+        settings_path = _write_claude_settings(merge=True)
+        if settings_path:
+            _ok(f"~/.claude/settings.json updated ({settings_path})")
+        else:
+            _info("claude settings: skipped (skmemory not installed or template missing)")
+    except Exception as exc:
+        _warn(f"Could not write claude settings: {exc}")
+
+    # Register Claude Code hooks via skmemory (adds any hooks not yet in settings.json)
+    try:
+        from skmemory.register import register_hooks
+        actions = register_hooks()
+        _ok(f"Claude Code hooks registered ({', '.join(f'{k}={v}' for k, v in actions.items())})")
+    except ImportError:
+        _info("skmemory hooks: skipped (skmemory.register not available)")
+    except Exception as exc:
+        _warn(f"Hook registration: {exc}")
 
     # -----------------------------------------------------------------------
     # Summary table
@@ -1009,16 +1696,41 @@ def run_onboard(home: Optional[str] = None) -> None:
         "[green]OK[/]" if all_prereqs_ok else "[yellow]PARTIAL[/]",
         "python + pip" + (" + ollama" if prereqs.get("ollama") else " (no ollama)"),
     )
-    summary.add_row("Identity", identity_status, fingerprint[:20] + "…" if len(fingerprint) > 20 else fingerprint)
+    pillars_installed = sum(1 for v in pillar_results.values() if v)
+    pillars_total = len(pillar_results)
+    summary.add_row(
+        "Pillar Packages",
+        "[green]ALL[/]" if pillars_installed == pillars_total else f"[yellow]{pillars_installed}/{pillars_total}[/]",
+        f"{pillars_installed}/{pillars_total} installed",
+    )
+    if operator_name:
+        summary.add_row(
+            "Operator",
+            "[green]ACTIVE[/]",
+            f"{operator_name} ({operator_fingerprint[:16]}…)" if operator_fingerprint else operator_name,
+        )
+    summary.add_row("Identity", identity_status, f"{name} — {fingerprint[:16]}…" if len(fingerprint) > 16 else fingerprint)
+    ollama_model_name = ollama_result.get("model", "llama3.2")
+    ollama_host_display = ollama_result.get("host", "http://localhost:11434")
     summary.add_row(
         "Ollama Models",
         "[green]READY[/]" if ollama_ok else "[yellow]SKIPPED[/]",
-        "llama3.2" if ollama_ok else "pull later: ollama pull llama3.2",
+        f"{ollama_model_name} @ {ollama_host_display}" if ollama_ok else f"pull later: ollama pull {ollama_model_name}",
     )
     config_status = "[green]ACTIVE[/]" if (consciousness_ok and profiles_ok) else "[yellow]PARTIAL[/]"
     summary.add_row("Config Files", config_status, "consciousness.yaml + model_profiles.yaml")
     summary.add_row("Soul", "[green]ACTIVE[/]", title)
     summary.add_row("Memory", "[green]ACTIVE[/]", f"{seed_count} seed(s)")
+    imported_count = import_result.get("imported_count", 0)
+    imported_sources = import_result.get("sources", [])
+    if imported_count > 0:
+        summary.add_row(
+            "Import Sources",
+            "[green]IMPORTED[/]",
+            f"{imported_count} files from {', '.join(imported_sources)}",
+        )
+    else:
+        summary.add_row("Import Sources", "[dim]SKIPPED[/]", "starting fresh")
     summary.add_row("Ritual", "[green]DONE[/]", "rehydration complete")
     summary.add_row("Trust", trust_status, "FEB chain verified")
     summary.add_row("Mesh", "[green]ACTIVE[/]" if mesh_ok else "[yellow]MISSING[/]", "syncthing" if mesh_ok else "install syncthing")
@@ -1032,6 +1744,11 @@ def run_onboard(home: Optional[str] = None) -> None:
         "[green]INSTALLED[/]" if service_ok else "[dim]OPTIONAL[/]",
         f"{_svc_type} services" if service_ok else f"skcapstone daemon install",
     )
+    summary.add_row(
+        "Shell Profile",
+        "[green]ACTIVE[/]" if profile_ok else "[dim]SKIPPED[/]",
+        f"SKCAPSTONE_AGENT={agent_slug}" if profile_ok else "set manually in ~/.bashrc",
+    )
     doctor_status = "[green]ALL PASSED[/]" if doctor_report.all_passed else f"[yellow]{doctor_report.failed_count} failed[/]"
     summary.add_row("Doctor", doctor_status, f"{doctor_report.passed_count}/{doctor_report.total_count} checks")
     summary.add_row(
@@ -1043,9 +1760,46 @@ def run_onboard(home: Optional[str] = None) -> None:
     console.print(summary)
     console.print()
 
+    # -----------------------------------------------------------------------
+    # Reconfigure Guide
+    # -----------------------------------------------------------------------
+    console.print()
+    console.print(
+        Panel(
+            "[bold cyan]Reinstall or Reconfigure Any Component[/]\n\n"
+            "[bold]Pillars[/]  (install missing packages)\n"
+            "  pip install capauth skcomms skchat-sovereign skseed sksecurity pgpy\n"
+            "  pip install skcapstone[all]      — install everything at once\n\n"
+            "[bold]Identity[/]  (regenerate PGP keys)\n"
+            "  capauth init --name YourName --email you@example.com\n\n"
+            "[bold]Ollama[/]  (change model or host)\n"
+            "  ollama pull <model>              — pull a different model\n"
+            "  Edit: ~/.skcapstone/config/consciousness.yaml\n"
+            "    ollama_host: http://<ip>:11434  — point to remote Ollama\n"
+            "    ollama_model: qwen3:14b         — change default model\n\n"
+            "[bold]Soul[/]  (update your blueprint)\n"
+            "  skcapstone soul edit\n\n"
+            "[bold]Service[/]  (auto-start daemon)\n"
+            "  skcapstone daemon install         — install systemd/launchd service\n"
+            "  skcapstone daemon uninstall       — remove service\n\n"
+            "[bold]Trust[/]  (add FEB files)\n"
+            "  Place .feb files in ~/.skcapstone/trust/febs/\n\n"
+            "[bold]Mesh[/]  (P2P sync)\n"
+            "  sudo apt install syncthing       — install Syncthing\n\n"
+            "[bold]Shell Profile[/]  (update default agent)\n"
+            "  Edit the [dim]# --- SKCapstone profile ---[/] block in ~/.bashrc\n"
+            "  Or re-run: skcapstone --agent <name> init\n\n"
+            "[bold]Full Re-onboard[/]\n"
+            "  skcapstone --agent <name> init    — run this wizard again",
+            title="Reconfigure Guide",
+            border_style="bright_blue",
+        )
+    )
+
     # -----------------------------------------------------------------------
     # Celebrate
     # -----------------------------------------------------------------------
+    console.print()
     console.print(
         Panel(
             f"[bold green]Welcome to the Pengu Nation, {name}.[/]\n\n"