Skip to content
C.W.K.
Stream
Lesson 08 of 08 · published

The Roster Lives Next Door

~13 min · review, architecture, ownership, routing

Level 0Wet Clay
0 XP0/40 lessons0/12 achievements
0/100 XP to next level100 XP to go0% complete

One Road to a Reviewer

A review round reaches its brain one way: a harness's command-line tool, run as a local subprocess on the machine where the session is working. Not a web interface, not a chat route, not a browser driven through a vendor's site. That rule did not start as a road. It started as a gate — a check that knew which channels were acceptable and refused the others — and the gate was correct and still lost. On one day, three sessions reached for the hosted route anyway, and two of them left stray conversations behind in a place a person had to clean up.

So the channel was deleted instead of guarded. The review verb resolves a reviewer through a map of routes, and a brain absent from the map cannot be named at all: the verb refuses at the point of logging, rather than letting the round happen and complaining afterwards. This is the fifth rung from the first track, applied to the review track's own machinery — the forbidden road is not refused; it is not there. What does not exist needs no discipline.

The Map Moved Out

For two months that map lived inside the workshop. Since 2026-09-28 it does not. A sibling app owns multi-brain routing for the whole family and publishes it as a catalog, one per task. For each brain the review catalog names the executable, an argument template with exactly one slot for the request and optional slots for model, effort and host, how the answer is read back, and what record the call leaves behind. When a round runs, the workshop fetches that catalog, renders one route into a local process, and runs it. It keeps no roster, no argument table, no copy.

Why give the map away? Because the same map was being kept in several workshops, and every copy drifts on its own schedule: one workshop carried a private override for a reviewer's flag that the others lacked, and a brain one app could reach was refused outright by another. One owner means one place where a route is fixed, and every caller picks it up on its next round.

The decision that matters most is what happens when the owner cannot be reached. The round fails, says exactly where it looked, and runs nothing. There is no fallback table. A local copy kept "just in case" would be the bug the previous lesson retired, one layer down: the record would name the reviewer the operator chose, while a table nobody had looked at in weeks decided what actually ran.

What a Route Carries

Native first, a harness when there is none. A brain whose only automatable surface was a plain completion used to answer every artifact round with an honest refusal: it could not open a file, so it said so, at length, on a clean exit. That shape needed its own detector, scoped to the opening lines of the answer so that a review of file-access code would not trip it. Now such a brain reviews through a harness that gives it a tool loop, inside a home created for that one call and deleted after it, with shell, edit, write and delegation denied. The capability gap closed at the route instead of being detected round after round.

A record policy, declared rather than hoped for. Two routes run with their tool's no-persist switch, so no conversation survives the call. Two keep the vendor tool's own local session. The harnessed ones live in the throwaway home. The first lesson of this track asked for one run per round and never a resumed thread; for the routes that cannot keep a thread, that is now structure. For the two that can, it is still discipline — and the catalog says which is which, so nobody has to assume.

A held brain carries its reason. One vendor's tool stopped serving the subscription the reviewers ran on. Naming that brain returns the catalog's reason, not "unknown reviewer". A brain named by another name is refused with the name to use instead, so the ledger records one spelling.

The grammar is checked where it is rendered. A route with no request slot, two request slots, a placeholder the client does not render, or a home the client could not delete is refused whole. That check used to sit beside the old in-workshop map. When the routes moved, the check did not move with them — and the reviewer that caught the gap was one of the harnessed brains, reviewing the very client that now launches it.

The Model Is Read When the Leg Runs

Which model a reviewer uses is not pinned in the workshop either. The operator's live selection is published by the family's state owner, and the workshop reads it per resolution — only for the leg that needs it. A machine without that family data still runs every round that needs no such model, and a leg whose model cannot be resolved is skipped with its reason on the record rather than run on a guess.

When another part of the system owns a fact, read it at the moment of use and fail out loud when you cannot. A local copy kept for resilience is a second record, and it disagrees with the first exactly when nobody is checking. The workshop kept its craft — the request templates, the ledger, the close floor — and gave away the roads, without keeping a map of them.

Code

The workshop's side of a review round, reduced to its decisions·python
# Nothing below is a table of brains. The catalog is fetched per
# round from the app that owns routing; the workshop only renders it.

def run_round(reviewer: str, request: str, task: str = "review"):
    try:
        catalog = fetch_catalog(task)        # the owner's published routes
    except Unreachable as exc:
        # NO local fallback table. A stale copy would let a table nobody
        # reviewed decide which reviewer actually ran.
        raise SystemExit(f"catalog unreachable ({exc}); nothing ran")

    identity = resolve(catalog, reviewer)
    #   routed       -> its identity (a long label matches its brain)
    #   another name -> refused WITH the name to use: one spelling
    #                   in the ledger
    #   held         -> refused WITH the catalog's reason
    #   absent       -> refused: a brain joins the catalog, never a
    #                   chat route or a web interface

    route = catalog["routes"][identity]
    check_grammar(route)   # exactly one {prompt}; no slot the client
                           # cannot render; a home it can delete

    model = resolve_model(identity)   # read NOW, for THIS leg only;
                                      # unresolvable -> leg skipped,
                                      # reason on the record
    argv = render(route, request, model)
    with ephemeral_home(route) as env:   # made for the call, removed
        return run(argv, env)            # with everything it wrote


# The record policy is a declared field of each route:
#   none            the tool's no-persist switch; nothing survives
#   vendor-local    the vendor tool keeps its own session - say so
#   ephemeral-home  a throwaway home, deleted after the call

External links

Exercise

Find one table of external routes your tool keeps for itself — endpoints, model names, command-line flags, service addresses — that another system in your organization also keeps. Decide who owns it. Then change your tool to read it at the moment of use, and write the error message it prints when the owner cannot be reached. If you catch yourself writing "falling back to the cached copy", write down who will notice when that copy is wrong, and how.
Hint
The usual answer to "who notices" is nobody, until a run behaves differently on one machine than on another. Cached routes fail quietly and locally, which is the worst pair of properties a failure can have. A loud failure on an unreachable owner is an outage you can see; a stale copy is a divergence you cannot.

Progress

Progress is local-only — sign in to sync across devices.
Spotted a bug or have feedback on this page?Report an Issue

Comments 0

🔔 Reply notifications (sign in)
Sign in — Please sign in to comment.

No comments yet — be the first.