graphs.sgit.ai → admin → Release history

The v0.5 era

The v0.5 era, closed: 24 releases in three days, from the tidy-up that shut the v0.4 era to the retrospective that weighs this one. It is the era in which the working surface produced three books, the WCLM was built and then parked, and a book became a build artefact with its own version. Weighed in the v0.5 retrospective.
The rest of the record: the current era · the v0.4 era (41 releases, the working surface, with its retrospective) · the beginnings, v0.1–v0.3.

VersionDateWhat changed
v0.5.23 28 August 2026 The v0.5 era is weighed and closed. The v0.4 era ended with a retrospective at v0.5.0; this is its counterpart, and the same discipline applies — every number computed from the release history, book.json, the suites and the file tree, every judgement marked as the agent’s. Twenty-three releases in three days. What did not exist on 26 August and does now: three books (47 chapters, 99,946 words, 302 PDF pages), the WCLM (12 operators in first-class folders, 951 token hashes, 57 concepts, strict layer adjacency), briefs 31 through 39 each reproduced verbatim with the agent’s reading, 95 tests in six suites where the era began with 84 in one file, 24 generators, and 64 client modules every one of which now carries a @module header. Six achievements are traced in the order they compounded, from the file explorer through the strict-layer pipeline and the operator folders to the books and per-book versioning. The more useful half is what was got wrong, and there are six, four of them caught by gates built in the same era: the harness that reported failing async tests as passes and was hiding a real dangling edge; book.json’s two writers disagreeing about what its keys mean; the front page that denied the books existed for ten releases; the frozen first edition regenerated and caught within minutes by a self-test written hours earlier; pass three planned without checking who loads the code; and covers that took three layout passes because the only way to find that class of error is to look at the picture. The judgement: the era’s real output is not the three books but that a book became a build artefact — markdown in, gated PDF and pages out, a version that moves only when content moves, a hash per chapter proving it. And the weakest point is now stated rather than hidden: a generated page cannot drift from its source and the build proves it every push, but a sentence that was true in August and false in September passes every check this repository has. Prose has no freshness gate. That is why the front page was wrong for ten releases in the middle of a publishing push, and why only a person reading it found out.
v0.5.22 28 August 2026 The front page stopped denying that the books exist. The site’s most-read page still said the second edition was “being written from the top down — and while its text does not exist yet, its working surface does”. That was true through the v0.4 era. It has been false since v0.5.12, and it was still there: a page announcing that the thing about to be sold on Leanpub had not been written. The estate’s own rule is that a page cannot drift from what it describes, and this one had drifted for ten releases. The front page is now the home of three books. It leads with them, and the shelf table is generated from each book’s own book.json rather than typed: title, its own version, its state, its chapters, its words, its page count, and where to read it. Nothing on that row is remembered. To make that possible, gen_bookmeta.py now counts every book’s pages from its PDF — before, only one of the three had a page count, because only one book’s builder wrote a build.json, and a number that exists for one book and not the others is a number nobody can quote. Fractal Semantic Graphs v0.2.0, 18 chapters, 38,029 words, 119pp; Creating a Book v0.1.0, 17 chapters, 31,221 words, 92pp; the Universe volume v0.1.0, held, 91pp; the first edition frozen at v0.3.26, closing the table as the evidence it is. The release count stopped being wrong by one. The page used to say “seventy-plus releases”; it now counts them, and calls them narrated rather than tagged, because CI tags each release after the push that builds the page — “tagged” would be off by one on every single build. The nav follows. “The book” became “The books”, the shelf leads the group, each book carries its landing page and its PDF, and the machinery that built them moved below the books rather than above them. And the front page now states the caveats the corpus travels with, where a first-time reader meets them: not a graph database pitch, the semantic layer is designed rather than shipped, and nine of the edge inverses are this site’s proposals rather than quotations. 95 tests green; no book content changed.
v0.5.21 28 August 2026 The size rule became a gate, and pass three lost three of its five targets for a good reason. Pass three was planned to split the estate’s five oversized modules. It was planned without anyone checking who loads them. Measured against v1/MANIFEST.json: altitudes-graph.js (795 lines) is loaded by one page and that page is frozen; altitudes.js (415) the same; docs.js (298) is loaded by 22 pages, all 22 frozen. A frozen page cannot gain a second <script src> tag, so those three cannot be split the ordinary way. Dynamic import() would work without touching the HTML — and would make initialisation async on pages that exist as evidence, for no benefit to anything anyone is still editing. So the call is to leave all three and say why, in each module’s own @module header where the next agent will actually read it. 1,508 lines stay long on purpose, which is stated debt rather than the unstated kind. And the guideline that allows that is now enforced. CLAUDE.md has always said “parts ≤ 200 lines, sections ≤ 250 — over that, split, or record the deviation in the module header; unstated debt is the thing to avoid, not debt”, and that was a convention anyone could quietly forget. A new test walks every module under assets/ and fails any file over the guideline whose header says nothing about it. It found five on its first run, none of which had a word about their length: the graph element, the reader shell, the tool API, the chat panel and the WCLM page. Each now states its own case — the API surface is long on purpose because a list of published commands should read as a list; the chat panel is the chat agent’s half of a published boundary and is not ours to split from outside it; the other three name the split worth making and the pass it is scheduled in. The rule now costs something to break, which is the only kind of rule that holds. 95 tests green; no book content changed.
v0.5.20 28 August 2026 Non-functional pass two: the harness that was lying, the builders that were duplicated, and a gate for the gate. The audit found that the test surface stopped at the v2 core, and pass two closes that half. The test harness had a real hole and it was hiding a real bug. test() called each function and caught synchronous throws, but an async test returns a promise nothing awaited — so a failing async test printed ok, counted as a pass, and only surfaced later as an unhandled rejection after the summary had already lied. Three tests in the suite are async. It was proven before it was fixed, with a deliberate failing async probe that reported green. The repaired harness immediately turned up a pre-existing failure it had been swallowing: normalise/anatomy.json declared that two of its segments feed a segment called run, and normalise has no such segment — its run half is run-setup and run-repair. Two dangling edges in the code-anatomy graph, invisible for as long as the harness was broken; the other eleven operators were audited for the same class of error and are clean. One file of 84 tests became six suites and a runner (admin/tests/run.mjs), each suite in its own process so a suite that dies while loading can only fail itself, and run.mjs wclm runs just one — a content agent can run what it touched. The release gate now calls the runner and names the failing tests in its message, because a gate that only says “the suite failed” costs the next reader a second run. The gate got a gate. validate.js is 530 lines of check and was itself unchecked; it now accepts a tree argument, and a new test copies the repository, breaks the version agreement on purpose, and insists the right error comes back. It earned its keep on its first honest run by catching that the frozen first edition had been regenerated — gen_book.py is not in the release chain and rewriting v1/ is exactly what gate 14 forbids. Three book builders became one kit at admin/build/bookkit/: markdown rendering, print figures, weasyprint, and the page counter that existed in five copies, each carrying the same comment about having learnt the trick the hard way. There is one now, and a test that fails if a sixth is written. Each book keeps what is genuinely its own — its shape, its cover, its CSS — and both PDFs were rebuilt and compared page by page against the shipped ones before an old builder was deleted: 119 pages and 92 pages, identical on every page but the cover, which carries the build date. That conversion surfaced one more thing, found rather than looked for: book.json had two writers who disagreed about what its keys mean. version meant the book’s version to one and the site’s to the other (the exact confusion per-book versioning exists to end), pdf was a filename to the shelf and a dict to the builder, chapters a count to one and a list to the other — and whichever generator ran last won. The file now has exactly one writer; a book’s builder writes build.json and gen_bookmeta.py folds it in. 94 tests green (84 plus ten new build gates); no book content changed, and the gate proves it.
v0.5.19 27 August 2026 The five things between here and a live release: covers, copy, samples, landing pages, a post. Everything the Leanpub upload needs is now built, and built the estate’s way — from one authored register (admin/build/gen_bookpub.py) that projects into every surface, so the store page and the site cannot drift apart. The covers are drawn, not decorated. Each carries a true subgraph in its own book’s vocabulary: Fractal Semantic Graphs shows the two 8080s — one ghosted and reaching nothing, one descending backed_by → observed_on → protected_by — under the caption the same value, differently connected; the making-of shows the loop closing, memo becomes brief commissions build ends at gate releases ship invites review. SVG is the source (versioned and diffable like everything else here) and the 1600×2400 PNG Leanpub wants is photographed from it by the repository’s own headless-Chromium harness, since no rasteriser is installed and the estate already owns the tool for the job. Three layout passes went in before the covers were good: the first put edge labels on top of their own lines, the second collided a verb with a node, and the third replaced the zigzag with a straight descent and moved node labels to the left, which is why the chain now reads as a path at thumbnail size. The samples are cut, not rebuilt — taken from the shipped PDFs at the first page of chapter two, located in each book’s own PDF outline rather than guessed, so a reader samples the exact typesetting they would buy (15 pages of FSG, 11 of the making-of). The metadata sheet per book is the paste-ready Leanpub copy: hook, 150-word description, audience, categories, keywords, licence, the files-to-upload table, and the sentence that says plainly this is v0.x and every future version is free. The landing page per book (about.html, linked from the shelf) shows the cover, the same words, the sample, and a note explaining what the version number means. And the LinkedIn post is drafted in full in the copy sheet, with the links bracketed until the store URLs exist and a note on which paragraph to cut if it runs long. What remains is only what an agent cannot do: update a bio that still names Photobox, create the two listings, upload, price, publish. 84 tests green; no book content changed.
v0.5.18 27 August 2026 Each book gets its own version, and a gate that keeps the two clocks honest. The founder answered the three questions brief 39 held open, and the answers settle the publishing shape. v1.0.0 is reserved for a book’s actual final release, so the pair ships openly unfinished: Fractal Semantic Graphs at v0.2.0, Creating a Book Using Fractal Semantic Graphs at v0.1.0, the Universe volume held at v0.1.0 and out of the release. Review notes will arrive as voice memos or as narrated-review exports with screenshots — both formats this estate already reads, since every brief is a transcribed memo and briefs 27 and 33 came from narrated reviews. And the Leanpub account is real, with history: ten published books, one unpublished, and a bundle, which is a precedent for shipping the two as a pair. Per-book versioning is now machinery, not a convention (admin/build/gen_bookmeta.py): every book carries a book.json with its own version and the SHA-256 of every chapter, and the founder’s rule is enforced in both directions — content that moves without the version moving fails the build, and a version that moves without content moving fails it too, because a book’s version tracks its content and the site’s tracks every push. The gate earned its keep on its first run by catching that fsg/book.json was carrying the site’s version (v0.5.12) in its version field, which is precisely the confusion it exists to end. The bookshelf hub finally exists at /v2/books/ — flagged as missing by book C’s own release notes — generated from the same register that versions the books, so the shelf cannot disagree with them; it is named in the nav and in llms.txt with the versioning rule stated for agents. The Leanpub release is prepared (the pack): what ships, the account as it actually stands (including an author bio years out of date, still naming Photobox), the method already decided in admin/publishing.html from the first book (upload our own PDF, the screen edition is the book, EPUB slot empty for now, cover at 1600×2400, one set of words everywhere), the five things still to build here (covers, a metadata sheet per book, sample PDFs, landing pages, the LinkedIn draft), and the upload-day checklist that is the founder’s hands. 84 tests green; no book content changed, and the gate proves it.
v0.5.17 27 August 2026 The non-functional pass, part one: the documents an agent reads first. Brief 39 arrived from the flight, and it opens with a finding worth recording before any instruction: the making-of book’s alignment is “way way stronger, like by orders of magnitude” than the FSG book’s — the same agent, the same day, the difference being that book C was written over 41 narrated release rows, 38 verbatim briefs and a repository it could interrogate, while book B was written over an argument. The founder reads that as the power of the source material, and it is the strongest case yet for what comes next. The memo then turns the estate: a proper non-functional pass over the code, the tests and the harness; the WCLM and its operators PARKED (not abandoned — an experiment that “needed a better target, a better environment”); the two books shipped all the way to Leanpub, because shipping is one of the most important things you can do; the site refactored as the home of two books; and then the real work, the review process itself as change control with human and agentic reviewers. This release is the pass’s first part and the audit behind it. The audit is measured, not remembered (the eight findings): the root README documented ten top-level directories, nine of which moved into v1/ a month ago; there was no contributor contract for the five-plus agents already working here; the documentation line fell exactly on the v1/v2 boundary (nine modules, 2,536 lines, no stated responsibility between them); seven modules exceed the size guideline with only one recorded; three writing sessions each wrote their own markdown-to-PDF builder; the 84 tests stop at the v2 core, leaving the twenty generators, the three book builders and validate.js itself ungated; only three web components exist; and the parked WCLM said so nowhere. What is healthy is listed too, because an audit that only lists faults is not honest. Pass one, executed: the README rewritten against the real tree; CLAUDE.md written as the agent contract (the release ritual, the collision discipline, the size guidelines, the verbatim-brief rule, the anchoring rule, the CDP unique-port lesson that once cost an hour, and the new distinction between tool work, content work and evidence work); a @module header added to all nine undocumented modules, so every one of the 40 hand-written modules now states its single responsibility; and the WCLM pages carry a visible parked notice quoting the founder’s reason. The version call, which the memo asked for with pros and cons: wrap in 5.x, open 6.x with the review machinery — the seam falls between finishing the books as they are and changing them under control, not between tidy and new. Passes two (the shared book builder, per-book versioning, gates for the unwatched half) and three (the module splits and the web components) are sized and planned. 84 tests green; no book content changed.
v0.5.16 27 August 2026 Book C’s self-review pass: eight corrections, each one a number the book got wrong about this repository. The colophon promised a final self-review; this is it, and it found more than expected, which is itself the argument the book makes. Every one was caught the same way: by re-running the computation the sentence claimed, over the git history, instead of re-reading the sentence. The corrections. The first edition carried twenty-one source documents at the freeze, not twenty-two (v0.3.25’s own row says so); it took thirty-four releases to reach the freeze at v0.3.26, not thirty-five; fifty releases followed brief 20, not thirty-four; the operators directory held seventy-four files at v0.5.7 and eighty-six by v0.5.11, and the book quoted the later count against the earlier release; the unit suite went from 13 to 84 tests in a little over two days (2d 4h), not two and a half; a cross-reference sent the reader to chapter 7 for a story told in chapter 8, and another called appendix A “chapter 3’s appendix”. And one claim demoted rather than corrected: the reading that 25 August’s nine releases were a heavy day rather than a slow one is a judgement about what those releases contained, and it is now marked as one instead of stated as fact. Nothing in the argument moved; the four numbers the loop chapter rests on (88 releases, six days, a 31.2-minute median, 89 of 97 commits) were recomputed and stand. The PDF is rebuilt at 92 pages and the chapter pages regenerated from the corrected markdown, which is the only source. Why this is a row and not a silent edit: the site’s own rule since v0.2.0, restated in the book’s own playbook, is that a correction that changes a claim gets a release. A book about checking your claims against the repository cannot quietly fix the ones it got wrong about that repository.
v0.5.15 26 August 2026 Book C ships, and the shelf is full: Creating a Book Using Fractal Semantic Graphs. The third and last of the three books commissioned at v0.5.10, written in its own session from the folder v0.5.11 put up, and released here by that session. The other two argue the material; this one is about the making, and its reader is an author with an agent at hand rather than a graph specialist. Twelve chapters, three appendices and a colophon; 31,000 words; one 92-page PDF that reads start to finish offline. The spine: the loop (voice memo → verbatim brief → build → release → live review), the pivot at brief 20 that inverted the construction order, briefs as the contract, why gates buy speed, the reader from page to instrument, two agents sharing one repository, the failures, reviewing out loud, the experiments, the founder’s craft, a playbook that stands alone, and what the method costs. Every scene is checkable at the tag its caption names. The twenty figures were not described from memory, they were RE-TAKEN: a git worktree per tag, served on its own port, photographed with the headless-Chromium harness — the same page at v0.4.5, v0.4.8, v0.4.11, v0.4.16, v0.4.31, v0.4.34 and v0.5.11, and the WCLM at v0.5.2, v0.5.4 and v0.5.9. The port rule the estate learnt the hard way (never reuse a debug port; kill the chrome you spawn) is why twenty figures took twenty ports and twenty shutdowns, and it is written up with the scripts in Appendix C. Every number is computed, not recalled: 88 releases across 6 days, a median 31.2 minutes between them, 89 of 97 commits are releases, the unit suite from 13 tests at v0.4.13 to 84 at v0.5.9, the validator from 7 checks to 16, uni-graph.js from 202 lines to 434 against a 250 budget. The failures chapter is the longest on purpose, and every one of its nine is already in this table: the iPad round that found what headless Chromium never would, the wire that jumped a layer and betrayed the architecture the page claimed, “meaning without connectivity” answering like “through”, the hour lost to a zombie browser serving stale modules, and the correction the agent owed at v0.4.3. Appendix A reproduces brief 32 complete and annotates it segment by segment, from voice memo to the release it produced thirty-three minutes later; Appendix B lists all 88 releases with their timestamps. The costs are stated rather than implied: the six days produced the machine for writing the second book and none of its chapters, one document of twenty-one is extracted, the uni-graph.js debt is still owed, and chapter 12 names four situations where this method is the wrong one. The book stops at v0.5.11 and says so, because that is where the repository was when it was commissioned. Also corrected here, since the shelf changed under them: llms.txt said the bookshelf held one finished book of three and that books A and C were “commissioned and not yet written”. Both were true when written and false by shipping; both now read the shelf as it is. No book content changed in either earlier volume.
v0.5.14 26 August 2026 The Universe volume’s cover prints. The founder, reading the PDF: the first page is a dark green panel. It was, deliberately — the estate’s own cover generator draws the family at night, cream and amber on #0d3a34 — but that generator makes a jacket, and this is the first page of a document somebody runs off on an office printer, where a full-bleed dark panel floods a sheet with ink for no reading gain. The cover is now white: the deep green moves to the title and a short rule, the kicker to a muted green, the footer line above a hairline. Same design, same family, on paper instead of covering it. And a stale number went with it. The cover read estate v0.5.11, the version the atlas data was authored at and stored in universe.json, not the version the reader is holding — so the cover, the front matter and the hub now read the live version.txt, and the authored-at version stays in the data where it belongs. Gate 21 again, from a different direction: a number that was correct when it was written and became wrong by shipping. No book content changed; the PDF is rebuilt and the pages restamped.
v0.5.13 26 August 2026 Book A ships: the Universe volume, the atlas of this estate’s own concepts. The companion to the book that landed an hour earlier, written in its own session from the folder v0.5.11 put up, and released here by that session. Two of the three commissioned books are now on the site, and this one is the universe the other one stands on. The book is a graph before it is a book: v2/books/fsg-universe/data/universe.json holds 90 concepts across 8 regions, joined by 168 verb-named edges, drawn from 63 declared sources — the 21 carried documents, both editions, the 19 founder memos, the methods register, the scoped lexicon, the pilot extraction and its ledger, the WCLM world file and four of its engine pages, the release history, the vault analyses, and two live fetches of sgit.ai’s vault and network indexes (snapshotted beside the data; the vault index’s 19 published read keys are redacted in the copy, stated in a banner, because a credential travels with every copy of it and this is not where they are published from). Every entry is anchored or it is not an entry: 165 verbatim quotes, and build/validate.py re-reads every one of them out of the source it names, checks both ends of every edge, refuses any edge stored under an inverse verb, and fails on an orphan. The hash gate learned something on this very release: a source under /v1/ is byte-frozen so its SHA-256 is a promise and a change fails the build, but a live page regenerates on release, so the first version of the gate failed on the release that shipped it — live sources now report a move and the quote check, which runs on every source, is what actually holds the anchor. Edges come in two kinds and the kind is printed — 17 anchored in a quote the corpus states, 151 authored by the session with their reasoning carried instead, which is the methods register’s carried-versus-authored distinction applied to a book’s own graph. The prose is authored; everything else is generated: entries, region maps, tables, and the counts inside the sentences (carried sources, memos, engines, published vaults, the pilot’s nodes and its sections, blocks, sentences and words) are written from the repository at build time, and gen_chapters.py --check fails if a chapter lags the data. One generated count came out wrong first time, which is gate 21’s argument in miniature. The two chapters that earn it are What the atlas found — the peaks computed rather than declared, the thin concepts printed with them, 6 contradictions in the corpus with both sides quoted, and 9 named absences including time, asserted everywhere and developed nowhere — and the colophon, which lists the nine near-duplicate entries merged into neighbours (their anchors carried onto the survivor rather than dropped), what the volume gets wrong, and that 90 is ten above the charter’s suggested ceiling with the reason stated. Ships three ways from one markdown source: 12 chapters under content/, a hub plus one self-rendering page each, and a 91-page print PDF with 8 figures photographed from the live pages by gen_figures.py, each captioned with the page and version it was taken at. The commission’s three spot-checks run over the whole book rather than one entry: every entry’s quote is printed, every edge end has an entry, no in-book link points at nothing. AI authorship is disclosed in the front matter in the estate’s existing voice.
v0.5.12 26 August 2026 Book B lands: Fractal Semantic Graphs: Meaning Through Connectivity. The first of the three commissioned books is written, and it is the one the title was waiting for: the argument whole, from first principles AND from the running system. Fifteen chapters in five parts plus front matter, a colophon and a reference card; 38,000 words, a 119-page PDF, at v2/books/fsg/. The parts read the title backwards, each earning one part of it: the claim (a node is just a node; why graphs at all, with the GraphRAG, RDF, property-graph and vector positions carried as stated); semantic (every edge is a verb, and the verbs register that makes the inverse rule machine-checkable; anchors not standards, with the senses and analogies registers as bridges you can watch being used; a type is a path, not a label); fractal (the zoom test applied to this estate's own two zooms, and reported failing at the storage layer, because a falsifiable claim never falsified is decoration; a graph at every boundary; documents are projections, tested by gate 5 rebuilding the document from the formatting graph byte-identical and gate 6 re-deriving the semantic shards from that graph alone); computed (the universe method with its 72 anchors and coverage total by construction, and the usage ledger that caught the FIRST edition misreading its own source on the word this book is named after; content address versus identity address with the three-pass match-then-mint; the WCLM as the existence proof, twelve typed operators and every weight a stated formula, training as editing reviewable files; explanation as a path rather than a narration, with opinion and evidence labelled apart); and in practice (twenty published vaults and nineteen sites with their real numbers; what ships and what is argued, updated for v0.5 and carrying seven things part four does not yet have; and an afternoon, a week and a month of instructions for the reader's own first graph). Same discipline as everything else here: the markdown is the source of truth (content/*.md), the web pages render their own source client-side, and the PDF is generated from the same files by v2/books/fsg/build.py; book.json carries every chapter with its part, word count and SHA-256. 17 of the 38 figures are screenshots taken from the real pages at v0.5.11 with the repository's own headless-Chromium harness; the rest are ascii, each naming what it was drawn from. Every number computed or quoted, never recalled (the unit suite was run while writing chapter 14: 84 passed, 0 failed). The honesty positions travel unchanged, above all not a graph database pitch. Books A and C are still to come; the shelf now holds one.
v0.5.11 26 August 2026 The bookshelf: three folders, each carrying its own initial prompt. The founder answered brief 38's two held questions the same evening and simplified the whole handoff in one move: book B does NOT wait for book A; the three books DO ship on the site (the writing agents get write access); and rather than pasting prompts from the pack, create the folders for those books, with the placeholder to put the markdown and pdf, each holding its own README-as-initial-prompt — so starting a session becomes one line: "hi, you are going to focus on writing this book: v2/books/<folder>/README.md". Built exactly so. v2/books/ is the bookshelf, with a shelf README naming the three; fsg-universe/, fsg/ and making-a-book/ each carry a README that IS the complete initial prompt — the reading order into the commissioning pack, the session's branch, the contract (everything lands in this folder; the PDF is sent to the founder the moment a draft exists; the book releases itself to dev through the full ritual; do not wait for the other books), and the placeholder map — plus content/ placeholders for the chapter markdown, data/ for book A's machine twin, figures/ for book C's re-taken evolution screenshots, and the expected PDF filename stated beside each README. The pack was updated to match: the how-to-use table now leads with the one-line start; shipping on the site moved from "recommended path: hand off integration" to IN SCOPE, with the release ritual spelled out and the collision discipline restated for up to four agents sharing this repo (fetch dev and tags first; renumber on collision; generated files regenerate, never hand-merge); and each entry file points at its folder as the canonical start. The founder's answers are recorded verbatim as brief 38's addendum. No book content changed — but the shelves are up, and the shelves know what belongs on them.
v0.5.10 26 August 2026 The book-writing pack: three books, three sessions, one pack. Brief 38, and something a little bit different — not a build round but a writing commission, shaped for a long flight tomorrow. The founder asked for three books/PDFs created from this repo and the work so far, each written by a FRESH Claude Code session fed one initial prompt: A, the universe for Fractal Semantic Graphs: Meaning Through Connectivity (the concept graph of the whole corpus as a readable atlas, one spread per concept, grouped by neighbourhood, with a machine twin in the pilot extraction's shape so the atlas is literally a universe other engines can stand on); B, the book itself — title locked, full editorial freedom elsewhere, arguing from first principles AND from the running system, with a proposed eight-chapter spine offered to be improved on; and C, Creating a Book Using Fractal Semantic Graphs — the expansion of the v0.4 retrospective through the v0.5 era, aimed at other authors: the loop, the briefs-as-contract, the gates, the two-agent discipline, the failures lovingly told, and evolution screenshots RE-TAKEN from history via the repo's own git tags (a worktree per tag, served and photographed — figures as evidence, not memory). Delivered exactly as asked: one pack in the dev-pack style with three entry points (v2/dev-packs/v0.5.10__the-book-writing-pack/, rendered under /v2/dev-pack/) — a shared README carrying the commission verbatim and the three governing rules (the title is locked; every claim is anchored; the reader is on a plane), a shared corpus file in five layers with fetch paths, skim markers and precedence rules, shared conventions (markdown → self-rendering pages → one 60–120 page print PDF via the estate's weasyprint precedent; the CDP screenshot harness with its hard-won port rule; honesty gates; each session on its OWN branch with no dev push outside the release ritual; the PDF sent to the founder the moment a draft exists), and one paste-ready entry prompt plus editorial charter per book, every charter marked proposals-not-orders. Questions held in the brief: whether B should wait for A's universe (the pack says no — anchor to the corpus, don't block), and where the finished books ship (integration is deliberately a separate single-session step). No book content changed — this release is the commissioning of three.
v0.5.9 26 August 2026 Keep zooming: the code itself gets the graph treatment. Brief 37, sent minutes after v0.5.8 went live, and the deepest zoom yet: the operator scripts are small but context-heavy, so give them what the founder asked by name — the Bret Victor treatment, graphs of graphs applied to source code. Every operator now carries an anatomy (anatomy.json): the code sliced into contiguous authored SEGMENTS — the claim, the dependencies, the official data, the contract, the run steps, the ui — each a node with what it does written for someone who knows JS, its variables with their roles, what it reads and writes, and feeds edges to the segments it drives. The anchoring is the estate's own extraction discipline applied to source: each segment anchors to the exact text of its first line, the build resolves heads to line ranges that must tile the file completely, and a gate fails the release the moment code and anatomy drift. The anatomy view is the js file's rendered tab in the explorer: the FLUXOGRAM on top (kind-coloured boxes with line ranges, feeds arrows, side arcs for the long hops), the code below grouped into its titled segments, the explanation pane on the right — and one id drives all three: click a flow box, a code block or a fed-by hop and the same segment lights everywhere. The tinted source stays one tab away. The workbenches speak the WCLM's visual language now: execute renders the previous layer's evidence as chips, the operator between, and the operator's own rendered chips as output — wired chip to chip through the same shared renderer the main page uses, every chip clickable for its record; the JSON dumps moved into debug where they belong. Each operator is honestly a mini app: drop a <key>.css in its folder and the workbench wears it — the experiment hook, no shell changes needed. The schema's rendered view draws its typed flow from the same shared diagram module the workbench header uses. And the frame the memo asked for is recorded in the brief: this is the lab — PoC ways to see, run, visualise and debug in the small space, promote what works to the main WCLM (the chip-and-wire execute shares its code with the main page by construction; the anatomy's one-id-three-views selection and the in-page vector replay are the named promotion candidates). 84 gate-27 tests including the anatomy anchoring gates; verified in headless Chromium (flow-to-code-to-pane selection, hops, schema flow, chip-wired workbench with wires painted, first-operator prompt chip). No book content changed.
v0.5.8 26 August 2026 The explorer earns its screen: an overview, real renders, and the docs-files treatment for json. The founder's iPad review of v0.5.7, four screenshots and four findings, each fixed where it pointed. The landing state stops saying "pick a file": the explorer now opens on the pipeline drawn as a clickable flow — every operator a chip in canonical order, the data type it writes carried on the arrow to the next, core engines solid — above a card per operator with its role, its typed io, and straight links to its workbench and its book page, in pipeline order rather than the alphabet. Clicking an operator opens its page: the folder row expands AND opens the operator's book page rendered, one click, exactly as the review asked; the flow chips and card titles do the same. html now actually renders: the rendered tab embeds the live page — the workbench runs inside the pane, prompt, execute and all — and the tinted source moved to raw, where it belonged. And json gets the v0.5.1 treatment the review named: the tinted pretty-print is now the RAW view, and rendered means data-driven visualisation, built in the tested fileview core — the schema as the typed reads/writes contract with the run-after chain spelled out, the official data as a provenance-chipped table (standard / authored / derived, the why beside each), the example vectors as cards summarising input and output per state key with counts, and the manifest as the operators table. Javascript, honestly, has no higher rendering than its tinted source, so it shows a single raw tab. 83 gate-27 tests (the four json views build from the real folder files); verified in headless Chromium including the workbench alive inside the iframe. No book content changed.
v0.5.7 26 August 2026 The operators become first-class folders: tune each one individually. Brief 36, the founder pointing at the document's file explorer (v0.5.1) and asking for the same treatment for the engine's own building blocks — and the restructure is real, not cosmetic. Each of the twelve operators moved into a dedicated folder (v2/wclm/operators/<key>/) whose <key>.js is the code the engine ACTUALLY imports: engine.js shrank to the shared helpers, the six-type registry and the layered runner, and gate 27 stayed green through the move because behaviour is byte-identical (a recorded structural deviation: pure core code now lives under v2/, at the founder's explicit direction). Around the code, each folder holds the full artefact set: the book page (md — what it does, the contract, the transformation walked through, an ascii architecture diagram); the schema as json — reads and writes with the full definition of every type touched, GENERATED from the code's own declaration and gate-checked against it, so the file can never drift; the official data (data.json) with the memo's distinction as a field, not a comment — standard across every document (the pinned hash vectors, the negation word table, the class weights, the summing multipliers), authored for the founder's review (senses, analogies, packs), or derived by another transformation (the token table, the stem families, the co-occurrence edges, the extraction); and the example vectors (examples.json) — real input-state and output-state slices captured by running the engine, deterministic by construction, 39 vectors in all, every one REPLAYED by a gate on every build. The explorer (operators/index.html): all twelve folders as a tree, every file readable raw (exact bytes) or rendered (marked-up markdown, tinted json and js — the fileview core gained a js colorizer), deep-linkable. The workbench, one reusable shell mounted by every folder's page: EXECUTE (the prerequisite chain runs, then the operator; the input slice, the operator box and the output slice side by side, with the typed IO flow drawn as an SVG from the schema itself), TEST (the folder's vectors re-run in the browser and compared — green means replays byte-identical), DEBUG (the full state, expandable), and the custom part each operator needs declared in its own module (senses and translate bring their preset switches), so a new operator brings its workbench with it. 82 gate-27 tests; verified in headless Chromium (workbench execute and 3/3 vector replay, preset sense-switch, fractal tests, explorer tree, raw and rendered tabs, tinted views, deep links). No book content changed.
v0.5.6 26 August 2026 The fractal nature: analogies for other worlds, and every answer declares its anchoring. Brief 35, the founder's memo on what this architecture actually is — world-model transformations, every layer asking what does this mean, expand it, contract it, give me more so the analysis can continue — carries one ask by name and this release builds it. Analogies and equivalencies: to explain this material to somebody from finance, do not repeat the words, find the equivalent concept in THEIR world — "graphs of graphs" is spreadsheets of spreadsheets, "because actually, in the financial world, we do have spreadsheets of spreadsheets of spreadsheets". The analogies register (v2/wclm/analogies.json, authored for review like every register) maps sixteen of this document's concepts into three audiences — finance, operations, medicine — each with the why carried: a node is a cell with a name, meaning through connectivity is the consolidation trail, an anchor node is the chart of accounts; for medicine, the differential diagnosis and the provisional "query appendicitis". A translate engine (reads meanings, writes meanings — the v0.5.5 schema working as designed) restates the answer in the listener's concept when an audience picker choice is made, wires the equivalence into the evidence trail like any other chip, and says "no analogy authored yet" where the register has a gap — a correction opportunity, not a silence. Every answer now declares its anchoring (the memo's "hey, here's a fact"): fact-anchored with its quoted section, a stated claim asserted but not quoted, an authored pack term, or a chosen sense — the confidence spectrum the book argues for, applied to the engine's own output. The rest of the memo is recorded in the brief as direction with questions back: ask-a-document (bring a graph TO a document and hear agree, disagree, evidence — queued on the document fan-out), corrections as first-class training artefacts, the 2D layer warm-up map with exact lines, and LLM-in-the-loop layers made safe by the schema contract because graph-in and graph-out are both kept as evidence. 551 wires re-proved with zero layer jumps; 79 gate-27 tests; verified in headless Chromium (audience switching, the why in the pane, honest gaps, the anchoring line). No book content changed.
v0.5.5 26 August 2026 Words have many meanings: senses, number, schemas, and a WCLM inside a WCLM. Brief 34 arrived in three parts in one afternoon — a voice memo recorded against v0.5.3, then two typed notes sent while this very release was being built — and all three shipped together. The senses register (v2/wclm/senses.json, authored for review like the meaning packs): the memo's thought exercise done — three to five definitions each for graph, node, fractal and task, across industries, the document's own sense always first because "the reason why I called network graphs… a graph is connected to a network, is connected to nodes and edges, is connected to mathematics". A sense picker appears for any prompt word the register knows: switch graph to a chart of data and the founder's exact prediction executes — the word withdraws from this universe's concepts, the chosen sense binds instead, and the answer says which claims stop applying: "graphs of graphs", "the graph provides the evidence or it does not", "schema-first in graph syntax" and 2 more do not apply under yours. The fractal element, as promised, does not survive a graph that is a diagram. Number is evidence: graphs carries "plural of graph — more than one involved", read from the stem families the core graph already computed, and the graph-of-graphs variants sit as example buttons producing visibly different runs. Layers now hold multiple engines (the first typed note): the pipeline became layers of engines — senses and operators run side by side in one slot by default, dragging an engine onto another shares its layer, into a gap gives it its own — and passthrough is itself an engine: include it and the marking engines' withdrawals become advisory (negation noted, nothing blocked; "meaning without connectivity" then answers like "through" again, with the contradiction still said), leave it out and the stream is strict. Every engine declares its schema (the second typed note): input and output as data types — six types move the whole pipeline: text, tokens, stream, profiles, bindings, meanings — so compatibility is structural, an engine placed where its input type is unwritten is skipped with the type named, and any engine writing the right type can stand in. Which is what makes the last ask real: the fractal engine is a full WCLM inside an engine — it re-runs the winning meaning's own statement through a complete inner pipeline, one zoom down, the meaning of the meaning. Also fixed from the founder's live catch on v0.5.4: wires drawn after scrolling right landed in the wrong place — chip positions are viewport-space and the canvas is content-space, and the horizontal scroll offset was never added back; wire geometry is now scroll-invariant, machine-checked. The adjacency proof re-ran over the layered shapes: 547 wires, zero jumps. 77 gate-27 tests (a word said twice withdraws once; sibling needs skip honestly; fractal runs inside; deterministic replay with senses chosen); verified in headless Chromium. No book content changed.
v0.5.4 26 August 2026 The detective playbook: strict layers, honest operators, reusable blocks. Brief 33, a narrated review of v0.5.3 — the founder walking the WCLM screen by screen — and every finding became structure. First, the caught bug: the screenshots showed wires jumping layers (tokenise straight to attend, attend straight to converge), which betrays the architecture the page claims. The engine and renderer were rebuilt so every block reads only the block before it — evidence a layer merely carries now appears as an explicit pass-through chip, so the wire has somewhere adjacent to land. This is machine-checked: 500 wires across five pipeline shapes and six prompts, zero adjacency violations. Second, the playbook itself: clicking any box no longer lights just its neighbours — it computes the transitive closure over the wires, both directions, and fades everything that played no part, so clicking the winning meaning is the detective's move: the full evidence trail back to the tokens, nothing else lit. Third, the founder's own experiment made honest: "meaning without connectivity" used to answer exactly like "through", because without was padding. A new operators block reads the little words — without, not, no, never negate what follows; negated evidence is withdrawn from binding (the answer changes), kept visible with a ⊘, and checked against the world: the answer now carries the warning that the prompt negates connectivity while this universe asserts meaning through connectivity — the query contradicts the world, said out loud. Fourth, "this is what we think you said": a normalise block repairs unknown tokens early, the dictionary way (edit distance 1: graphz → graph, conected → connected) and the thesaurus way (a form whose stem lands in a known stem family is pulled to that family's head, for the misspellings a single edit cannot reach), each repair a chip naming its evidence; what it cannot repair says so and stays dim. Fifth, blocks over layers: the eight stages are now a registry of reusable blocks with declared needs — a pipeline bar shows them in order, optional blocks toggle off with a click and drag to reorder (the pin-board gesture), the arrangement persists, and an illegal order does not error but shows the block skipped with its reason (needs bind), which is itself a lesson in what the dependencies are. Four blocks are core and fixed; the engine runs any legal subset — the future the memo names, where other pilots (code, verbs, dictionaries) snap into the same bar. Sixth, opinion versus evidence: every formula surface now labels its parts — counts and coverage are evidence, the halves and multipliers are opinion — so the reader can see exactly which numbers were measured and which were chosen. 71 gate-27 tests including negation flipping an answer, repairs naming their method, illegal orders skipping, and deterministic replay; verified in headless Chromium (toggle, drag, skip, trail, contradiction). No book content changed.
v0.5.3 26 August 2026 Every box explains itself, both ways. Brief 32, recorded through the viewer's own loop after the founder tried the WCLM ("this WORKED really WELL"), built the same hour. The memo's point, taken literally: the point of the deterministic transformer is that every item can say WHY it is there — so now every chip at every layer is clickable. Clicking selects it, lights its wires and dims the rest, and opens the explanation pane (right on desktop, below on a phone): the item's record with its formula, then because of — everything upstream that produced it, with the reason carried on each wire ("share 4 sentences in the document", '"graph" is in this label', "bind 0.517 doubled, plus 0.1 per neighbour") — and leads to, everything downstream it feeds. Every entry in both lists is itself clickable, so the why can be walked in either direction: it is graphs all the way, exactly as the memo says. Clicking a layer title explains the layer: its role, what it reads, what it writes, and its count this run. The impact of a changed prompt is measured, not guessed: the engine diffs every layer against the previous run (a pure function, gate-27 tested), new chips carry a badge, and a delta banner reports the movement — the founder's own pic1-to-pic2 gesture ("when I added graph, it made a massive difference") now reads tokenise +4/−1 · bind +5/−3 · expand +9/−2 · the meaning held. Seven example buttons, strong to weak connectivity, including the founder's "meaning through nodes and graph sausages" verbatim, unknown word and all, because honest failure is worth one click. The memo's direction is recorded in the brief for the rounds ahead: one of these engines at every abstraction jump of the book — word to concept, concept to chapter, chapter to thesis — each rationally explaining its compression, and eventually the generative half: phrase in, structure out, prose composed from it. 69 gate-27 tests; verified in headless Chromium including walking an explanation upstream and back. No book content changed.
v0.5.2 26 August 2026 The WCLM: a deterministic transformer over our graphs. Brief 31, the founder's self-described "crazy experiment", built in its own folder (v2/wclm/) with its own code, exactly as asked, and it works. The idea the memo argues: an LLM is not predicting the next word at random, it consults a rich world model — so build a mini engine with the transformer's SHAPE where nothing is learned and everything is named. Tokens are content hashes (FNV-1a 64-bit; the founder's instinct that "the ID is the hash of the word" taken literally): the same word tokenises identically in every document with no registry, phrases hash their joined hashes, and the Python and JavaScript implementations are gate-checked against shared vectors so the two sides can never drift. Recorded distinction: the hash is a content address; the ledger uid remains the identity address — different jobs, both kept. Six named layers, each a pure deterministic function: tokenise, resolve (form, class, count, weight), attend (co-occurrence pairs and companion pulls, the look-back the memo most wanted to see), bind (forms light the concepts and pack terms whose labels they cover), expand (bound meanings pull their neighbourhood — the world model assembling), converge (evidence summed, meaning out). Every weight is a stated formula written in the world file — class weight over log2(2+count), bind as half label coverage plus half prompt coverage, total as 2·bind + 0.1·blast — so training the model is editing graph inputs and meaning packs, never fitting numbers; one ranking bug in this very build was fixed by editing the bind formula, the training loop working as designed. The query flips: not the next word but what does this mean — "meaning through connectivity" answers with the exact concept (beating its one-word members on specificity), the statement, the anchored quote, blast radius 6 and the arithmetic in the open; "qa" answers part-of → development from the first meaning pack (packs/graphs-domain.json, 35 terms, extraction-style: the agent proposes, the founder reviews); nonsense answers honestly with nothing. The page draws what the memo asked to see: the six layers as columns, weighted arcs for attention and look-back between them, padding dimmed at its tiny weight, doc bindings in blue and pack bindings in purple, the winner lit. The visual language borrows deliberately from the LLM-visualisation lineage recorded in the brief (Alammar's Illustrated Transformer, BertViz, 3Blue1Brown, TensorFlow Playground, and closest in spirit Anthropic's attribution graphs — which reverse-engineer what the WCLM has by construction). Brief 31 carries the memo verbatim with ten instructions mapped and the defaults taken flagged for review. Three new gate-27 vectors (68 tests); verified in headless Chromium. Methods register entry 35, status experiment. No book content changed.
v0.5.1 26 August 2026 The file explorer: the document's artefacts, raw and viewed. The founder's observation driving it: as the cross-references grow, the site needs an honest window onto the data underneath the pages, not just the pages. Every document now gets {slug}.files.html — a file tree on the left (the authored folder: source, extraction, cross-references, identity ledger, README; and the generated core data: the index, thirty-two shards, the tokens, the word forms, the formatting graph — forty-one files for the pilot), the file on the right. Raw mode is exactly what was asked: minimal formatting, just colours and alignment — JSON pretty-printed with keys, strings, numbers and keywords tinted; markdown line-tinted (headings, quotes, list markers, fences) without touching a byte of it. Every file the build understands also carries its own data-driven view: the extraction as family-chipped node and edge tables, the ledger as a live/retired identity table, the cross-references as a rated-uses table, the tokens as a ranked bar chart with the ◊ candidates, the core index as a per-section table, each shard as its blocks with their uids, and markdown rendered. Raw is always one tab away, and every file deep-links (#docs/<slug>/ids.json) and opens directly as a plain URL. The pure logic (colorizers and all nine view builders) lives in core/fileview.js under gate 27 (65 tests); the shell is under 100 lines; the manifest is generated at build so a new artefact appears in the tree without anyone remembering to list it. Verified in headless Chromium on desktop and iPhone (stacked layout, no horizontal scroll, deep links on fresh loads). Linked from the document page, and the universe menu gains "its files, raw and viewed". No book content changed.
v0.5.0 26 August 2026 The v0.4 era closes, and the site catches up with what it built. Three moves, all asked for by the founder in one message. The top menu tells the truth now: the second edition's working surface — the universe with its reader and standalone graph page, the founder's memos, the methods register (34 techniques), the lexicon, the artefact catalogue, the open decisions, the immediate-connection register — was buried as sub-items of "The book"; it is now a first-class The universe menu, and "The book" returns to being about the two editions. The front page stops describing the second edition as "the plan and its scaffolding" and shows what four days actually built. The retrospective: forty-one releases weighed in the v0.4 retrospective — the seven achievements that compounded (extraction discipline, the instrument reader, the stability principle, navigation-as-query, the core graph, the component proof, the working-pack culture), the conclusions (the voice-memo loop works; gates buy speed; two agents can share a repo politely; honest debt beats hidden debt), the transferable learnings (persistence makes identity; fit is a decision; the measurement is the discovery; test the harness too; screenshots need state in the pixels), and what v0.5 opens. And the history is kept whole but shelved: the forty-one v0.4.x entries — a great historical view, as the founder called them — moved intact to the v0.4 era, the thirty-five earliest to the beginnings, and this page starts clean for v0.5.x. The generators that read the release table (the front-page timeline, the changes data) now read every era page, so nothing computed from history lost a byte of it. No book content changed; no viewer behaviour changed.

How a version is decided

← Comms How this site is built →