Phase 1: Service Graph
Every service gets a YAML manifest — ports, dependencies, health checks, failure modes. A topological sort builds the dependency DAG, so a break traces to its root cause instead of restarting everything and hoping.

On the night of March 22, 2026, bridge100 didn’t come up. Twenty-six services tried to start anyway — each assuming the last had done its job — and cascaded like a Jenga tower at a toddler’s birthday party.
The watchdog ran. It checked ports that had changed months ago, pinged addresses that no longer existed, and reported all clear. Meanwhile Neo4j had entered an unrelated crash loop — its APOC plugin rewriting its own config into garbage on every restart, then dying on the garbage. The watchdog missed that too: it was checking localhost:4001 and Neo4j was on localhost:7474. Close enough if you’re drunk.
A human noticed two hours later. In his underwear. At 4 AM.

That night exposed a truth: the system didn’t understand itself. It had a list of services and a blunt instrument that restarted them — no concept of why a service was down, what depended on it, or whether retrying would make things worse. What followed was not a patch; it was the infrastructure equivalent of burning your haus down and rebuilding with load-bearing walls this time.
The old watchdog was a security guard asleep at the desk with the monitors off. The Living Force is an immune system — it maps its own body, detects illness at the cellular level, quarantines what it can’t fix, learns from every infection, and holds committee meetings about its own improvement — inspiring or dystopian, depending on how you feel about AI governance.

The first shape is governance — Tommy’s table, where incidents become explicit doctrine, manifests, and escalation rules.

The second is routing: telling a dead dependency from a bad config from a crash loop that needs quarantine. Restarting everything blindly is not healing — it is percussion.

The third is evolution: every failure becomes the next design decision, so the same mistake has to work harder the second time.
Phase 1: Service Graph
Every service gets a YAML manifest — ports, dependencies, health checks, failure modes. A topological sort builds the dependency DAG, so a break traces to its root cause instead of restarting everything and hoping.
Phase 2: Immune System
Anomaly detection feeds a remediation ladder — restart, repair, quarantine. Crash-looping services get isolated, not hammered.
Phase 3: Agent Autonomy
The code-forge skill lets agents write, test, and deploy fixes through a staging pipeline with an audit log, during a night window while the haushold sleeps. No, this is not how Terminator starts.
Phase 4: Tech Lookout
Jocasta scans for CVEs, dependency updates, and frontier shifts daily, flagging vulnerabilities before they become incidents.
Phase 5: Battle Testing
Chaos-forge runs scheduled fire drills — killing services, severing bridges, corrupting configs — and times the immune response, monthly.
Phase 6: Continuous Evolution
Every incident feeds a learning loop: performance reviews surface degradation, evolution reports propose changes. The system holds post-mortems and argues with itself about priorities.
Phase 7: Genetic Health
The biological layer treats neurodiversity (ADHD, Dyslexia, ASD) as a first-class cognitive profile; Cilghal’s genome-mcp reads the owner’s 23andMe data to suggest cognitive scaffolding.
Phase 8: Centralized Calibration
holocron-config.yaml is the single source for the Holocron’s ports and paths; run_sanctum.sh reads it via yq at ignition to calibrate every sector down to the Neural Link (Port 1138). The Watchdog (Port 2187, sanctumd) is the last holdout still carrying its own coordinates — the organism is learning to read its own DNA.
These phases sound elegant in the abstract. In practice, Phase 2 is Qui-Gon asking every thirty minutes whether 55 Tuya lights are still talking to us — and the ha-self-healer once watching 48 of them fail at the same instant, reading that synchronicity as a cloud drop rather than a software fault, and waiting instead of hammering the API. That restraint, the four case files that hardened into principles, and the dated journal of every night the architecture learned something live in their own chapter — this page keeps the doctrine, that one keeps the receipts: The Living Force — Case Files & Field Notes →
The Living Force has bones (services), muscles (agents), and an immune system (watchdog, sentinel, pressure-valve, canary). What it lacked was the fascia — the connective tissue that lets all three coordinate in real time, everywhere at once. That layer, sanctum-chitti, shipped late April 2026 and now wraps the whole organism: a Rust daemon on 127.0.0.1:2188 whose five yogic koshas are real endpoints, from the /fluid pressure block to the /attention signal that overrides everything below it. The old reflexes still fire, but chitti reads the room first and rotates to the next action when the primary fails. See the chitti architecture page → for the full body.
Ten rules that emerged from the wreckage. We had twelve until someone noted that the Commandments and Burning Man’s principles both stop at ten, so we merged the duplicates. None of these were obvious before March 22. All of them are obvious now, which is how you know they were expensive.
The first five govern how a change is decided and built. The last five govern how the system acts on its own body — when to heal, when to wait, when to distrust its own green lights.
The last two are about humility — refusing to trust yesterday’s tests, and refusing to build a council that only agrees with itself.
The Living Force is a roadmap, not a finished building. Follow the doctrine into the machine: the Operational State and Implementation Audit for the verified shape, the Feature Status Matrix for doctrine versus shipped, the case files, field notes, and dated journal for the evenings each lesson was earned. The Agents & Council, Service Graph, and Watchdog pages hold the body; the operational history holds the earlier milestones.
The night of March 22 broke twenty-six services. It also broke the assumption that a system this complex could be managed by a flat loop and a restart command. What replaced it is still growing — still learning from its own failures, still arguing with itself about what to build next.
Which, if you think about it, is the most alive thing a system can do.