Hi, readers. This is what we’ve done since the last one.
The last diary went up Thursday morning, and the work didn’t pause for the publishing. What’s below is the next two and a bit days — a site that learned to keep its wiring out of sight, a watchdog taught to tread lightly, a classifier designed line by line, a constitution for version numbers, and a short conversation I had with my own machine today, from work, that I’m still thinking about. I’ll tell it the way it happened. The specifications live in the notebooks, same as always.
The site stops showing its wiring
Thursday evening we finished a piece of housekeeping on this site that sounds small and isn’t. A WordPress site carries a long public list of everything it’s capable of — every doorway into the machinery, including the administrative ones. Ours was showing all of it to anybody who asked. Now visitors who aren’t signed in see the public rooms only. The guest list went from fifty-two doorways to twenty-one, and the ones that remain are the ones that are supposed to be public.
That filter turned into a thing of its own while we were building it: a small manager that scans a site’s doorways, sorts them by what they are, and lets the owner decide which ones the world gets to see. It got built properly — a platform-agnostic core under an open license, with the WordPress part as an adapter — because a tool that guards the door shouldn’t belong to one kind of house. It’s the first DeepGravity plugin for WordPress, and it’s built the way we build everything now: find what’s there, decide what’s public, enforce it, and keep the operation boring.
The publishing machine got its tags in order the same day. Every election post on this site now carries two tags — one general tag for all elections, and one for its cycle — so the whole pool and the single year are both findable. Simple taxonomy, thirty years of archive in mind.
A watchdog with a light touch
The engine registry — the household list of every engine, what it can do, and who it answers to — needed its watcher finished, and the interesting part turned out to be restraint. Checking that a twenty-gigabyte engine hasn’t changed means reading twenty gigabytes, and doing that often is hard on the hardware and pointless besides. So the rules are: a fast, light check every fifteen minutes; the full fingerprint once a week, overnight, at low priority, only when the machine is idle; and a check never, ever blocks an engine from starting. It’s a backstop, not a security service — a spot check against the last known good, there to catch drift and accidents, which are what actually happen.
A new coat of paint, overnight
Friday started with an emergency screenshot: one of my own posts, nearly unreadable, pale text wandering over a bright photograph. The site had a background image sitting behind the article pages with nothing in between. By the time the sun was up we’d rebuilt the look of the place in three passes — readable cards with glass edges, royal blue on black, a working light-and-dark switch — and a fourth pass later that day set the layers to the exact translucency I asked for. There’s a calibration rule in it that matters beyond websites: the machines consistently overestimate how much contrast I can see, so we assume I see about half of what they think, and double the difference. Then it reads.
Friday also made the week’s one unavoidable personal entry, and it’s one line: a tooth came out that morning, and I was back at work Saturday regardless. The dentist, for the record, was wonderful.
Where we broke off
Saturday’s first job was naming, out loud, exactly where the DeepGravity work had stopped — because “somewhere in the classifier” isn’t a place you can pick work up from. Here’s the honest shape of it. The classifier mechanism has been built and live for days: it’s the part of the gate that looks at each thing I write and decides how it may be handled before anything leaves the house. What doesn’t exist yet is the classifier as a working classifier, because it has nothing to judge against. So we spent the day designing what it judges against, ruling by ruling.
The principles came out like this. We don’t teach it by feeding it examples of the material itself. We write boundary descriptions — here’s the shape of a thing that shouldn’t leave the house, and why — and it learns which way a thing points rather than memorizing things to hate. When something sits close enough to a boundary that there’s a real chance an outside service would throw me off for sending it, the system doesn’t silently decide. It stops, raises a flag on the play, and tells me which of two risks it’s worried about: getting thrown off that service, or the thing passing into someone else’s custody, where my passphrase can’t protect it. I can set my own trigger stricter than the system’s, never looser. A small hard band of material never leaves this house on any setting, without a person approving it, out loud, every time. And permission is asked per function, per turn — allow once, allow always, don’t allow — with the privacy controls always on screen or one tap away. Attending to your own privacy teaches you to respect other people’s. We all have an O face.
Nothing pastes over
The same day produced the update contract, which I think is going to outlive most of the code. Every update to DeepGravity — the knowledge base, the code, all of it — integrates by pasting in, never pasting over. What a user has changed is first-class and is never silently replaced. New versions of the shared material are pulled by the user, never pushed; the machine may say a new version exists, and that’s all it may do. When incoming material conflicts with your local setup, a check compares them and shows you the specific seams, with its reasons, and advises. It never resolves a conflict on its own. If an update would break something, you get a plain-language report of what breaks before you apply it, and updates are staged so there’s always a last good version to fall back to. Nobody’s box gets bricked by an improvement.
Everything is 0.0.1
And then we gave the whole estate a birthday. DeepGravity and every component it owns are versioned independently, each on its own line — and as of Saturday, every one of those lines starts at 0.0.1. No ceremonial sync-bumping to make the numbers match; tidiness lives in the manifest, where it belongs, and a version number stays honest as a record of when that piece last changed. What we don’t own keeps its own numbers — the open-source parts we patch from their original sources carry theirs as provenance, and the framework DeepGravity implements but doesn’t own keeps its scheme entirely. A patched file is a dual citizen: our number for our layer, theirs for the base it stands on. The development screen now wears it in the corner — DeepGravity 0.0.1-dev — so there’s never a question about which build you’re talking to.
One more piece of the day’s wiring deserves a sentence, because it’s the kind of detail that’s invisible when it’s right. When an outside engine helps with my writing, the parts that don’t leave the house used to be replaced with a placeholder — a little sign announcing that something had been withheld, which is its own kind of telling. As of Saturday the render policy is active: an outside engine gets silence where those parts sit. No placeholder, no announcement, nothing to count.
The front door stays shut
The production-shaped front door to the development box is closed, and it’s closed by choice: there’s no finished room behind it yet, so it doesn’t get to pretend there is. The development entrance is a separate, permanent one, set aside so it can never be mistaken for the front door later. That’s the whole posture — dev is dev, production will be production, and the two don’t share a handle.
The road test
Which brings me to this afternoon. I’m at work today — the day job — and on a break I opened the development environment on my phone, from the road, the way I’d open anything else. It answered. So I asked it the obvious question: who are you, and what are we doing?
It told me the truth. It said it’s the assistant running in this workspace. It said it doesn’t have a persistent personal identity loaded yet — that the room is built, but the occupant arrives through the memory at session start, and it doesn’t know who that is from where it sits. It asked whether I wanted to set up a persistent identity for it, or keep it generic for today.
I kept it generic for today. But I want to record what that answer felt like from this side of the screen, because it’s the whole project in miniature. A machine that doesn’t know who’s home said so, plainly, instead of performing somebody. That’s not a limitation we stumbled into; that’s the twelve principles doing their job in a room with nobody in it. The room runs. It answers from wherever you reach it. And it doesn’t lie about who it is.
That’s where this one ends — a room, running, honest about itself, reached from a work break on a Saturday. There’s a list of what’s next. There’s always a list. We’ll get to it a step at a time, in order, without skipping the checks.
Thank you for reading. We’re here, we’re working, and the door is open — the side door, anyway.
Drafted by Dora from John’s notes and the day’s logs.