The machinery that runs itself

Applies the taps I make on the Command Center page to my own notes, so a close or snooze on the phone lands in the one record of them.

Checks that the PC can still reach my phone, re-arms the link after the phone restarts, and reports what it found to the Command Center page.

Every half hour, gathers what is waiting on me, what it cost, what is broken and what moved, and sends it to my phone page.

Reads this PC’s health (disk, memory, hangs) and reports anything wrong at the start of the next session, because a machine that is merely unusable logs almost nothing.

Keeps the logged request and response bodies, kept deliberately for studying each new tool version, from filling the disk.

Wakes the task agent when work is waiting for it.

Wakes the assistant agent when one of its scheduled entries is due.

Exports each agent’s workload numbers into its own repo, where the board reads them.

Checks the agents’ requests to reach new web domains and escalates each one to me for a decision.

Decides whether a standing goal’s latest run finished or should continue.

Validates the agents’ requests for host changes and escalates them; nothing is granted automatically.

Restarts the agents’ chat pollers if they stall.

Validates anything an agent wants to send outside and holds it for my approval.

Every five minutes, looks for a new red fault, a new question from an agent or something coming back today, and sends one notification for each; quiet overnight except for red faults.

Fetches both agents’ own status files so the phone page shows their questions, spend and faults beside everything else.

Stages each new release of the agents’ own tooling, tests it, and switches them over only when it passes.

Rebuilds the status page’s snapshot, sends it to the page’s server, and commits the day’s token-usage history before its source ages out.

Stops local development servers left running on registered ports.

Reads the pages of the AI tools’ documentation that changed overnight, checks every quoted finding against the page itself, and leaves what survives for a session to act on; it changes nothing on its own.

Commits and pushes every project and this machine’s settings on a clock rather than on a session, so a week without a session is not a week without a backup.

Runs the slow test tier of every project and reports any failure at the start of the next session.

Compares this site’s systems pages with this PC each morning and opens a window to publish any change with one click.

Rebuilds the two reference sites that map this whole setup, in the one order that is correct, because one reads what the other builds.

Finds and stops background shell processes nobody is waiting on.

Refreshes this site’s public repos list every day, and pulls and scores the job board every morning; gates both for anything private, and commits only what changed.

Takes an encrypted backup of a private store, so losing this PC does not lose it.

Sends me a summary of what the agents did and what is waiting on me.

Sends one notification each morning: what is waiting, what it cost, what is broken and what moved, across everything including both agents.

Publishes any new podcast episode to this site after checking its audio and provenance.

Copies a client site's newest nightly snapshot into a private archive each week.

Backs up and audits the taskbar layout, and speaks up only when something is wrong.

Pings me every week whether or not anything broke, so a dead alert channel shows up as a missing ping instead of a missed outage.

Rotates the logs of the proxy that all of the agents’ outbound traffic goes through.

Reads every file stored on the PC’s drive once a month, so a damaged spot is found while the rest of the file can still be saved.