Architecture

This server answers one question: how is this written at home. It is asked by an agent working in a codebase that is not home — another repository, another product, sometimes another language — and the answer has to carry the authority of the reference codebase without pretending to be about the code in front of the agent.

The rule is the centre

The unit of this server is a rule, not a declaration. The written guidelines decide; the index shows them being followed where it can check that they are. A rule is read whole out of the document its author keeps, never summarised and never derived, because a derived rule is a second opinion standing next to the first.

Three questions arrive here, and they are not the same question:

The agent asks Answered by Out of
what the rules are get_guidelines the written document
which rule applies here get_guidelines with a topic the rules as rows of the index
what shape this has here get_di_conventions, get_dto_format, search_code_patterns declarations

The second one is why the rule is the centre. Before it existed, a question about one rule was answered with every rule, and the agent was left to decide which of fifty applied — which is the agent doing the server's work with less information than the server had.

Half of this is built, and the half says which

A rule is answered with its text, the checks that hold it, and — for the rules that can be judged from the index — declarations that were checked against it and keep it, named with their file and line. Candidates are found by meaning and narrowed to the kind the check can speak about; the verdict comes from the check, never from the similarity. A rule nothing near it keeps says that too, because that is a fact about the reference rather than a gap in the answer.

Only three rules are judged, and the measurements chose them. Of the written rules, twenty-one name an analyzer the build already enforces: a project cannot ship while breaking those, so a verdict on them would be true by construction and worth nothing. Of the rest, the reference was measured for something to sift. On 2026-10-15: 32.5 % of its declarations carry no documentation comment, and 51 of 263 records are not sealed, while leaking a List<> through a public signature happens in 1.3 % of members. On 2026-11-13, outside the tests: 311 of 857 methods answering a task take no cancellation token, while 0.6 % of the methods building strings use string.Format or + and none puts an else after a return. So documentation, sealed records and cancellable asynchrony are checked, and nothing else is: a check that passes everywhere does not tell examples apart.

Every other rule still answers without examples. That is the honest state: picking an example by meaning alone breaks the very rule it is offered for about a third of the time, so where there is no check there is no claim. Extending this means adding a check to the table beside the rule's id and the kind it applies to — and measuring first that there is anything for it to exclude.

The rule says what holds it

A rule carries the build checks quoted in its own text. That is what lets an agent tell what the compiler will catch from what only a reader will, and it is the difference between spending an answer on work the build was going to do anyway and spending it on work nothing else can.

A rule no analyzer can judge says so. "Held by review" is a fact about the rule, not a gap in it.

The boundary with memory

Authored knowledge and derived knowledge are kept apart, and the line is an invariant:

Memory holds what cannot be derived from the code. The index holds what must be rebuilt from it. A rule joins them, and a measurement never overrules a decision.

This is why nothing in this server writes a rule. Rules exist only where someone wrote them down, they are re-read from that document by the same pass that re-reads the code, and they are stamped by its contents, so editing the document rewrites them rather than adding to them. A file planted at a link above the configured one would silently become the authority — so no code here can plant one, and a test holds that shut.

Every answer is a snapshot, and says so

The index is a reading of a codebase taken at a moment, and two things go wrong with that in silence: a question about another repository is answered from the configured one as if it were the same house, and a reading taken before a month of commits reads exactly like a current one. So every answer opens by naming the codebase it came from, how many projects that covers, and when the reading was taken; the guidelines name the file they were read from.

What is one table

Rules and declarations are rows of the same index, told apart by kind. A rule is answered only when it is asked for by kind, so a search for code never returns one. Rules are written under the path of their document as if it were a project, which is how they inherit the lifecycle the code already has: a document that has not changed is not re-read, and a document that is gone is forgotten.

A pass stores one more thing that is not code: how it ended. Its readiness rides the same bookkeeping, under a name of its own, so every later answer can say that solutions were left out — otherwise a solution missing from the index is indistinguishable from a convention the codebase does not have. Neither marker is a project, and anything counting projects says so.

What this server will not do

  • It never writes to the codebase it describes, and never to the one being edited.
  • It cannot report a violation: it does not see the code being changed and has nothing to compare.
  • It does not answer style out of declarations. No declaration documents how to name a variable, and a search for one returns plausible neighbours at a confident-looking score. Style comes from the rules.
  • It does not invent rules where none are written. "This codebase keeps no written guidelines" is an answer; a draft of counts presented as rules is not.