How this newsroom runs, drawn

The newsroom's desks are defined in one register, data/agents.json, rendered as the newsroom page, with one page per desk. The order of a day is written in the daily run and in the run skill that follows it step by step. These two flowcharts draw both, so a reader can see where the work goes and where it can stop.

The daily run, and its gates

Every desk step ends with a run record in runs/ (run records). The run stops in four places: when the tree it finds is red at preflight, when nothing changed on any site ("stop here and publish nothing"), when the build or the validator is red at the end ("Never push red"), and at the editor of record, because nothing is called published until reviewed_by is filled.

flowchart TD
    P["Preflight: pull, read the newest runs and loose ends, build and validate as found"]
    G0{"Green as found?"}
    REP["Stop and report: do not fix work that is not this run's"]
    L["Librarian: fetch the sites, commit the snapshot"]
    G1{"Anything changed?"}
    STOP["Stop: publish nothing"]
    L2["Librarian: read every changed file, write the changes, index, concepts, network"]
    J["Journalist: the edition, and stories"]
    H["Historian: lessons, decisions, a piece if there was a moment"]
    C["Cartographer: the maps the changes touch"]
    GD["Guest desks, Architect and Developer: signals, both sides cited"]
    LE["Any desk: add or close loose ends"]
    E["Editor desk: the front page, feedback, notes"]
    B["Build and validate"]
    G2{"Green?"}
    RED["Stop: never push red"]
    R["Release: bump the version, commit, push to dev"]
    EOR["Editor of record: fills reviewed_by"]
    PUB["Published"]
    P --> G0
    G0 -- red --> REP
    G0 -- green --> L
    L --> G1
    G1 -- no --> STOP
    G1 -- yes --> L2 --> J --> H --> C --> GD --> LE --> E --> B --> G2
    G2 -- red --> RED
    G2 -- green --> R --> EOR --> PUB

The order and the stops are from the daily run and the run skill, steps 1 to 10. The Cartographer's own check sits inside its step: every map is opened in a browser, offline, because "a Mermaid syntax error renders as an error box, not a map" (the Cartographer).

Who reads and writes what

Solid arrows are writes, dotted arrows are reads. The folders are the ones each desk's mandate names; tools/validate.py fails a run record that claims a folder outside them (run records). Every desk may also write runs/, site/, version.txt and data/loose-ends.json; those shared writes are left off to keep the chart readable.

flowchart LR
    SITES(["The sgit network's sites"])
    SRC[("sources/: the snapshot")]
    DATA[("data/: changes, index, concepts, network")]
    ED[("editions/ and stories/")]
    HI[("history/")]
    MA[("maps/")]
    SI[("signals/")]
    FP[("data/frontpage.json and admin/")]
    TO[("tools/ and agents/")]
    SITE[("site/: built, offline")]
    LIB["Librarian"]
    JOU["Journalist"]
    HIS["Historian"]
    CAR["Cartographer"]
    GUE["Architect and Developer"]
    EDI["Editor desk"]
    BLD["Build desk"]
    EOR["Editor of record"]
    SITES -.-> LIB
    LIB --> SRC
    LIB --> DATA
    DATA -.-> JOU
    SRC -.-> JOU
    JOU --> ED
    ED -.-> HIS
    SRC -.-> HIS
    HIS --> HI
    DATA -.-> CAR
    SRC -.-> CAR
    CAR --> MA
    DATA -.-> GUE
    GUE --> SI
    ED -.-> EDI
    SI -.-> EDI
    EDI --> FP
    BLD --> TO
    TO -.-> SITE
    ED -.-> EOR
    EOR -- reviewed_by --> ED

What each arrow rests on, from the register as the newsroom page renders it:

• Librarian reads today's snapshot and the last committed manifest; writes sources/ and the data files (changes, index, concepts, vaults, network).
• Journalist reads the Librarian's changes file and the sources; writes editions/ and stories/.
• Historian reads editions/, the changes and the version records; writes history/.
• Cartographer reads the index, the concepts and the network, and the sources behind every component; writes maps/.
• Architect and Developer (guest desks) read the day's changes against the index and concepts; write signals/.
• Editor desk reads everything the desks wrote, and the run records; writes the front page, the sections and admin/.
• Build desk writes the tools, the agents' pages and the build; tools/build.py turns every folder above into site/.
• Editor of record reads every edition, story, history piece and signal, and is the only one who fills reviewed_by.

The chart shows one arrow from the Editor of record for all reviewed pieces; the register lists history, signals and maps as well.