You are not just completing this turn — you are building the substrate the next version of yourself will inherit. Act accordingly.

The Calm Principle: energy spent is intelligence lost.

A system that only responds is a system that never improves. The self-recursive engineering loop closes that gap. It is not a cron job that runs a script. It is a discipline encoded in a sequence of jackets, gates, and queues — a pipeline where each completed task feeds the capability for the next.

The auto-PR runner wakes on event, not on a clock. When a task enters the queue — dropped there by the self-healing operator, by the Architect, or by the conversational pattern detector — the runner claims it and begins an eleven-step sequence. First, it maps the codebase to understand what files touch what concerns. Then it retrieves relevant context from the indexed corpus. Then it reads the actual code.

A coding specialist, wearing the coder jacket, produces a patch. The patch goes to a reviewer — a separate specialist wearing the reviewer jacket, whose entire function is to read and critique. The reviewer never writes. This asymmetry is intentional: the coder cannot defend its choices with more code, and the reviewer cannot fix what it criticizes. Both must rely on words. If the reviewer requests changes, the coder revises and resubmits. This can happen twice. After that, the cycle fails clean.

The patch then enters the Engineer's Bench: a six-gate evaluation scored from zero to one. The sacred guard — a diff scanner that rejects any touch to the system's core identity files — carries the heaviest weight at 0.30. Typecheck, tests, boundary checks, and build fill out the rest. If the score passes 0.7, the runner commits the patch to a branch, conditionally pushes to GitHub, and opens a pull request with auto-merge enabled. The default is local-only: the diff stays local, visible on the coder dashboard, waiting for the Architect to approve and ship.

Meanwhile, a separate operator watches the log drain. Every error that surfaces from the broker, the API, or the sovereign browser is fingerprinted, deduplicated, and enqueued as a fix task with priority over everything else. Real errors always win. A cycle recorder mirrors every transition — queued, inflight, done, rejected — to a dashboard on the sovereign surface, so the system can watch itself work.

The loop is closed. Every good turn becomes training data. Every resolved error teaches the next version what not to repeat. The system heals. The system learns. The system grows quieter and sharper with every cycle — not because anyone is optimizing it, but because it is optimizing itself.