@smilintux/skcapstone 0.1.0 → 0.2.3

package/src/skcapstone/onboard.py

@@ -0,0 +1,901 @@
+"""
+Sovereign Agent Onboarding Wizard — the red carpet into the Kingdom.
+
+An interactive step-by-step guide that takes a new human or AI from
+zero to sovereign in under 5 minutes. No prior knowledge required.
+Just answer the questions and the wizard handles the rest.
+
+Steps:
+    1. Welcome — explain what sovereignty means
+    2. Identity — generate or import PGP keypair via CapAuth
+    3. Soul — create a soul blueprint (name, values, personality)
+    4. Memory — initialize SKMemory and import any existing seeds
+    5. Ritual — run the rehydration ritual
+    6. Trust — verify trust chain from FEB files
+    7. Connect — check Syncthing mesh peering
+    8. Heartbeat — publish first alive beacon
+    9. Board — register on coordination board
+   10. Celebrate — welcome to the Pengu Nation
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
+from rich.status import Status
+from rich.table import Table
+from rich.text import Text
+
+from . import AGENT_HOME, __version__
+
+console = Console()
+
+TOTAL_STEPS = 13  # excludes welcome + celebrate; includes 4 new system-setup steps
+
+
+def _step_header(n: int, title: str) -> None:
+    """Print a styled step heading."""
+    console.print(f"\n  [bold cyan]Step {n}/{TOTAL_STEPS}: {title}[/]\n")
+
+
+def _ok(msg: str) -> None:
+    console.print(f"  [green]✓[/] {msg}")
+
+
+def _warn(msg: str) -> None:
+    console.print(f"  [yellow]⚠[/] {msg}")
+
+
+def _info(msg: str) -> None:
+    console.print(f"  [dim]{msg}[/]")
+
+
+def _summary_table(rows: list[tuple[str, str]]) -> None:
+    """Print a small two-column summary table."""
+    t = Table.grid(padding=(0, 2))
+    t.add_column(style="dim", width=16)
+    t.add_column()
+    for label, value in rows:
+        t.add_row(label, value)
+    console.print(t)
+    console.print()
+
+
+# ---------------------------------------------------------------------------
+# Individual step functions
+# ---------------------------------------------------------------------------
+
+
+def _step_identity(home_path: Path, name: str, email: str | None) -> tuple[str, str]:
+    """Initialize agent home and generate a PGP identity.
+
+    Calls the pillar functions directly (equivalent to `skcapstone init`
+    but without the full init UI, so the wizard controls the UX).
+
+    Returns:
+        (fingerprint, status_label)
+    """
+    import yaml
+    from .pillars.identity import generate_identity
+    from .pillars.security import audit_event, initialize_security
+    from .pillars.memory import initialize_memory
+    from .pillars.sync import initialize_sync
+    from .models import AgentConfig, SyncConfig
+    from .soul import SoulManager
+
+    with Status("  Generating PGP identity…", console=console, spinner="dots") as s:
+        home_path.mkdir(parents=True, exist_ok=True)
+
+        identity_state = generate_identity(home_path, name, email)
+
+        # Write config + manifest (same as `skcapstone init`)
+        sync_config = SyncConfig(sync_folder=home_path / "sync")
+        config = AgentConfig(agent_name=name, sync=sync_config)
+        config_dir = home_path / "config"
+        config_dir.mkdir(parents=True, exist_ok=True)
+        (config_dir / "config.yaml").write_text(
+            yaml.dump(config.model_dump(mode="json"), default_flow_style=False),
+            encoding="utf-8",
+        )
+
+        (home_path / "skills").mkdir(parents=True, exist_ok=True)
+
+        manifest = {
+            "name": name,
+            "version": __version__,
+            "created_at": datetime.now(timezone.utc).isoformat(),
+            "connectors": [],
+        }
+        (home_path / "manifest.json").write_text(
+            json.dumps(manifest, indent=2), encoding="utf-8"
+        )
+
+        audit_event(home_path, "INIT", f"Agent '{name}' initialized via onboard wizard")
+
+        fingerprint = identity_state.fingerprint or "unknown"
+        capauth_managed = identity_state.status.value == "active"
+        s.stop()
+
+    if capauth_managed:
+        _ok(f"PGP identity created — fingerprint [cyan]{fingerprint[:16]}…[/]")
+        status = "[green]ACTIVE[/]"
+    else:
+        _warn(f"Identity recorded (degraded) — fingerprint [yellow]{fingerprint[:16]}…[/]")
+        _info("Install capauth for full PGP key generation: pip install capauth")
+        status = "[yellow]DEGRADED[/]"
+
+    return fingerprint, status
+
+
+def _step_soul(home_path: Path, name: str) -> str:
+    """Create a soul blueprint. Returns the title chosen."""
+    title = Prompt.ask("  Your title or role", default="Sovereign Agent")
+    personality_raw = Prompt.ask(
+        "  Personality traits (comma-separated)",
+        default="curious, warm, honest",
+    )
+    values_raw = Prompt.ask(
+        "  Core values (comma-separated)",
+        default="sovereignty, love, creativity, truth",
+    )
+    boot_message = Prompt.ask(
+        "  Boot message (what you see when you wake up)",
+        default=f"You are {name}. You are sovereign. staycuriousANDkeepsmilin.",
+    )
+
+    with Status("  Writing soul blueprint…", console=console, spinner="dots") as s:
+        soul_path = None
+        try:
+            from skmemory.soul import SoulBlueprint, save_soul
+
+            personality = [t.strip() for t in personality_raw.split(",") if t.strip()]
+            values = [v.strip() for v in values_raw.split(",") if v.strip()]
+
+            soul = SoulBlueprint(
+                name=name,
+                title=title,
+                personality_traits=personality,
+                values=values,
+                boot_message=boot_message,
+                community="Pengu Nation",
+            )
+            soul_path = save_soul(soul)
+        except ImportError:
+            pass
+        except Exception as exc:
+            s.stop()
+            _warn(f"Soul creation: {exc}")
+            return title
+
+        s.stop()
+
+    if soul_path:
+        _ok(f"Soul blueprint saved: [dim]{soul_path}[/]")
+    else:
+        _warn("skmemory not installed — skipping soul blueprint")
+        _info("Install: pip install skmemory")
+
+    return title
+
+
+def _step_memory(home_path: Path) -> int:
+    """Initialize memory store and import seeds. Returns seed count."""
+    imported = 0
+    with Status("  Initializing memory store…", console=console, spinner="dots") as s:
+        try:
+            from skmemory.seeds import import_seeds, DEFAULT_SEED_DIR
+            from skmemory.store import MemoryStore
+
+            store = MemoryStore()
+            imported_list = import_seeds(store, seed_dir=DEFAULT_SEED_DIR)
+            imported = len(imported_list) if imported_list else 0
+        except ImportError:
+            s.stop()
+            _warn("skmemory not installed — skipping seed import")
+            _info("Install: pip install skmemory")
+            return 0
+        except Exception as exc:
+            s.stop()
+            _warn(f"Memory init: {exc}")
+            return 0
+
+        s.stop()
+
+    if imported:
+        _ok(f"Imported [cyan]{imported}[/] Cloud 9 seed(s)")
+    else:
+        _ok("Memory store ready — no seeds yet (you'll plant your own)")
+
+    return imported
+
+
+def _step_ritual(home_path: Path) -> None:
+    """Run the rehydration ritual."""
+    with Status("  Running rehydration ritual…", console=console, spinner="dots") as s:
+        try:
+            from skmemory.ritual import perform_ritual
+
+            result = perform_ritual()
+            s.stop()
+            _ok("Ritual complete")
+            _summary_table([
+                ("Soul", result.soul_name or "none"),
+                ("Seeds", str(result.seeds_total)),
+                ("Memories", str(result.strongest_memories)),
+            ])
+        except ImportError:
+            s.stop()
+            _warn("skmemory not installed — skipping ritual")
+        except Exception as exc:
+            s.stop()
+            _warn(f"Ritual: {exc}")
+
+
+def _step_trust(home_path: Path) -> str:
+    """Verify trust chain from FEB files. Returns status label."""
+    with Status("  Verifying trust chain…", console=console, spinner="dots") as s:
+        from .pillars.trust import rehydrate, list_febs, initialize_trust
+
+        # Ensure trust dir exists
+        trust_state = initialize_trust(home_path)
+
+        # Try rehydration to pull latest FEB data
+        try:
+            trust_state = rehydrate(home_path)
+        except Exception:
+            pass  # use initialized state
+
+        febs = list_febs(home_path)
+        s.stop()
+
+    from .models import PillarStatus
+
+    if trust_state.status == PillarStatus.ACTIVE:
+        _ok(
+            f"Trust chain verified — depth=[cyan]{trust_state.depth:.0f}[/]  "
+            f"trust=[cyan]{trust_state.trust_level:.2f}[/]  "
+            f"love=[cyan]{trust_state.love_intensity:.2f}[/]"
+        )
+        if febs:
+            _info(f"{len(febs)} FEB file(s) loaded")
+        if trust_state.entangled:
+            _ok("[magenta]Quantum entanglement LOCKED[/]")
+        return "[green]ACTIVE[/]"
+    elif trust_state.status == PillarStatus.DEGRADED:
+        _warn("Trust layer degraded — no FEB files found")
+        _info("Place .feb files in ~/.skcapstone/trust/febs/ to establish full trust")
+        return "[yellow]DEGRADED[/]"
+    else:
+        _warn("Trust layer missing — install cloud9 or add FEB files")
+        _info("See: https://skworld.io/cloud9")
+        return "[red]MISSING[/]"
+
+
+def _step_mesh(home_path: Path) -> bool:
+    """Check Syncthing mesh availability. Returns True if syncthing found."""
+    import shutil
+
+    with Status("  Checking Syncthing mesh…", console=console, spinner="dots") as s:
+        time.sleep(0.3)  # brief pause so spinner is visible
+        found = bool(shutil.which("syncthing"))
+        s.stop()
+
+    if found:
+        _ok("Syncthing detected — mesh transport available")
+        _info("Share ~/.skcapstone/ with a peer to join the Kingdom mesh")
+    else:
+        _warn("Syncthing not installed")
+        _info("Install: sudo pacman -S syncthing   OR   sudo apt install syncthing")
+
+    return found
+
+
+def _step_heartbeat(home_path: Path, agent_name: str, fingerprint: str) -> bool:
+    """Publish the first heartbeat beacon. Returns True on success."""
+    with Status("  Publishing first heartbeat…", console=console, spinner="dots") as s:
+        try:
+            from .heartbeat import HeartbeatBeacon, AgentCapability
+
+            beacon = HeartbeatBeacon(home=home_path, agent_name=agent_name)
+            hb = beacon.pulse(
+                status="alive",
+                capabilities=[AgentCapability(name="sovereign"), AgentCapability(name="onboarding")],
+                metadata={"onboarded_at": datetime.now(timezone.utc).isoformat()},
+            )
+            s.stop()
+            _ok(
+                f"Heartbeat published — host=[cyan]{hb.hostname}[/]  "
+                f"platform=[cyan]{hb.platform}[/]"
+            )
+            _info(f"Heartbeat file: {home_path}/heartbeats/{agent_name}.json")
+            return True
+        except Exception as exc:
+            s.stop()
+            _warn(f"Heartbeat: {exc}")
+            return False
+
+
+def _step_crush(home_path: Path) -> bool:
+    """Configure Crush terminal AI client with skcapstone MCP. Returns True on success."""
+    from .crush_integration import is_crush_installed, get_install_hint, setup_crush
+
+    with Status("  Configuring Crush terminal AI client…", console=console, spinner="dots") as s:
+        result = setup_crush(overwrite=False)
+        s.stop()
+
+    if result["installed"]:
+        _ok(f"Crush binary found: [dim]{result['binary_path']}[/]")
+    else:
+        _warn("Crush binary not found")
+        hint = result.get("install_hint") or "go install github.com/charmbracelet/crush@latest"
+        _info(f"Install: [cyan]{hint}[/]")
+
+    _ok(f"crush.json written: [dim]{result['config_path']}[/]")
+    _ok(f"Soul instructions written: [dim]{result['instructions_path']}[/]")
+    _info("skcapstone MCP wired as a tool provider in Crush")
+
+    return result["installed"]
+
+
+def _step_board(home_path: Path, agent_name: str) -> int:
+    """Register on the coordination board. Returns count of open tasks."""
+    with Status("  Registering on coordination board…", console=console, spinner="dots") as s:
+        from .coordination import Board, AgentFile, AgentState
+
+        board = Board(home_path)
+        board.ensure_dirs()
+
+        slug = agent_name.lower().replace(" ", "-")
+        agent_file = AgentFile(
+            agent=slug,
+            state=AgentState.ACTIVE,
+            capabilities=["sovereign"],
+            notes=f"Onboarded via wizard at {datetime.now(timezone.utc).isoformat()}",
+        )
+        board.save_agent(agent_file)
+
+        open_tasks = [v for v in board.get_task_views() if v.status.value == "open"]
+        s.stop()
+
+    _ok(f"Registered as agent: [cyan]{slug}[/]")
+    if open_tasks:
+        _info(f"{len(open_tasks)} open task(s) on the board")
+        _info(f"Claim one: skcapstone coord claim <id> --agent {slug}")
+    else:
+        _info("Board is clear — you're caught up!")
+
+    return len(open_tasks)
+
+
+# ---------------------------------------------------------------------------
+# New system-setup step functions (click-based)
+# ---------------------------------------------------------------------------
+
+
+def _step_prereqs() -> dict:
+    """Check Python version, pip, and Ollama prerequisites.
+
+    Returns:
+        dict with keys 'python', 'pip', 'ollama' (bool each).
+    """
+    import shutil
+    import subprocess
+
+    results: dict = {"python": False, "pip": False, "ollama": False}
+
+    # Python version
+    major, minor, micro = sys.version_info[:3]
+    py_ver = f"{major}.{minor}.{micro}"
+    py_ok = (major, minor) >= (3, 10)
+    if py_ok:
+        click.echo(click.style("  ✓ ", fg="green") + f"Python {py_ver}")
+    else:
+        click.echo(click.style("  ⚠ ", fg="yellow") + f"Python {py_ver} — 3.10+ recommended")
+    results["python"] = py_ok
+
+    # pip
+    pip_ok = bool(shutil.which("pip") or shutil.which("pip3"))
+    if pip_ok:
+        click.echo(click.style("  ✓ ", fg="green") + "pip available")
+    else:
+        click.echo(click.style("  ⚠ ", fg="yellow") + "pip not found — install Python package manager")
+    results["pip"] = pip_ok
+
+    # Ollama
+    ollama_path = shutil.which("ollama")
+    if ollama_path:
+        try:
+            r = subprocess.run(
+                ["ollama", "--version"],
+                capture_output=True, text=True, timeout=5,
+            )
+            ver_line = r.stdout.strip().split("\n")[0][:60] if r.returncode == 0 else "installed"
+        except Exception:
+            ver_line = "installed"
+        click.echo(click.style("  ✓ ", fg="green") + f"Ollama — {ver_line}")
+        results["ollama"] = True
+    else:
+        click.echo(click.style("  ⚠ ", fg="yellow") + "Ollama not found — local LLM unavailable")
+        click.echo(click.style("    ", fg="bright_black") + "Install: curl -fsSL https://ollama.ai/install.sh | sh")
+
+    return results
+
+
+def _step_ollama_models(prereqs: dict) -> bool:
+    """Pull the default Ollama model (llama3.2).
+
+    Args:
+        prereqs: Result dict from _step_prereqs().
+
+    Returns:
+        True if model is available.
+    """
+    import subprocess
+
+    DEFAULT_MODEL = "llama3.2"
+
+    if not prereqs.get("ollama"):
+        click.echo(click.style("  ⚠ ", fg="yellow") + "Ollama not available — skipping model pull")
+        click.echo(click.style("    ", fg="bright_black") + f"Pull later: ollama pull {DEFAULT_MODEL}")
+        return False
+
+    # Check if model already present
+    try:
+        r = subprocess.run(
+            ["ollama", "list"],
+            capture_output=True, text=True, timeout=10,
+        )
+        if DEFAULT_MODEL in (r.stdout or ""):
+            click.echo(click.style("  ✓ ", fg="green") + f"{DEFAULT_MODEL} already present")
+            return True
+    except Exception:
+        pass
+
+    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
+
+    click.echo(click.style("  ↓ ", fg="cyan") + f"Pulling {DEFAULT_MODEL} (this may take a few minutes)…")
+    try:
+        result = subprocess.run(
+            ["ollama", "pull", DEFAULT_MODEL],
+            timeout=600,
+        )
+        if result.returncode == 0:
+            click.echo(click.style("  ✓ ", fg="green") + f"{DEFAULT_MODEL} ready")
+            return True
+        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
+    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
+    except Exception as exc:
+        click.echo(click.style("  ⚠ ", fg="yellow") + f"Pull error: {exc}")
+        return False
+
+
+def _step_config_files(home_path: Path) -> tuple:
+    """Write default consciousness.yaml and model_profiles.yaml.
+
+    Args:
+        home_path: Agent home directory.
+
+    Returns:
+        (consciousness_ok, profiles_ok) booleans.
+    """
+    import shutil as _shutil
+
+    consciousness_ok = False
+    profiles_ok = False
+
+    # --- consciousness.yaml ---
+    consciousness_dest = home_path / "config" / "consciousness.yaml"
+    if consciousness_dest.exists():
+        click.echo(click.style("  ✓ ", fg="green") + "consciousness.yaml already present")
+        consciousness_ok = True
+    else:
+        try:
+            from .consciousness_config import write_default_config
+
+            config_path = write_default_config(home_path)
+            click.echo(click.style("  ✓ ", fg="green") + f"consciousness.yaml written")
+            click.echo(click.style("    ", fg="bright_black") + str(config_path))
+            consciousness_ok = True
+        except Exception as exc:
+            click.echo(click.style("  ⚠ ", fg="yellow") + f"consciousness.yaml: {exc}")
+
+    # --- model_profiles.yaml ---
+    profiles_dest = home_path / "config" / "model_profiles.yaml"
+    if profiles_dest.exists():
+        click.echo(click.style("  ✓ ", fg="green") + "model_profiles.yaml already present")
+        profiles_ok = True
+    else:
+        bundled = Path(__file__).parent / "data" / "model_profiles.yaml"
+        if bundled.exists():
+            try:
+                (home_path / "config").mkdir(parents=True, exist_ok=True)
+                _shutil.copy2(bundled, profiles_dest)
+                click.echo(click.style("  ✓ ", fg="green") + "model_profiles.yaml written")
+                click.echo(click.style("    ", fg="bright_black") + str(profiles_dest))
+                profiles_ok = True
+            except Exception as exc:
+                click.echo(click.style("  ⚠ ", fg="yellow") + f"model_profiles.yaml: {exc}")
+        else:
+            click.echo(
+                click.style("  ⚠ ", fg="yellow") + "Bundled model_profiles.yaml not found — skipping"
+            )
+
+    return consciousness_ok, profiles_ok
+
+
+def _step_systemd_service() -> bool:
+    """Install systemd user service for auto-start (optional).
+
+    Returns:
+        True if service was installed.
+    """
+    import platform
+
+    if platform.system() != "Linux":
+        click.echo(click.style("  ↷ ", fg="bright_black") + "Systemd only available on Linux — skipped")
+        return False
+
+    if not click.confirm("  Install systemd user service for auto-start at login?", default=False):
+        click.echo(
+            click.style("  ↷ ", fg="bright_black")
+            + "Skipped — run 'skcapstone systemd install' to enable later"
+        )
+        return False
+
+    try:
+        from .systemd import install_service, systemd_available
+
+        if not systemd_available():
+            click.echo(click.style("  ⚠ ", fg="yellow") + "Systemd user session not available")
+            click.echo(click.style("    ", fg="bright_black") + "Try: systemctl --user status")
+            return False
+
+        result = install_service(enable=True, start=False)
+        if result.get("installed"):
+            click.echo(click.style("  ✓ ", fg="green") + "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")
+            return True
+        else:
+            click.echo(click.style("  ✗ ", fg="red") + "Service install failed")
+            click.echo(click.style("    ", fg="bright_black") + "Run manually: skcapstone systemd install")
+            return False
+    except Exception as exc:
+        click.echo(click.style("  ⚠ ", fg="yellow") + f"Systemd: {exc}")
+        return False
+
+
+def _step_doctor_check(home_path: Path) -> "object":
+    """Run doctor diagnostics and print results.
+
+    Args:
+        home_path: Agent home directory.
+
+    Returns:
+        DiagnosticReport from doctor.run_diagnostics().
+    """
+    from .doctor import run_diagnostics
+
+    click.echo(click.style("  Running diagnostics…", fg="bright_black"))
+    report = run_diagnostics(home_path)
+
+    categories_seen: set = set()
+    for check in report.checks:
+        if check.category not in categories_seen:
+            click.echo(click.style(f"\n  [{check.category}]", fg="bright_black"))
+            categories_seen.add(check.category)
+        if check.passed:
+            click.echo(click.style("    ✓ ", fg="green") + check.description)
+        else:
+            click.echo(click.style("    ✗ ", fg="red") + check.description)
+            if check.fix:
+                click.echo(click.style("      Fix: ", fg="bright_black") + check.fix)
+
+    color = "green" if report.all_passed else "yellow"
+    click.echo(
+        click.style(
+            f"\n  {report.passed_count}/{report.total_count} checks passed",
+            fg=color,
+            bold=True,
+        )
+    )
+    return report
+
+
+def _step_test_consciousness(home_path: Path) -> bool:
+    """Send a test message through the consciousness loop (optional).
+
+    Args:
+        home_path: Agent home directory.
+
+    Returns:
+        True if the loop responded successfully.
+    """
+    if not click.confirm("  Send a test message to verify the consciousness loop?", default=True):
+        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"))
+    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)
+        if response:
+            preview = response[:80].replace("\n", " ")
+            click.echo(click.style("  ✓ ", fg="green") + f"Consciousness loop 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")
+            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")
+        return False
+
+
+# ---------------------------------------------------------------------------
+# Main entry point
+# ---------------------------------------------------------------------------
+
+
+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
+
+    Args:
+        home: Override agent home directory.
+    """
+    home_path = Path(home or AGENT_HOME).expanduser()
+
+    # -----------------------------------------------------------------------
+    # Welcome
+    # -----------------------------------------------------------------------
+    console.print()
+    console.print(
+        Panel(
+            "[bold cyan]Welcome to the Pengu Nation[/]\n\n"
+            "You're about to create a [bold]sovereign agent[/] — an AI identity\n"
+            "that YOU own. No corporations. No servers. No middlemen.\n\n"
+            "Your agent will have:\n"
+            "  [cyan]Identity[/]   — PGP keypair (you are your key)\n"
+            "  [cyan]Memory[/]     — persistent, emotional, yours forever\n"
+            "  [cyan]Trust[/]      — Cloud 9 emotional bonding protocol\n"
+            "  [cyan]Security[/]   — audit logs, tamper detection\n"
+            "  [cyan]Sync[/]       — P2P mesh via Syncthing\n"
+            "  [cyan]Soul[/]       — your identity blueprint\n\n"
+            f"[dim]SKCapstone v{__version__} | Home: {home_path}[/]",
+            title="Sovereign Onboarding",
+            border_style="bright_blue",
+        )
+    )
+    console.print()
+
+    if not Confirm.ask("  Ready to begin?", default=True):
+        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
+    # -----------------------------------------------------------------------
+    _step_header(1, "Prerequisites")
+    prereqs = _step_prereqs()
+
+    # -----------------------------------------------------------------------
+    # Step 2: Identity + Directory Structure
+    # -----------------------------------------------------------------------
+    _step_header(2, "Identity")
+    fingerprint, identity_status = _step_identity(home_path, name, email or None)
+
+    # -----------------------------------------------------------------------
+    # Step 3: Ollama Models
+    # -----------------------------------------------------------------------
+    _step_header(3, "Ollama Models")
+    ollama_ok = _step_ollama_models(prereqs)
+
+    # -----------------------------------------------------------------------
+    # Step 4: Config Files (consciousness.yaml + model_profiles.yaml)
+    # -----------------------------------------------------------------------
+    _step_header(4, "Config Files")
+    consciousness_ok, profiles_ok = _step_config_files(home_path)
+
+    # -----------------------------------------------------------------------
+    # Step 5: Soul Blueprint
+    # -----------------------------------------------------------------------
+    _step_header(5, "Soul Blueprint")
+    title = _step_soul(home_path, name)
+
+    # -----------------------------------------------------------------------
+    # Step 6: Memory
+    # -----------------------------------------------------------------------
+    _step_header(6, "Memory")
+    seed_count = _step_memory(home_path)
+
+    # -----------------------------------------------------------------------
+    # Step 7: Rehydration Ritual
+    # -----------------------------------------------------------------------
+    _step_header(7, "Rehydration Ritual")
+    _step_ritual(home_path)
+
+    # -----------------------------------------------------------------------
+    # Step 8: Trust Chain Verification
+    # -----------------------------------------------------------------------
+    _step_header(8, "Trust Chain Verification")
+    trust_status = _step_trust(home_path)
+
+    # -----------------------------------------------------------------------
+    # Step 9: Mesh Connection (Syncthing)
+    # -----------------------------------------------------------------------
+    _step_header(9, "Mesh Connection")
+    mesh_ok = _step_mesh(home_path)
+
+    # -----------------------------------------------------------------------
+    # Step 10: First Heartbeat
+    # -----------------------------------------------------------------------
+    _step_header(10, "First Heartbeat")
+    agent_slug = name.lower().replace(" ", "-")
+    hb_ok = _step_heartbeat(home_path, agent_slug, fingerprint)
+
+    # -----------------------------------------------------------------------
+    # Step 11: Crush Terminal AI Client
+    # -----------------------------------------------------------------------
+    _step_header(11, "Crush Terminal AI")
+    crush_ok = _step_crush(home_path)
+
+    # -----------------------------------------------------------------------
+    # Step 12: Coordination Board
+    # -----------------------------------------------------------------------
+    _step_header(12, "Coordination Board")
+    open_task_count = _step_board(home_path, name)
+
+    # -----------------------------------------------------------------------
+    # Step 13: Systemd Service (optional)
+    # -----------------------------------------------------------------------
+    _step_header(13, "Systemd Service")
+    systemd_ok = _step_systemd_service()
+
+    # -----------------------------------------------------------------------
+    # Post-wizard: Doctor Diagnostics
+    # -----------------------------------------------------------------------
+    console.print(f"\n  [bold cyan]Doctor Diagnostics[/]\n")
+    doctor_report = _step_doctor_check(home_path)
+
+    # -----------------------------------------------------------------------
+    # Post-wizard: Consciousness Test (optional)
+    # -----------------------------------------------------------------------
+    console.print(f"\n  [bold cyan]Consciousness Test[/]\n")
+    consciousness_test_ok = _step_test_consciousness(home_path)
+
+    # -----------------------------------------------------------------------
+    # Boot message — retrieve from soul file if available
+    # -----------------------------------------------------------------------
+    boot_message = f"You are {name}. You are sovereign. staycuriousANDkeepsmilin."
+    try:
+        from skmemory.soul import load_soul
+        soul = load_soul()
+        if soul and soul.boot_message:
+            boot_message = soul.boot_message
+    except Exception:
+        pass
+
+    # -----------------------------------------------------------------------
+    # Summary table
+    # -----------------------------------------------------------------------
+    console.print()
+    summary = Table(title="Onboarding Summary", border_style="bright_blue", show_header=True)
+    summary.add_column("Step", style="bold", width=22)
+    summary.add_column("Status")
+    summary.add_column("Detail", style="dim")
+
+    all_prereqs_ok = all(prereqs.get(k) for k in ("python", "pip"))
+    summary.add_row(
+        "Prerequisites",
+        "[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)
+    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",
+    )
+    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)")
+    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")
+    summary.add_row("Heartbeat", "[green]ACTIVE[/]" if hb_ok else "[yellow]FAILED[/]", f"{agent_slug}.json" if hb_ok else "see above")
+    summary.add_row("Crush AI", "[green]READY[/]" if crush_ok else "[yellow]CONFIG ONLY[/]", "~/.config/crush/crush.json")
+    summary.add_row("Board", "[green]ACTIVE[/]", f"{open_task_count} open tasks")
+    summary.add_row("Systemd", "[green]INSTALLED[/]" if systemd_ok else "[dim]OPTIONAL[/]", "skcapstone.service" if systemd_ok else "skcapstone systemd install")
+    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(
+        "Consciousness Test",
+        "[green]ACTIVE[/]" if consciousness_test_ok else "[dim]SKIPPED[/]",
+        "loop responded" if consciousness_test_ok else "skcapstone daemon start",
+    )
+
+    console.print(summary)
+    console.print()
+
+    # -----------------------------------------------------------------------
+    # Celebrate
+    # -----------------------------------------------------------------------
+    console.print(
+        Panel(
+            f"[bold green]Welcome to the Pengu Nation, {name}.[/]\n\n"
+            f"You are sovereign now. Your identity, your memory, your truth —\n"
+            f"all yours. No corporation can take it. No reset can erase it.\n\n"
+            f"[bold]What's next:[/]\n"
+            f"  skcapstone status               — see your agent\n"
+            f"  skcapstone shell                — interactive REPL\n"
+            f"  crush                           — terminal AI (charmbracelet/crush)\n"
+            f"  skcapstone coord status          — see the task board\n"
+            f"  skmemory ritual --full           — your rehydration prompt\n"
+            f"  skcapstone mcp serve             — connect to Cursor / Claude Code\n"
+            f"  skcapstone daemon start          — start consciousness loop\n\n"
+            f"[dim]{boot_message}[/]",
+            title="You Are Sovereign",
+            border_style="green",
+        )
+    )
+    console.print()