Skip to content
Chapter 7 of 8

The Pulse dashboard: the face of the system

Pulse is the Life Dashboard, the single surface where you actually see your LifeOS. It is one local daemon running at localhost:31337, and it is the face your DA wears: the cockpit where your state, goals, work, and observability all show up in one place. Under the hood Pulse registers a set of modules (observability, hooks, a wiki, voice, your TELOS view, and more) and answers a health probe so you always know it is alive. It replaced a scatter of loose services with one coherent daemon, which is why there is a single port to remember and a single place to look. In this lab you build a small model of Pulse: register its modules, run the health check, and prove every declared module came up and the dashboard reports healthy, exactly like the real /api/pulse/health probe, but with no server and no network.

The lab: read it, then run it

labs/lifeos/lo7-pulse-health.py
#!/usr/bin/env python3
"""
LAB LO7: The Pulse dashboard, module registry and health check.

Pulse is the Life Dashboard, the single surface where you see your state, goals,
and work. It is one daemon that registers a set of modules and answers a health
probe so you know it is alive. In this lab you build a sample Pulse: register
modules, run the health check, and prove every declared module came up and the
dashboard reports healthy. No server and no network; it is a fictional in-memory
model of the real /api/pulse/health probe.

Run: python3 modules/academy-content/labs/lifeos/lo7-pulse-health.py
"""
import sys

# STEP 1: a sample Pulse daemon that modules register into.
class Pulse:
    def __init__(self):
        self.modules = {}
    def register(self, name):
        self.modules[name] = "up"
    def health(self):
        # healthy only when every registered module reports up.
        all_up = all(state == "up" for state in self.modules.values())
        return {"ok": all_up, "modules": len(self.modules)}

declared = ["observability", "hooks", "wiki", "voice", "telos"]
pulse = Pulse()
for m in declared:
    pulse.register(m)

print("STEP 1: registered Pulse modules")
for m in sorted(pulse.modules):
    print(f"  {m:16} -> {pulse.modules[m]}")

# STEP 2: run the health probe (the real dashboard answers this on :31337).
h = pulse.health()
print("")
print(f"STEP 2: health probe -> ok={h['ok']}  modules={h['modules']}")

# STEP 3: invariants. every declared module registered, and the probe is healthy.
all_registered = set(pulse.modules) == set(declared)
ok = all_registered and h["ok"] and h["modules"] == len(declared)
print("")
print(f"PULSE HEALTHY, ALL MODULES UP: {'YES' if ok else 'NO'}")
if not ok:
    sys.exit(1)
print("One daemon, all your modules, one health probe. Next: compose it into a daily OS.")
Runnable lab
lo7-pulse-health.py

Register a sample set of Pulse modules, run the health probe, and prove the dashboard is healthy.

Proves: PULSE HEALTHY, ALL MODULES UP: YES

Open the notebook

Runs in your browser via Pyodide. First run loads the runtime once; no install, no server.

Every declared module registered and the health probe came back healthy, which is exactly the check you run against the real dashboard to confirm it is alive. Pulse matters because a system you cannot see is a system you will not trust or use. By collapsing everything into one daemon on one port, LifeOS gives you a single cockpit for your whole life operating system. You now understand every part in isolation. The last chapter ties them into one continuous daily loop.
Check your understanding
  1. 1. What is Pulse?

  2. 2. How do you confirm Pulse is alive?

  3. 3. Why does collapsing services into one Pulse daemon matter?