Subsystem

The Windows NT Object Manager got the important things right: one namespace, the handle as the sole form of authority, mechanism over policy. It also had structural faults it could never shed — a closed ring-0 type taxonomy that cannot be extended from outside the kernel, a registry bolted on as a second store of truth beside the namespace instead of a projection of it, and a kernel that cannot host or rebuild itself.

Subsystem keeps the discipline and removes the faults with one move: recursion. There is one self-similar node type — a child object manager is the same type as its parent. The registry projects the namespace rather than duplicating it. And the image builds itself from source it carries. Terminating an owner cancels its token and cascades depth-first, revoking every child handle; a wedged thread is left resourceless while the rest of the system keeps running.

A unit of work is a 256-byte-aligned shared memory region, a monotonic timeline fence, and free-on-zero refcounting. You push it across a boundary. The boundary is the only thing that changes: inside the process, the handle is a pointer. Between processes, it is an NT shared handle. Across a die, a language, or a machine, it is the same contract over a C ABI.

This is one primitive applied at every scale, on purpose. Threads inside the process trade work the same way processes do — a handle and a fence, never a shared mutable object. In-process handoff is IPC-shaped deliberately: the determinism comes from the contract, not from proximity. And because the data plane is native memory behind a C ABI, a C++ module and a C# module share one heap: sharing a base pointer and a layout is sharing the heap. Delivery is push-based and latest-wins — a stale frame drops. That is the correct semantic for streaming inference and the wrong one for transactions; the system is built for the former.

The binary carries its own source and compiles itself in-process with Roslyn (ss build self) — no external SDK, no MSBuild — running 26 analyzers over its own tree on every build. The gate is fail-closed: 573 standing findings are held under a ratchet, and a single new finding fails the build. The baseline shrinks only by fixing.

The loop composes. The binary rebuilds itself, the gate rides every rebuild, and the ratchet only tightens — so each pass leaves the system structurally stronger, not more fragile. That is what makes a one-person project at this velocity hold: the rules are not written down for contributors to remember, they are compiled into the thing itself, and they bind human and model authors identically. Exact rule titles, from the code:

The type grammar is closed: names are mechanism nouns, methods begin with approved verbs, and suffixes like Manager, Helper, Factory, and Orchestrator do not compile.

Every test prints a receipt: the command, the verdict, and the measured numbers, appended to a ledger the binary writes itself. A number appears here only after a benchmark prints it. The suite state above is reported as-is, including the failures.

Recent entries, newest first. Compressed from commit subjects; the full history is in git.