A model with many surfaces

The pipeline

Seven extractor families read a repository. Each emits immutable evidence assertions of the form subject, predicate, object, against a scope snapshot pinned to the exact source revision it read. Nothing is written in place. Projections are built from those facts and can be deleted and rebuilt at any time; a test does exactly that on every run, rebuilding every current projection from an empty cache and comparing it to the stored one.

One node, seven surfaces

Below is a single node from this codebase, the class WeaveScorer, rendered the way each surface would ask about it. Nothing about the node changes. What changes is the question the surface is asking.

/// The deterministic Weave scorer. Pure, model-free: it turns a closed
/// Work Episode's deterministic evidence into an honest Scorecard.
public sealed class WeaveScorer
{
    public Scorecard Score(
        WorkEpisode episode,
        DeterministicEpisodeSignals signals,
        ScoreSchema schema,
        TimeProvider time)
    {
        // 1. Not Scored gate: no goal, no done-condition,
        //    not closed, or no verification path.
        var notScored = NotScoredReason(episode, signals);
        ...
    }
}

The fifteen surfaces

A surface's identity, state and content are independent of where it is docked. One factory maps a surface kind to its content, so adding a kind never means touching the layout model, and an unknown kind still gets an honest pane rather than a blank one.

Fourteen rows for fifteen kinds: view and inspector share a row because they share a reader. The list is a published constant the application checks itself against, so a surface cannot exist without appearing here.

Why the model is edited through agents, not surfaces

The temptation with a diagram tool is to make the diagram editable. Drag a box, rename a class, and have the code follow. It is the feature everyone asks for, and it is the one this project refuses.

A derived view that can be written through is a second source of truth. The moment two places can define the same thing, they disagree, and the disagreement is silent, because both look authoritative. The repository carries this as a standing rule with its own architecture decision record, and the modelling reviewer holds a veto over any editable derived view.

So the write path runs the other way. You direct an agent; the agent changes the repository; the extractors observe the change and append new facts; the projections rebuild; every surface updates because every surface was only ever a question asked of the same store. The model is transient in the sense that any particular state of it can be thrown away and reconstructed, and durable in the sense that the facts, and the record of how they got there, are the thing that is kept.

• A correction is a superseding fact. Nothing is rewritten, so the history of what was believed, and when, survives the correction.
• Extraction is pinned. Every assertion carries the scope snapshot and source revision it was read at, so a stale answer is detectable rather than merely wrong.
• Coverage is declared. When an extractor cannot analyse a language, the graph says so rather than looking complete. A graph that silently omits package types looks finished and gives the reader no way to know it is not.
• Rebuild is tested, not assumed. A fixture replay rebuilds every current projection from an empty cache and compares it to the stored one. If projections could drift, that test fails.