.NET without a build: --mode source

Compiled mode reads the built assemblies and their portable PDBs, and it is the gate: the compiler has resolved every reference, so its edges are exact (ADR-0011). On a large solution a build takes minutes, and an agent will not build to check one import (design § Where it would be ignored). --mode source reads the .cs files instead, with tree-sitter-c-sharp, and resolves names the way the compiler looks them up, without compiling anything. It is the inner loop's answer, never the gate (Wave 3, Step 14; FR-EXT-DN-04).

rulebearing cruise --mode source -T err

or, in a native configuration:

languages:
  dotnet:
    mode: source      # compiled (the default) | source

--mode wins over languages.dotnet.mode.

What is read

A partial type lands in one file, as a compiled build attributes it: the part that declares a constructor when exactly one does, else the file named after the type, else the first by path. What a build compiles into the type rather than into a method (a field's type, a signature, an attribute, a base type, an initializer) is attributed to that file, and a part with code has an edge to it; what is written in a method body stays with the file that writes it. A namespace a using directive imports that no file declares is an external module named by the namespace: package when a package reference of the project provides it, framework for System.* and Microsoft.*, else undetermined, since without a build nothing says whether it resolves.

What is marked

The document's marks are additive, and the json reporter's --strict-schema removes them (ADR-0004), so a source-mode run asked for that output exits 2 with approximate-mode-not-strict unless --allow-approximate-gate is given: without its marks the result could gate later (cli.md); the agent report keeps its header and its per-finding marks, since an agent reading it must know. Source mode has no code layer, so element rules have nothing to evaluate there; compiled mode evaluates them.

What it cannot know

A name is resolved without a compiler, so what only a compiler decides is not known: overload resolution, members inherited from a base class (a call to one lands in the class that uses it, not the one that declares it), and the type behind var. An extension method call (services.AddClock()) is resolved as C# looks extension methods up, from the innermost namespace out through the static classes each level declares and imports, with C# 14 extension(T x) { ... } blocks included; without the receiver's type every candidate at the first level that has one counts. A constant or an enum member read is no edge, since the compiler writes its value where it is read. A local variable or a property that shares its name with a type in scope reads as that type. Every edge is therefore approximate, and how close it is to a compiled graph is measured rather than assumed:

The ten oracles are every .NET oracle of testbeds/manifest.yaml, and each is above the 90% precision target. The comparison covers edges between two files both modes know, each oracle at its pinned SHA with the solution the oracle row names, the compiled side built in Release as the nightly builds it, with the row's msbuild arguments and the newest 10.0 SDK beside 8.0 and 9.0 (TNG/ArchUnitNET's global.json asks for 10.0.400, and DrJohnMelville/Pdf's [FromConstructor] source generator emits no constructors under the 10.0.100 SDK). cargo test -p rb-extract-dotnet --features source-mode --test source_mode asserts at least 90% precision and recall on the two built fixtures and writes target/source-mode-precision.json; the nightly runs testbeds/oracles/precision.py on every .NET oracle and joins the results into source-mode-precision.json (Wave 3, Step 14). Measuring it also found two edges compiled mode missed, now fixed: the body of an async or iterator method of a release build, and top-level statements.

The nightly measures it again on every .NET oracle row, against the compiled graph that row's own architecture tests run against: the assemblies the imported tests name, not the whole solution. testbeds/oracles/dotnet.sh writes each result and the summary job joins them into testbeds/results/source-mode-precision.json. TNG/ArchUnitNET and BenMorris/NetArchTest are the conformance suites of gate 2, not oracle rows there, so the nightly lists eight. Measured that way on 2026-10-08, each at its pinned SHA with the 10.0.401 SDK:

DrJohnMelville/Pdf was at 70.75% on every night from 2026-10-03 to 2026-10-08. Its [StaticSingleton] source generator writes a partial type's constructor under obj/, and compiled mode credited the type's base class and fields to that generated file, which source mode never reads. Compiled mode now attributes a type to a file its developer wrote whenever the PDB names one (ADR-0061); the other seven oracles have no generated partial types and did not move.

Never the gate

A run read in source mode never passes or fails a gate. cruise with a reporter that gates, fmt --exit-code on a saved source-mode result and diff --exit-code with a source-mode side print warning: approximate-mode-not-a-gate: ... and exit 2, whether the count was zero or not; attest refuses to sign such a graph at all. cruise --from-hook answers as it always does, because the Stop hook is the inner loop source mode exists for. --allow-approximate-gate gives the count back for a local script (cli.md; FR-EXT-DN-04).

The cache

Under --cache, a changed .cs file is the only one parsed again; every other file's parse is taken from the entry, and the resolution, which depends on every file, is run over all of them, so an incremental run equals a full one. A .cs file added or deleted, or a project file changed, reads everything again. A build since the entry was written changes nothing, since no assembly is read (cli.md).