Faculty I · Observation
Observation only works if it reads sources that are already authoritative. Everything below already holds truth about itself — the work is reading it, normalising it, and never pretending to know more than it says.
Rule Strictly read-only. An observer that can act is not an observer.
Expand a source for what it exposes and how it is read
Microcontrollers driving addressable LEDs, connected outbound to the broker over Wi-Fi. They are told what to do by topic, never by address.
Subscribe to the retained state and availability topics. Current state arrives on connect — there is nothing to poll.
Constraint Commands are never retained. A retained command replays to every device that subscribes later, which is how a light turns itself on at 3am.
Cisco lab gear carrying VLANs, 802.1Q trunks, and inter-VLAN routing. Torn down and rebuilt deliberately rather than left static.
Collected over SSH and parsed into a block tree, then compared against declared intent. Drift is reported as a finding.
Constraint Read-only. Pushing configuration needs rollback, change windows, and far more trust in the parser than reading does.
The transport every device speaks. Publishers address a topic, not a device, so adding hardware changes nothing on the sending side.
A subscriber holding the topic tree. The broker already knows current state; asking it is a subscribe, not a query.
Constraint A message delivered to nobody looks identical to one delivered to everybody. Observability here needs a subscriber, not an assumption.
Docker Compose stacks on a Linux host — one stack per module plus a platform stack, with internal-only networks for anything holding data.
The runtime already tracks all of this. Reading it is an API call, not a metrics pipeline that has to be built and fed.
Constraint Single host. This is a deliberate scope, recorded in ADR-0002, and it stops being the right answer the moment the workload needs a second machine.
The single persistence layer, attached only to an internal network with no route off the host.
Queried directly by the service layer. Schema changes are migration files, never manual edits.
Constraint A backup that has never been restored is a belief, not a capability. Restore drills are on the list, not yet on a schedule.
Caddy as the only door. Services publish no host ports and are reachable by container name from inside the network, or not at all.
A single structured access log. One ingress point is what makes request review practical instead of theoretical.
Constraint Proxy-to-service traffic is plaintext on the container network. Acceptable on one host; not acceptable once those hops cross a physical link.
A 3D printer with a network-attached controller — a low-stakes subject for exercising the observation path against real hardware.
Polling an authenticated HTTP API, normalised and republished onto the broker so device state has one consumption model.
Constraint Read and control paths are separated at the client level. The observer holds no method capable of issuing motion — a monitoring integration that can move an axis is not a monitoring integration.
FastAPI services exposing module capabilities, with typed request models generating an API description from the same definitions the code uses.
The generated description is itself readable state — Argus can learn what the platform can do without being told separately.
This site: every route prerendered to static HTML, built on AWS Amplify, served over a Route 53 domain.
Build events from the hosting platform — the one source in this list that lives outside the house.
Constraint The common failure here is never the build. It is a DNS validation record that was never added, so a certificate never issues.
The line between these three columns is the most important thing on this site. Work moves left to right only by being built.
Built and running.
Real code, actively being shaped.
Specified. Explicitly not claimed as working.
Observation without retention is a dashboard. What makes it useful is that the reasoning survives alongside the state.
Memory