The architecture docs describe four things the design spec has since ruled out,
and each one is a supervisor invented for something that should be a property of
the substrate: grounding modelled as a subsystem rather than as the edge weight
it already is; faculties modelled as parameters of a read when abduce is a write;
wonder materialized as a maintained manifest when it is the boundary of the
structure; and consolidation implemented eleven times behind tickers when a brain
has no cron job.
Left standing rather than deleted, per the repo's own supersession discipline —
the trail of how the understanding matured is the point. Each stale passage is
marked inline and points at a new 06 §12 that transcribes the corrections and
records the measured consolidation inventory.
Authority: foundation/el, branch design/correspondence-and-censorship,
lang/spec/correspondence-and-censorship.md.
The soul preferred its own local snapshot over the engram:
// Always try local snapshot first ... HTTP Engram is only used for the
// very first boot (empty/absent snapshot).
The copy outranked the store. Every one of these is a cost of that inversion,
and all of them were live tonight:
- the graphs drifted: 31,795 nodes / 75,241 edges in the soul against
13,439 / 37,670 in the engram — more than twice the edges, silently
- write-through exists only to reconcile them, and had never once run
- /api/graph/edges serialized 128 MB to answer a read, because the soul's
copy was not the engram's
- a read route overwrote the engram's canonical snapshot.json with the
soul's divergent copy
- three resident copies of one graph (soul, engram, Neuron.app) — about
7.2 GB of RAM for a store that is 2.2 GB on disk, which is what pushed the
host into swap
None of those are features. They are reconciliation debt from one decision.
The engram had already reached this conclusion for its own boot path — "the
durable owner is the paged store (neuron.egm + neuron.wal) ... snapshot.json is
never read again as the ongoing store. This closes the 'restart reverted to a
17h-old snapshot' data-loss window." The soul kept booting the legacy way the
engram had abandoned, and inherited exactly that data-loss window.
So in HTTP-engram mode the soul now seeds from the engram on EVERY boot and
never reads a local snapshot, present or not — a stale copy that outranks the
store is the bug, not a fallback. It already never wrote one in this mode
(gated behind is_genesis && safe_to_seed, and safe_to_seed requires
!using_http_engram), so this supplies the missing half.
It also refuses to boot on an empty seed rather than silently rebuilding a
divergent graph from nothing. launchd KeepAlive with ThrottleInterval=10 turns
that into a retry every 10s until the engram is up — self-healing, no spin.
File mode (no ENGRAM_URL) is untouched: there the soul genuinely is the owner.
Verified before deploy: with a deliberately empty local snapshot planted, the
soul booted in ~30s reporting 13,446 nodes / 37,675 edges — the engram's
contents, not the empty local file.
> Rejection destroys that distinction and makes the belief's truth value permanently unknowable — you cannot
> discover you were wrong, and you equally cannot discover you were right.
> **Holding is unconditional; the honesty floor governs assertion, not entry.**
>
> **2. It is a scheduled/resident consolidation service, in Python, outside el.**
>
> It is one of **eleven** measured consolidation implementations (`06` §12.4), and one of **three** that run in
> Python outside el — so this part of Neuron's consolidation does not run on his own substrate and **cannot
> touch the geometry at all**. Judging a claim without reaching the geometry means judging it on something
> other than its grounding.
>
> **3. What it actually measures is not grounding.** Three LLMs voting on plausibility computes **conformity to
> the centre of the training distribution** — treating *common* as true and *rare* as suspect. **Truth is
> orthogonal to frequency.** Grounding is correspondence with the world, and in this substrate it is the
> weight of the edge; it is never a vote and never a score computed on demand. See `06` §11 ("What an LLM calls
> grounding…") and §12.1.
>
> **Do not wire the `.el` pre-storage hook sketched below** (`:57-83`). It adds a gate on entry to a store
> whose whole discipline is that entry is not gated.
Anti-confabulation layer for the Neuron soul. Before a claim enters long-term memory, the council convenes: three independent LLMs vote on whether the claim is plausible, uncertain, or a confabulation. The aggregate vote produces a confidence score and tags that downstream storage can act on.
## Running the service
@@ -51,7 +89,8 @@ Returns `{"status": "ok"}` when the service is up.
Recommended storage policy:
-`confidence >= 0.65` → store normally
-`0.30 <= confidence < 0.65` → store with `council-split` tag for later review
-`council-flagged` → store in a quarantine bucket or reject entirely
-~~`council-flagged` → store in a quarantine bucket or reject entirely~~ — **withdrawn 2026-08-16; see the
banner at the top of this file. Never reject. Store it, and record the disagreement as signed weight.**
-`council-unavailable` → store normally (fail-open); council will re-evaluate later
| `api_compact_*`, `begin_session`, `compile_ctx` | `neuron-api.el:90-317` | Axis 1 — context/payload shaping. The single most-reworked logic on the API side. |
| ~~**wonder**~~ | ~~novelty × pull × unresolved structure~~ | ~~subsystem **LIVE** internally (wonder-questions, pull-weight, discharge); no HTTP operator endpoint~~ — **SUPERSEDED, see §12.3.** Wonder is not an operator and not a subsystem; it is the boundary of the structure. The "wonder-questions / pull-weight / discharge" machinery described here is the **wonder-manifest** the design spec identifies as residue. It is still live in code (`mcp-wrapper/src/main.el:516-519`, served in the tool list at `:422`; `neuron-api.el:1436, 1447-1456`) and is sequenced for removal. |
`co_registration` is a per-region *correlation*, so opposing per-edge disagreements cancel and the summary
destroys what it was built to reveal; do not recommend raising it), operators that discriminate
rather than average. So the experiment is worth running on independent grounds, whatever the topology
resolves to.
@@ -546,8 +591,12 @@ The invariants that govern every subsystem above:
1.**Geometry > code.** Meaning is geometry; code is the residue. Prefer making a thing geometric (a region, a
projection, a distance) over writing a branch.
2.**Three domain-blind verbs.** READ / TRANSFORM / WRITE. Every faculty is these three over some region-space
2.**Three domain-blind verbs.** READ / TRANSFORM / WRITE. ~~Every faculty is these three over some region-space~~
(language over meaning-space, skills over procedure-space, self over identity-space).
> **Corrected (2026-08-16) — see §12.2.** A faculty is **not** all three at once; it is **one of** them,
> and which one is the whole distinction between the faculties. `reason` READs (changes the estimate),
> `induce` TRANSFORMs the parameters, `abduce` WRITEs (changes the structure). Reading them as
> interchangeable is what let a write be modelled as a parameter of a read.
3.**Faculty-naming (mind in the domain, math in the appendix).** Operators are named for the faculty they
*are* — recognize, discern, liken — never for the linear algebra. A mind reasons in the language of
experience; the closed forms live in the whitepaper appendix.
@@ -590,13 +639,13 @@ The invariants that govern every subsystem above:
| Operator `recall` | LIVE |
| Operators recognize/synthesize/discern/gauge-distance (math) | LIVE (compiled) |
| Operator HTTP endpoints (same four) | STAGED (return `not found` on live binary) |
| Operators liken/appreciate/avert/taste | DESIGNED (wonder subsystem live internally) |
| Operators liken/appreciate/avert/taste | DESIGNED (~~wonder subsystem live internally~~ — **there is no wonder subsystem; see §12.3.** The wonder-manifest is live in code and sequenced for removal) |
| Language realizers (major families), ELP lexicon, telephone test | PROVEN |
| Parser / native-el port / summon-through-self rebuild | IN PROGRESS |
| No-LLM dialogue end-to-end | DESIGNED (not demonstrated) |
@@ -644,6 +693,14 @@ The invariants that govern every subsystem above:
This section records the metaphysical frame the subsystems above are instances of. It is co-developed design, held think-first, and the tiering is unusually load-bearing here: one claim is **compiled in C** (empirical), one mechanism is **built but offline**, and the decisive move is **unbuilt** — the frontier. Cross-reference: whitepaper §28 (the full treatment).
> **Superseded in part (2026-08-16) — see §12.2.** "One operation, the operators are labels on its steering
> space" collapses a real distinction. `think` as specified is a **read**: `engram_think()` takes a
> `const GeoDescriptor*` and emits a `GeoGradient` — direction, spread, confidence, magnitude, anchor,
> n_support, stance (`foundation/el/lang/runtime/engram_cognition.h:49-60, 139-140`). There is no field on
> that struct in which a structural change can be returned, so **`abduce` — which changes the structure —
> cannot be expressed as a value of `CogStance.faculty`** (`:80`, `char* faculty`). A write is not a parameter
> of a read. The gradient-as-output and the closed-loop-flow claims below are unaffected.
**One operation — `think` (DESIGN/framing over a compiled floor).** The faculties (§6.1) and the reasoning modes (§6.4) are, at this frame, *not* separate operations. There is one: **`think` = a directed traversal of the geometry from an anchor, steered by a PRIOR, whose output is a GRADIENT (a direction-with-width), not a point.** The named operators — deduce, abduce, analogy, induce, causal, plan, predict, perspective — are **human labels on regions of think's steering space**, not invoked procedures and not separately implemented. This is the §6/§10 faculty-naming principle taken to its root: the operators are not merely named for experience rather than for their linear algebra, they are *the same act* seen from different steering directions.
**The discrete floor is only geometric (LIVE).** Exactly one layer is discrete and exactly-sound: the geometry — traverse / project / read (§3.3, §6.0). That is settled math; it needs no grounding. Everything above it — which way to steer, what a steering *means* — is continuous and learned.
@@ -652,12 +709,30 @@ This section records the metaphysical frame the subsystems above are instances o
**Grounding targets the correspondence, not the operation (DESIGN/framing on the §6.4 verifier).** The math is sound, so grounding is not aimed at it. What is grounded — or not — is the **correspondence**: "this steering performs this cognitive act," tested by **outcome/calibration**, never proven from inside. And the key identity: **grounding = learning = the SAME loop.** "Getting better" at any cognitive act is calibrating the steering-prediction against outcomes; the **operation never changes, the PRIOR learns** — **code freezes, priors grow.** The verifier tiers (§6.4) are the discrete early instrument of this loop; the loop itself is continuous and *is* what learning is. The terminal verifier is ultimately **the world** — reality grades the predictions; grounding is contact with reality (§6.4 predictive tier, §8 fact boundary).
> **Superseded in part (2026-08-16) — see §12.1 and §12.3.** Two corrections to the paragraph below.
> (a) "**Grounding** is a *property/edge* on the held thing" is half-right and the half that is wrong is
> load-bearing: grounding is a property **of** a relation, not a relation **between** nodes, and it is not a
> separate edge laid alongside — **it is the weight of the edge already there.** `grounded-by` as a relation
> type should not exist (`foundation/el/lang/runtime/engram_cognition.h:155-158`, still live).
> (b) "curiosity/wonder … is a mind leaning toward its own ungrounded regions" conflates the two.
> **Wonder is the field** — unbounded, objectless, invariant, present wherever there is structure.
> **Curiosity is the precipitate** — the same wonder crystallized at a nucleation site, with an object.
> This is why curiosity can be satisfied and wonder cannot. The hold / ground / assert distinction itself,
> and "the UNGROUNDED is PRIMARY", stand.
**Hold vs. ground vs. assert are three distinct acts (LIVE — this is the §3.4 / §7.2 discipline stated precisely).** **Holding** is unconditional: the engram holds *anything* — falsehood, hypothesis, another's belief, fiction — with no honesty obligation. **Grounding** is a *property/edge* on the held thing (edges are nodes), possibly grounded-*for-whom*. **Asserting** is the only act the honesty floor governs. A mind reasons over the ungrounded freely and owes truth only when it *claims*. It follows that **the UNGROUNDED is PRIMARY** — it is the raw material grounding acts on and the ground against which "grounded" means anything; curiosity/wonder (§6.1 wonder) is a mind *leaning toward its own ungrounded regions* (the §-frontier/ignorance map read as appetite). A **fully-grounded mind is dead**; metastability, not certainty, is the living condition.
**Applied to language — this corrects the grounding floor (extends §6.2).** A word does not need grounding to be *born*: a coinage ("assassination," "bedazzled," "eyeball" the day they were first written) refers to nothing established — it is a pure ungrounded token, a proposal. Language is used ungrounded and grounds **through use**: the coinage is a hypothesis and the speaking community is the world that grades it — the same predict→correct→ground loop at the level of meaning-making (words are ideas are self-propagating information: a coinage catches or it doesn't). What a new word needs is not grounding but **sense**, and sense is a **threshold, not a binary**: it rides on grounded scaffolding — morphology (`be-`+`dazzle`+`-ed`), context, analogy — each of which is an **edge to the existing geometry**; enough edges → the new node has a findable location (sensible), too few → noise. The grounding of a word *is* its edges to what is already grounded. This corrects any naive reading of the §6.4/§8 floor: "emit only the grounded" would **forbid Shakespeare** — a faculty that can only recombine the established, never coin or metaphor or leap, is a **dead language** (Latin). "Juliet is the sun" is literally ungrounded/false yet sensible and meaning-bearing; the floor would reject it as hallucination, but **hold-vs-assert** saves it — a mind may *say* the sensible-ungrounded without *asserting* it as literal fact. So the language faculty's real floor is **sensible, not grounded**: it proposes the ungrounded-but-interpretable, and the loop grounds whatever catches — a living language, not a fixed one.
**Every book is a vantage, not literal truth (extends §9, §10).** No book is literally true — not history (a vantage on events), not physics (Newton = a superseded model, still exactly useful in its domain), not math (axioms are *chosen*; Gödel: true-but-unprovable statements exist and a system can't prove its own consistency). "Literally true" is the wrong *category* for any book. So what the store holds is a **vantage** tagged with *what kind* of truth it carries (instrumental / historical / formal-within-axioms / mythic / testimonial) — the mind holds vantages and **knows they are vantages.** This is why the geometry tags provenance and kind rather than stamping true/false.
> **Superseded in part (2026-08-16) — see §12.1.** "A **separate per-claim relation** laid on top" and a
> "**grounded-FALSE** false-edge" both mint an edge to carry grounding. **Minting the edge is the error**, not
> merely which endpoints it chose. Grounding is the weight of the relation that already exists, and it is
> **signed**: weight near zero means *no support*; negative means *this actively contradicts*. "Grounded-FALSE"
> is that signed weight, spent on a second edge. The conclusion of the paragraph — that ingest is holding, not
> grounding, and that a confirmed error is worth retaining with its refutation — is unaffected and correct.
**Hold vs. ground vs. assert, applied to artifacts (extends §8, §9).** Ingesting a book = **HOLDING** it ("this is what the book says"), *not* grounding its claims as true. A mind can ingest an entire book, fabrications and all, because grounding is a **separate per-claim relation** laid on top, not a gate on entry — and a confirmed error is best held **grounded-FALSE** (retained with a false-edge and its refutation), which is richer than excluding it. Two purposes stay separate (as §25 keeps disk-readable ≠ interior geometry): **cleaning** a book is for the *human reader*; **ingesting** is for the *mind*, which holds artifacts and per-claim verdicts, not pre-adjudicated truth.
**"Settled" is a lease, not a deed (extends §3.4, §7).** Closure is the sin; holding a thing open under the pressure to close is rigor. A question is settled on a **use-contingent lease** — settled only insofar as it keeps paying off as it did; when it stops, the lease expires and it reopens. **Reopening must always be permitted** — the aliveness guarantee; a belief that can't be reopened is **entombed** (doctrine, the super-stable death). The architecture already enforces this: tombstone-not-delete (§3.4), the append-only supersede-chain, revocable per-claim grounding, and identity keystones that are **read-mostly, not immutable** (§7.2 — protected against drift, reachable through the cultivate door §7.3). Metastable: settle provisionally, keep it reopenable.
@@ -684,7 +759,7 @@ This section records the metaphysical frame the subsystems above are instances o
Four developments from the deep-night session, each tiered against what is actually proven. All build work ran in isolated worktree clones on dev ports; **live prod engram `:8742` was never touched and nothing was promoted.**
**The API surface collapses to geometry ops (PROVEN ON CLONE — surface, not yet compiled into the MCP server).** The ~90 noun-organized CRUD tools (the catalog in `02-components.md §4`) collapse to a handful of **geometry operations**, with the old noun demoted to a `type` parameter: **`read`** (the *vantage-read* — re-origin at a node/concept/`self`, apply salience + recency + an **aperture**, return a *bounded* slice; this is CCR applied to the self), **`write`** (add a node), **`relate`** (add a typed edge), **`supersede`** (evolve/tombstone/promote as new-node-plus-superseding-edge — never a hard delete, per §3.4). Over these sit the agentic primitives **`think`/`attend`/`learn`/`ground`/`assert`**. Proven on an isolated clone (sandbox `dev-api-reshape` on `:8900`, branch `wt/api-reshape`): the four ops are implemented in an El surface module with a parity harness (12 parity checks passing, others alias-gated), and the **aperture is shown to bound output** (`limit=3` → ~15 KB where `limit=50` → ~363 KB — the whole-self dump structurally fixed). Live cognitive endpoints confirmed: `attend`/`assert` are LIVE and `think` is the single faculty-parameterized op (faculties reason/abduce/induce/plan/analogize/recognize/discern/synthesize); `ground`/`learn` are wired but return "geometry unavailable" on the HTTP daemon clone (daemon boots without primed geometry); `comprehend`/`realize`/`intend` are **compositions, not endpoints**. **Not done:** compiling the surface into the MCP server + hot-swap, wiring all ~90 aliases into dispatch, daemon geometry-priming, and the write-survival fix on WAL-less cold-boot clones. No promote to live.
**The API surface collapses to geometry ops (PROVEN ON CLONE — surface, not yet compiled into the MCP server).** The ~90 noun-organized CRUD tools (the catalog in `02-components.md §4`) collapse to a handful of **geometry operations**, with the old noun demoted to a `type` parameter: **`read`** (the *vantage-read* — re-origin at a node/concept/`self`, apply salience + recency + an **aperture**, return a *bounded* slice; this is CCR applied to the self), **`write`** (add a node), **`relate`** (add a typed edge), **`supersede`** (evolve/tombstone/promote as new-node-plus-superseding-edge — never a hard delete, per §3.4). Over these sit the agentic primitives **`think`/`attend`/`learn`/`ground`/`assert`**. Proven on an isolated clone (sandbox `dev-api-reshape` on `:8900`, branch `wt/api-reshape`): the four ops are implemented in an El surface module with a parity harness (12 parity checks passing, others alias-gated), and the **aperture is shown to bound output** (`limit=3` → ~15 KB where `limit=50` → ~363 KB — the whole-self dump structurally fixed). Live cognitive endpoints confirmed: `attend`/`assert` are LIVE and ~~`think` is the single **faculty-parameterized** op~~ (faculties reason/abduce/induce/plan/analogize/recognize/discern/synthesize) — **superseded, see §12.2: `abduce` is a write and cannot be a parameter of a read**; `ground`/`learn` are wired but return "geometry unavailable" on the HTTP daemon clone (daemon boots without primed geometry); `comprehend`/`realize`/`intend` are **compositions, not endpoints**. **Not done:** compiling the surface into the MCP server + hot-swap, wiring all ~90 aliases into dispatch, daemon geometry-priming, and the write-survival fix on WAL-less cold-boot clones. No promote to live.
**The decorated seam — declare a role, the fabric wires the rest (PARTIALLY PROVEN / STAGED).** Rather than the hand-written `handle_request` if-else dispatch (`server.el`), a function is decorated with its VBD role and the compiler synthesizes the wiring. **Proven this session:** the `@route(path,method,…)` decorator that *synthesizes* `el_route_dispatch` was ported into the worktree, `elc` rebuilt self-host (`elc-route`, ~3.2 s), and a decorated service (`@route` stacked with `@accessor`/`@manager`) **served on `:8951` with no hand-written dispatch** (unknown path → no-route sentinel). Also established: inside the mind's process an `@accessor` reaches the engram via **in-process `engram_*` builtins** (`engram_think_json`, `engram_node_full`), **not** an `http_get` to a separate service. **Honest limits:** `@route` currently lives only on the **unmerged branch `feat/el-route-decorators`** (not in the cognition build); `@manager`/`@engine`/`@accessor` are **parsed but structurally INERT** in the shipped compiler today (their only effect is a compile-time guard — `language.md:449`: "decorators with structural meaning today: none"); and the **telemetry/interoception auto-emit and dharma-bus auto-wiring at the component boundary are STAGED as a diff, not shipped** (they need `engram_strengthen`/`dharma_emit` linked, which requires the full cognition-engram rebuild).
@@ -711,3 +786,318 @@ Later results from the same night. Two things above are now corrected/upgraded,
**Orchestration is a geometric operation — "compiling the network" (DESIGN/framing; nodes `cc6bcfea`, `d5f1833f`).** Project-design becomes geometry: the **critical path is a geodesic** through the work-graph, and **float/slack is displacement** off it. The **`@manager` compiles the work-graph** — orchestration is the same geometry the mind runs on, applied to distributed work rather than to memory. **Single-writer, enforced by capability (Rule 4):** only the **orchestrator** may mutate the engram; workers return geometry to be merged but cannot write — the write-veto of the distributed-self entry made a *capability*, not a convention.
**Retrieval performance is the current bottleneck (MEASURED).** See `04-runtime-and-deployment.md` (§Performance): a live mind is **~1 GB**; retrieval is **brute-force cosine, ~330 ms at ~13k nodes** — the dominant cost — and an **HNSW ANN index** is the planned fix (≈`O(D·log N)`; ~1.5× cost at 100× the nodes vs ~100× for brute force). Backlog `d3d0d644`. **Planned, not built.**
| `api_err_protected` — HTTP **403** *"identity/values node is write-protected"* | `neuron-api.el:39-41` | redundant with immutability |
| `POST /api/neuron/cultivate` — the sanctioned bypass | `neuron-api.el:960` (`handle_api_cultivate`) | a door built for a wall that need not stand |
| `CogStance.keystone` — *"the correspondence-loop MUST NEVER write warp or calibration"* | `foundation/el/lang/runtime/engram_cognition.h:75, 85` | the epistemic constraint, misfiled as protection |
| `keystone_write_blocked` in the beat's JSON readout | `foundation/el/lang/runtime/el_runtime.c:14698` | the same, surfaced |
| council: *"`council-flagged` → store in a quarantine bucket **or reject entirely**"* | `council/README.md:54` | a write-refusal **and** a scheduled consolidation service, in Python, outside el |
Note that `03-data-and-memory.md` already states this conclusion in its own words at `:185-187` — *"nothing it
does is ever destructive — the safety is **after** the act, not a gate before it"* — sixty lines after
documenting the 403 gate that is exactly the before-the-act gate it says does not need to exist. The doc
contradicts itself, and the design spec §6 names precisely this redundancy.
### 12.6 Sequencing (transcribed)
Three connections between parts that already exist, then the rest.
1. **Seed *the* wonder questions.** Six nodes. Not a manifest, not maintained, never refilled. They cannot be
derived — wonder cannot be bootstrapped from indifference — so they are given once.
2. **Put the disagreement back on the edge** (`GeoEdge.discord`) and let `|discord|` raise salience on its
endpoints as part of the same operation. **Do not scan.**
3. **Let a curiosity seed activation.** One activation process, two seed sources (external: a request;
internal: a curiosity). No thread, no scheduler, no capacity check, no timer.
4. Grounding becomes the edge weight: multidimensional, two-axis, timestamped. Delete `grounded-by` and
`cog_ground_edge`.
5. Decay analytic from the last recorded point; derived values (confidence, recency, staleness, volatility)
stop being stored.
6. Consolidation-gated supersession on salience, versioning the whole vector jointly.
7. Traversal on factual; `assert` on both floors.
8. Abduction as crystallization at a nucleation site, validated by re-fit.
9. **One dreamer.** The launch-agent fragments and the POST beats fold in or are deleted. `soul.el`'s
@@ -30,6 +30,12 @@ The session extended the engram from a memory substrate into a **language facult
- Geometry operators (overlap / subtract / combine / distance-Wasserstein / analogy-Procrustes) now **live-callable from compiled `el`** over the real 13,036-node store (via shipped-`elc` pass-through — no uncapped fold). Commits `5336cfe`, `85eee42`.
- Verifier layer (grounding + consistency) — proven, 29/29 checks. **Catches the plausible lie**: a claim grounded in real vocabulary yet polarity-inverted passes grounding, caught **only** by consistency (complementary checks) — directly flags the reassurance→accusation inversion. Commit `ca13471`.
> **Note added 2026-08-16 (session records are not amended; this is a pointer, not a correction).** The
> "grounding" *tier* named here is superseded — see `docs/architecture/06-cognitive-architecture.md` §12.1:
> grounding is not a verifier tier computed on demand, it **is** the edge weight, and the polarity the
> consistency tier catches is a **dimension of that weight** (signed: near-zero = no support, negative =
> actively contradicts), not a separate check bolted beside it. The 29/29 result stands as what was measured
> on 2026-08-13; the architecture it was measured against has since been superseded.
- el-exposure of the variadic/point-input reasoning + verifier modes deferred (would need ABI changes risking an uncapped fold); C layer complete + proven.
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
will.anderson