@rsconcept/rstool 0.2.1 → 0.3.0

package/docs/CONCEPTUAL-SCHEMA.md

@@ -1,168 +1,78 @@
-# Conceptual schema (КС) — agent recommendations
+# Концептуальная схема
 
-This note complements the mechanistic references:
+Справка про проектирование КС как системы определений. Для механики см. `CONSTITUENTA.md`, `SYNTAX.md`, `TYPIFICATION.md`.
 
-- `CONSTITUENTA.md` — how to upsert constituents correctly (fields, order, validation)
-- `SYNTAX.md` / `TYPIFICATION.md` — how to construct correct RS expressions
+## Цель схемы
 
-Here we focus on **how to design and analyse a conceptual schema as a system of constituents**.
+КС ценна не числом конституент, а различениями, которые она вводит.
 
-## What makes a schema valuable
+- Добавляй понятие, если оно дает новый критерий, роль, отношение, инвариант или правило.
+- Если пользователь постоянно переформулирует одно различие, введи отдельную конституенту.
 
-The value of a conceptual schema is the **diversity of concepts expressed in it**.
+## Текстовые поля
 
-- A good schema forms a **domain thesaurus**: a stable set of terms and distinctions that people can use for communication and decision-making.
-- “Diversity” is not the same as “many aliases”. Prefer concepts that introduce **new distinctions** (new criteria, roles, constraints, invariants) instead of synonyms.
+`term`, `definitionText`, `convention` держи в языке схемы и в ее словаре.
 
-Practical agent heuristic:
+- `term` — короткое имя понятия.
+- `definitionText` — текстовая интерпретация формального определения.
+- `convention` — соглашение для неопределяемого понятия.
 
-- If you can remove a derived concept `D#` and lose no important language for reasoning, it is probably redundant.
-- If stakeholders keep rephrasing the same thing in different words, the schema likely misses one or more constituents that capture the missing distinction.
+Перед записью `definitionText` проверь существительные: важный предметный термин должен быть введен как `N#`, `X#`, `C#`, `S#` или `D#`.
 
-## Rule for text fields (term / definitionText / convention)
+## Номиноиды и атрибутирование
 
-When you write natural-language text in a schema, follow this strict rule:
+`N#` — номиноид: именованная сущность для словаря схемы. Он помогает фиксировать термин до точной родоструктурной формализации.
 
-- **Use only terms that are introduced in the schema itself.**
+Атрибутирование связывает номиноид с другими конституентами через атрибуты. Это отдельная атрибутивная экспликация, не замена `S#`, `D#`, `A#` в родоструктурной экспликации.
 
-Rationale:
+Правило для `rstool`: не смешивай атрибутивную и родоструктурную экспликацию. Используй `N#` как словарную опору, но не превращай атрибуты в RS-формулы и не добавляй атрибутивные связи, если пользователь явно не просит совместить эти способы.
 
-- Text definitions that rely on “external vocabulary” quietly import unstated assumptions and weaken the schema as a shared thesaurus.
+## Родовые структуры
 
-Agent checklist:
+`S#` — родовая структура. Ее `definitionFormal` задает типизацию, а смысл задают конвенция, интерпретация и аксиомы.
 
-- When you add a new `definitionText`, scan it for nouns/terms. If a term is essential, introduce it explicitly (typically as `N#`, `X#`, `S#`, or a derived `D#`).
-- Prefer short “closed-world” definitions: explain a concept using already-introduced schema terms plus logical connectives (“and”, “or”, “not”), quantifiers (“for all”, “exists”), and references to RS expressions.
+Паттерн для отношения:
 
-## Modeling genus structures (родовые структуры) as `S#`
+1. `X1` — базисное множество.
+2. `S1: ℬ(X1×X1)` — отношение; порядок пары описан в `convention`.
+3. `D# := Pr1(S1)`, `D# := Pr2(S1)` — именованные компоненты.
+4. Сложные термы строятся поверх этих `D#`.
 
-`S#` constituents represent **base structured concepts**: their `definitionFormal` is a **typification** (grade), and their meaning is set by `convention` plus axioms.
+Если повторяется цепочка вроде `Pr2(Fi1[D](S7))`, введи промежуточный терм или уточни конвенцию/аксиому для `S7`.
 
-### Define structure components explicitly
+## Аксиомы
 
-For a genus structure `S#`, it is often useful to define **all components** as named derived terms.
+`A#` — логическое требование к модели. Используй аксиомы, чтобы:
 
-Why:
+- фиксировать смысл `S#`;
+- задавать уникальность, тотальность, непересечение, порядок, область и диапазон;
+- оправдывать `debool(...)`: внутреннее множество должно быть гарантированно одноэлементным.
 
-- It gives names to projections / reduced parts of a structure, making the thesaurus usable.
-- It shortens later formulas and prevents agents from repeating long projection chains differently in different places.
+## Проверка на маленькой модели
 
-Typical pattern for a binary relation over a base set:
+Когда семантика определения не очевидна, используй концептуальную модель как тестовый стенд: задай минимальные значения для `X#`, `C#`, `S#` и вычисли проверяемые `D#`, `F#`, `P#`, `A#`.
 
-- `X1` — base set (undefined)
-- `S1 : ℬ(X1×X1)` — relation as a structure (undefined, meaning via convention)
-- Component terms:
-  - `D_dom := Pr1(S1)` — “domain” / “left elements”
-  - `D_cod := Pr2(S1)` — “codomain” / “right elements”
-  - `D_pairs := red(bool(S1))` is usually nonsense; instead name the parts you truly use
-  - For higher-arity structures, define `Pr1`, `Pr2`, … and relevant multi-projections (`Pr1,3`, etc.)
+Это особенно полезно для проекций, фильтров, `red`, `bool` / `debool` и аксиом. Если проверка важна для будущих изменений, перенеси ее в скрипт-тест: собрать маленькую сессию, задать значения неопределяемых конституент, вычислить целевые конституенты и проверить не только `success`, но и ожидаемое `value`.
 
-More generally:
+Подробный цикл: `MODEL-TESTING.md`.
 
-- **Projections** (`Pr*`, `pr*`) are the main tool for naming components.
-- **Reduce** (`red`) is useful when a component is a set-of-sets and you need a flattened union; introduce a named `D#` when you use `red` in more than one place.
+## Быстрое ревью
 
-### Avoid “anonymous structure usage”
+- Атрибутивная экспликация не смешана с родоструктурной без явного запроса пользователя.
+- Не добавляй проверки принадлежности к собственной типизации: если `x` уже объявлен в `X1`, `x ∈ X1` избыточно.
+- Покрыты главные предметные сущности, роли, отношения и утверждения.
+- Слои идут так: `X#`/`C#` → `S#` → простые `D#` → сложные `D#`/`F#`/`P#` → `A#`/`T#`.
+- У каждой аксиомы понятная цель.
+- Частые падения аксиом в модели указывают на ошибку данных или семантики схемы.
+- Сомнительные выражения проверены на маленькой КМ, если есть показательные тестовые данные.
 
-If later definitions repeatedly use expressions like `Pr2(Fi1[D](S7))`, it is usually a sign that:
+## Рабочий порядок
 
-- the schema is missing a named constituent for that concept, or
-- the structure `S7` is underspecified (needs conventions/axioms).
-
-Prefer to introduce:
-
-- an intermediate derived term `D#` for the filtered relation/set, and
-- separate terms for the projections you interpret in text.
-
-## Axioms as semantic direction
-
-An axiom `A#` is a **true statement** that:
-
-- defines the intended semantics of genus structures, and
-- enables safe derivations (“in a certain direction”) by providing guarantees needed for operations.
-
-Think of axioms as giving you _permission to use certain operators_ without risking typification/runtime failures or semantic ambiguity.
-
-### Example: singleton guarantee for `debool`
-
-`debool(S)` is only meaningful when `S` is guaranteed to be a **singleton**.
-
-In practice, when you build `S` as a projection/filter result, you often need an axiom that guarantees uniqueness.
-
-For example, for a binary relation `S1 : ℬ(X1×X1)` you may want to define a function-like choice:
-
-- `D_childOf(x) := debool(Pr2(Fi1[bool(x)](S1)))`
-
-This is only valid if for every `x` the filtered projection yields exactly one element.
-That guarantee is provided by an axiom of **right-uniqueness** (functional dependency) for the relation (written in RS logic for your specific structure).
-
-Agent rule:
-
-- If you see `debool(...)` in a definition, ensure there is an axiom that makes the inner set a singleton on the intended domain.
-- If the axiom is absent, either (a) add the axiom, (b) replace `debool` by keeping the set-valued result, or (c) restrict the domain explicitly so the singleton property holds.
-
-## Expression hygiene: avoid tautological membership checks
-
-In well-typed/correct RS expressions, you should avoid adding membership predicates that only restate what is already guaranteed by typification and by the correctness model.
-
-Specifically, avoid “sanity checks” like:
-
-- `x ∈ X1`
-- `x ∈ ℬ(X1)` (and other plain grade constructions such as `X1×X2`, `B(X1)`, etc.)
-
-when `x` is already bound/typed as an element compatible with `X1` (or with the intended element structure induced by `ℬ(X1)`, `X1×X2`, …).
-
-Why this is usually meaningless:
-
-- `AnalysisResult` checks expressions in a **global context** where identifiers must have known typifications and must satisfy **bijective portability**.
-- Under these guarantees, values of an element grade “already belong” to the corresponding set/grade in the semantic sense; so the predicate becomes (effectively) TRUE and adds no discriminating information.
-
-Agent rule:
-
-- Use membership (`∈` / `Fi*`) to express *nontrivial* schema semantics (e.g. defining/characterising derived sets), not to re-check that a value matches its own typification.
-
-## Bijective portability (биективная переносимость)
-
-**Bijective portability** means that a formal meaning/definition of a constituent depends only on the *structure* that the schema intends, and not on arbitrary “names” of undefined-concept interpretations.
-
-Concretely, if you replace interpretations of undefined concepts by a bijective renaming (structure-preserving renaming), then:
-
-- the evaluation result of every bijectively portable definition is unchanged up to the same renaming,
-- therefore definitions are stable and reusable across equivalent models.
-
-In rstool’s correctness model this property is not optional for the formal part:
-
-- all formal definitions are required to be **bijectively portable**,
-- expression checking assumes bijective portability for every referenced identifier.
-
-Because of this, membership checks against base sets/grades become redundant in correct expressions: the type discipline plus portability already guarantee the relevant “belonging” constraints.
-
-## Analysis: how to review a schema as a system
-
-### Thesaurus health
-
-- **Coverage**: do core domain nouns/roles appear as constituents (`N#`, `X#`, `S#`, `D#`)?
-- **Non-synonymy**: if two terms are interchangeable in all axioms/definitions, collapse or differentiate them.
-- **Naming stability**: avoid renaming “public” terms frequently; prefer adding refined terms and marking old ones as deprecated in text (if your workflow supports that).
-
-### Term graph health (dependencies)
-
-- Prefer a **layered graph**: bases/constants → core structures → derived projections/components → higher-level derived concepts → axioms/statements.
-
-### Axiom health
-
-- Every axiom should have a clear intent: uniqueness, totality, disjointness, ordering, invariance, domain/range constraints, etc.
-- Prefer a small set of high-leverage axioms that unlock safe derivations, rather than many weak axioms with overlapping meaning.
-- If axioms regularly fail in model evaluation, either the interpretation data violates the intended semantics or the semantics are wrong — in both cases the schema needs revision.
-
-## Practical workflow for agents (recommended)
-
-1. **Start with a vocabulary list** (domain nouns, roles, relations) → introduce `N#` for stable names when formalisation is not ready yet.
-2. **Introduce bases/constants** (`X#`, `C#`) early with conventions.
-3. **Introduce core structures** (`S#`) with typifications + conventions; immediately add the most important component terms (`Pr*`, `red`-based terms).
-4. **Add derived concepts** (`D#`, `F#`, `P#`) incrementally; keep definitions short by using named components.
-5. **Add axioms** (`A#`) that:
-   - encode intended semantics of structures,
-   - justify `debool`/functional choices, and
-   - restrict domains/ranges so derived concepts remain meaningful.
-6. Run analysis on scratch expressions before committing, and keep text definitions closed-world (schema terms only).
+1. Собери словарь предметной области.
+2. Добавь `X#` и `C#` с конвенциями.
+3. Добавь ключевые `S#` с типизацией и конвенцией.
+4. Назови важные компоненты через `D#`: `Pr*`, `pr*`, `red`.
+5. Добавляй выводимые `D#`, `F#`, `P#` маленькими шагами.
+6. Добавь `A#` и `T#` по необходимости.
+7. Перед upsert проверяй `analyzeExpression`.
+8. Для сомнительной семантики собери маленькую КМ и вычисли ожидаемые значения.

package/docs/CONSTITUENTA.md

@@ -1,78 +1,53 @@
-# Constituenta reference
+# Конституенты
 
-Use this when upserting constituents via `addOrUpdateConstituenta`.
+Читай перед `addOrUpdateConstituenta`.
 
-## `ConstituentaDraft` fields
+## Поля черновика
 
-| Field              | Required           | Description                                                    |
-| ------------------ | ------------------ | -------------------------------------------------------------- |
-| `id`               | yes                | Stable integer id within the session                           |
-| `alias`            | yes                | Display alias (`X1`, `D5`, `F2`) — must match `cstType` prefix |
-| `cstType`          | yes                | One of `CstType` values (see table below)                      |
-| `definitionFormal` | yes (may be empty) | RS expression. Empty for `basic` / `constant`                  |
-| `term`             | optional           | Natural-language term name                                     |
-| `definitionText`   | optional           | Natural-language definition / interpretation                   |
-| `convention`       | optional           | Convention text for undefined concepts                         |
+- `id` — стабильный id внутри сессии.
+- `alias` — имя вида `X1`, `D5`, `F2`; префикс должен совпадать с `cstType`.
+- `cstType` — роль конституенты.
+- `definitionFormal` — формальное определение; для `basic` и `constant` строго `''`.
+- `term` — естественно-языковое имя.
+- `definitionText` — текстовая интерпретация формулы.
+- `convention` — соглашение для неопределяемого понятия.
 
-Omitted text fields default to `''` in stored state.
+Пропущенные текстовые поля сохраняются как `''`. Пиши `term`, `definitionText`, `convention` на одном языке: в языке схемы или, для новой схемы, в языке запроса.
 
-## Language of text fields
+## `cstType`
 
-The natural-language fields `term`, `definitionText`, and `convention` should be written in **one consistent language**:
+- `nominal` / `N#` — номиноид. В родоструктурной экспликации не используется.
+- `basic` / `X#` — базисное множество; формула пустая.
+- `constant` / `C#` — константное множество; формула пустая.
+- `structure` / `S#` — родовая структура; формула задает типизацию.
+- `term` / `D#` — терм; формула задает вычисляемое значение.
+- `function` / `F#` — терм-функция.
+- `predicate` / `P#` — предикат-функция.
+- `axiom` / `A#` — аксиома; нужна типизация `Logic`.
+- `statement` / `T#` — высказывание; нужна типизация `Logic`.
 
-- When editing/extending an existing schema, keep the **same language** that is already used in the schema’s text fields.
-- When creating a new schema from scratch, use the **language of the user’s request**.
+`basic`, `constant`, `structure` можно интерпретировать через `setConstituentaValue`. `term`, `axiom`, `statement` вычисляются и напрямую не задаются.
 
-## `cstType` table
+## `S#` и `D#`
 
-| `cstType` (value) | Prefix | Formal definition         | Notes                                                                                             |
-| ----------------- | ------ | ------------------------- | ------------------------------------------------------------------------------------------------- |
-| `basic` (`X`)     | `X#`   | **must be empty**         | Base set; non-empty formal → `definitionNotAllowed`                                               |
-| `constant` (`C`)  | `C#`   | **must be empty**         | Constant set; same rule                                                                           |
-| `nominal` (`N`)   | `N#`   | allowed                   | Free vocabulary item, no semantic constraint                                                      |
-| `structure` (`S`) | `S#`   | allowed                   | **Base** structured concept; `definitionFormal` is its **typification** (grade), not a definition |
-| `term` (`D`)      | `D#`   | allowed                   | **Derived** concept; `definitionFormal` is its **definition** (value computed in the model)       |
-| `axiom` (`A`)     | `A#`   | allowed (must be `Logic`) | Logical statement asserting a requirement                                                         |
-| `statement` (`T`) | `T#`   | allowed (must be `Logic`) | Logical assertion about the model                                                                 |
-| `function` (`F`)  | `F#`   | allowed (parameterised)   | Term-function                                                                                     |
-| `predicate` (`P`) | `P#`   | allowed (parameterised)   | Predicate-function                                                                                |
+`S#` — неопределяемая родовая структура. `definitionFormal: 'ℬ(X1×X1)'` описывает ступень элемента: множество пар над `X1`.
 
-### Interpretability and inferrability
+`D#` — терм. `definitionFormal: 'X1×X1'` строит полный декартов продукт.
 
-- **Interpretable** (a value can be assigned via `setConstituentaValue`): `basic`, `constant`, `structure`.
-- **Inferrable** (computed from definitions, never set directly): `term`, `axiom`, `statement`. Assigning to an inferrable raises an error.
+Для бинарного отношения обычно нужно:
 
-## Structure (`S#`) vs term (`D#`)
+1. `X1` — базисное множество.
+2. `S1` — `definitionFormal: 'ℬ(X1×X1)'`; конвенция объясняет порядок пары.
+3. `D#` — проекции и фильтры: `Pr1(S1)`, `Pr2(S1)`, `Fi1[D1](S1)`.
 
-Do not treat `structure` and `term` as interchangeable because both may contain `×`, `ℬ`, or projections.
+Пример: `examples/build-kinship-rsform.ts`.
 
-|                    | `structure` (`S#`)                                                                          | `term` (`D#`)                                                                                        |
-| ------------------ | ------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------- |
-| `definitionFormal` | **Typification** — which grade the elements have (e.g. `ℬ(X1×X1)` = set of pairs over `X1`) | **Definition** — how to obtain the concept (e.g. `Pr1(S1)` = first projection of relation `S1`)      |
-| Introduction       | `convention` (+ optional axioms); interpretation from the subject domain                    | Formal expression only; interpretation is **evaluated**                                              |
-| `X1×X1` in context | Inside a grade: **one** pair type `(X1, X1)`                                                | As the whole body: **Cartesian product** `X1 × X1` (all pairs) — rarely what you want for a relation |
+## Валидация
 
-**Typical pattern (relation over a base set):**
+1. Префикс `alias` соответствует `cstType`.
+2. У `basic` и `constant` пустая формула, иначе `definitionNotAllowed` (`0x8862`).
+3. Все глобальные ссылки уже есть в сессии.
+4. `axiom` и `statement` имеют типизацию `Logic`, иначе `expectedLogic`.
+5. Выводимая конституента с пустой формулой дает `cstEmptyDerived`.
 
-1. `X1` — base set, empty formal, `convention` names the domain elements.
-2. `S1` — `definitionFormal: 'ℬ(X1×X1)'`, `convention` explains pair order (e.g. parent, child).
-3. `D1` — `definitionFormal: 'Pr1(S1)'` (or filters / term-functions), `definitionText` explains the derived set.
-
-Worked example: `examples/build-kinship-rsform.ts`.
-
-## Validation rules
-
-1. **Prefix ↔ `cstType`**: `alias` letter must match the type prefix.
-2. **Empty formal for undefined concepts**: `basic` and `constant` must have `definitionFormal === ''`. Any non-empty value triggers `definitionNotAllowed` (`0x8862`).
-3. **Dependency declaration order**: every global identifier referenced in `definitionFormal` must correspond to an already-upserted constituent in the session.
-4. **Logical-only definitions**: `axiom` and `statement` definitions must typecheck to `Logic`; otherwise `expectedLogic`.
-5. **Empty derived expression**: a derived constituent with empty `definitionFormal` triggers `cstEmptyDerived`.
-
-## Recommended upsert order
-
-1. All `basic` (`X#`) and `constant` (`C#`) constituents (empty formal).
-2. Core `structure` (`S#`) and crucial concepts.
-3. Topological order of derived concepts: every dependency upserted before its dependent.
-4. Axioms and statements after the constituents they reference.
-
-Use `analyzeExpression` on a scratch expression before upsert; use `addOrUpdateConstituenta` only when the expression typechecks. Read `result.diagnostics` for actionable error info and patch by `from`/`to` ranges.
+Цикл: `analyzeExpression` на черновике → исправить `diagnostics[].from/to` → `addOrUpdateConstituenta`.

package/docs/DIAGNOSTICS.md

@@ -1,130 +1,85 @@
-# Diagnostics reference
-
-Use this when an `analyzeExpression` / `addOrUpdateConstituenta` call returns errors in `result.diagnostics`.
-
-## How to read a diagnostic
-
-Each `DiagnosticRecord` carries:
-
-- `code` — numeric `RSErrorCode` (see table). The high nibble identifies the class (`0x82xx` lexer, `0x84xx` parser, `0x88xx` semantic, `0x81xx` runtime, `0x28xx` warnings).
-- `params` — substitution arguments for the message (identifier names, sets, etc.).
-- `from`, `to` — character positions in the _expression text_ that should be patched. Always edit `definitionFormal` by range.
-- `constituentId` — present in session diagnostics from `listDiagnostics`.
-
-Resolve `code` from **`@rsconcept/domain`** (installed: `node_modules/@rsconcept/domain/src/rslang/error.ts`):
-
-- **`RSErrorCode`** — reverse-lookup the numeric value to its symbol name (`missingParenthesis`, `globalNotTyped`, …). The identifier is the canonical error kind; inline comments on each member document the hex id.
-- **`getRSErrorPrefix(code)`** — short label with class + hex (`P8406`, `S8803`, …).
-- **`params`** — substitution arguments from the reporter (see `*.test.ts` cases in `domain/src/rslang/` for examples per code).
-- **Tables below** — typical causes and agent fixes when patching `definitionFormal`.
-
-## Class table
-
-| Mask            | Class                | Behaviour                                                                      |
-| --------------- | -------------------- | ------------------------------------------------------------------------------ |
-| `0x8400` family | Parser               | Lexical / syntactic problems; expression cannot be analysed further            |
-| `0x8800` family | Semantic             | Definition-level issues (types, scopes, structure)                             |
-| `0x8100` family | Runtime / evaluation | Raised during `evaluateExpression` / `evaluateConstituenta`                    |
-| `0x2800` family | Warning              | Not critical; expression still valid                                           |
-| `0x88Cx`        | Schema-level         | Rules enforced by the schema layer (`cstEmptyDerived`, `definitionNotAllowed`) |
-
-`isCritical(code)` returns `false` only for `localDoubleDeclare` and `localNotUsed`.
-
-## High-priority codes
-
-### Parser
-
-| Code     | Symbol                 | Typical cause                        | Agent fix                       |
-| -------- | ---------------------- | ------------------------------------ | ------------------------------- |
-| `0x8400` | `unknownSyntax`        | Stray token / typo                   | Re-tokenise around `from`–`to`  |
-| `0x8406` | `missingParenthesis`   | Unmatched `(` `)`                    | Insert matching paren near `to` |
-| `0x8407` | `missingCurlyBrace`    | Unmatched `{` `}`                    | Insert matching brace           |
-| `0x8408` | `missingSquareBracket` | Unmatched `[` `]`                    | Insert matching bracket         |
-| `0x8409` | `bracketMismatch`      | Mixed bracket types                  | Replace one bracket to match    |
-| `0x840A` | `doubleParenthesis`    | `(( ... ))` redundancy               | Remove one pair                 |
-| `0x840B` | `missingOpenBracket`   | Closing bracket without opener       | Insert opening bracket earlier  |
-| `0x8415` | `expectedLocal`        | Quantifier or filter expects a local | Provide a lowercase variable    |
-| `0x8416` | `expectedType`         | Missing typification annotation      | Add explicit grade              |
-
-### Semantic — locals and scopes
-
-| Code     | Symbol               | Typical cause                    | Agent fix                       |
-| -------- | -------------------- | -------------------------------- | ------------------------------- |
-| `0x8801` | `localUndeclared`    | Variable used before declaration | Bind via quantifier / parameter |
-| `0x8802` | `localShadowing`     | Local redeclared in inner scope  | Rename inner variable           |
-| `0x8815` | `localOutOfScope`    | Local escapes its binder         | Move usage inside the binder    |
-| `0x2801` | `localDoubleDeclare` | Same local declared twice        | Warning; rename                 |
-| `0x2802` | `localNotUsed`       | Declared local never referenced  | Warning; remove or use          |
-
-### Semantic — types
-
-| Code     | Symbol                          | Typical cause                                          | Agent fix                                           |
-| -------- | ------------------------------- | ------------------------------------------------------ | --------------------------------------------------- |
-| `0x8803` | `typesNotEqual`                 | Operands have different typifications                  | Convert / project to matching grade                 |
-| `0x8804` | `globalNotTyped`                | Referenced global has no typification                  | Ensure dependency is upserted and typechecked first |
-| `0x8805` | `invalidDecart`                 | Cartesian product on non-set operand                   | Wrap operand in `ℬ(...)` if appropriate             |
-| `0x8806` | `invalidBoolean`                | `ℬ(...)` applied to a non-set                          | Use a set-grade operand                             |
-| `0x8807` | `invalidTypeOperation`          | Operator not defined for these types                   | Re-check the typification table                     |
-| `0x8808` | `invalidCard`                   | `card(...)` on a non-set                               | Use a set operand                                   |
-| `0x8809` | `invalidDebool`                 | `debool(...)` on non-singleton                         | Ensure exactly one element first                    |
-| `0x880B` | `globalFuncWithoutArgs`         | Calling a function without `[]` args                   | Provide arguments                                   |
-| `0x8810` | `invalidReduce`                 | `red(...)` on something not `ℬ(ℬ(...))`                | Wrap in extra `ℬ` or change source                  |
-| `0x8811` | `invalidProjectionTuple`        | `pr_i((a,b))` with out-of-range index                  | Use valid index                                     |
-| `0x8812` | `invalidProjectionSet`          | `Pr_i(S)` on non-tuple set                             | Use a tuple-set source                              |
-| `0x8813` | `invalidEnumeration`            | `{a, b}` with incompatible element types               | Match element typifications                         |
-| `0x8814` | `invalidCortegeDeclare`         | Tuple declaration with mismatched arity                | Match declaration to use                            |
-| `0x8816` | `invalidElementPredicate`       | `ξ ∈ S` typification mismatch                          | Match `ξ`'s grade to elements of `S`                |
-| `0x8817` | `invalidEmptySetUsage`          | `∅` in a position that needs a concrete element        | Provide explicit typified operand                   |
-| `0x8818` | `invalidArgsArity`              | Wrong number of arguments to function                  | Match function declaration                          |
-| `0x8819` | `invalidArgumentType`           | Argument typification mismatch                         | Adjust caller or function signature                 |
-| `0x881C` | `globalStructure`               | Wrong structural shape of referenced global            | Re-check `structure` constituent shape              |
-| `0x8821` | `radicalUsage`                  | Radical used outside parameter domain                  | Move usage into parameter declarations              |
-| `0x8822` | `invalidFilterArgumentType`     | `Fi[D](S)` parameter does not match index typification | Match `D` to projected grade                        |
-| `0x8823` | `invalidFilterArity`            | Filter parameter count ≠ multi-index length            | Align lengths                                       |
-| `0x8824` | `arithmeticNotSupported`        | Arithmetic operator outside integer context            | Use integer expressions                             |
-| `0x8825` | `typesNotCompatible`            | Generic type incompatibility                           | Re-examine surrounding context                      |
-| `0x8826` | `orderingNotSupported`          | `<`, `≤` etc. used outside integer                     | Ensure operands are integers                        |
-| `0x8827` | `expectedLogic`                 | Definition where `Logic` is required                   | Wrap in logical expression or change `cstType`      |
-| `0x8828` | `expectedSetexpr`               | Definition where STE required                          | Convert from logic to set expression                |
-| `0x8829` | `invalidArgumentCortegeDeclare` | Tuple parameter declaration mismatch                   | Match tuple arity in declaration                    |
-
-### Schema / cstType validation
-
-| Code     | Symbol                 | Trigger                                                | Fix                                                    |
-| -------- | ---------------------- | ------------------------------------------------------ | ------------------------------------------------------ |
-| `0x8861` | `cstEmptyDerived`      | Derived constituent with empty `definitionFormal`      | Provide a definition                                   |
-| `0x8862` | `definitionNotAllowed` | `basic`/`constant` with non-empty formal               | Clear the formal                                       |
-| `0x8840` | `globalNoValue`        | Reference to global without a model value              | Set value via `setConstituentaValue` before evaluating |
-| `0x8841` | `invalidPropertyUsage` | Property-only constituent used where value is required | Use a different operand                                |
-
-### Runtime (evaluation)
-
-| Code     | Symbol                    | Cause                                    |
-| -------- | ------------------------- | ---------------------------------------- |
-| `0x8100` | `calcUnknownError`        | Unspecified evaluation failure           |
-| `0x8101` | `setOverflow`             | Intermediate set too large               |
-| `0x8102` | `booleanBaseLimit`        | `ℬ(X)` overflow at runtime               |
-| `0x8103` | `calcGlobalMissing`       | Referenced global has no current value   |
-| `0x8104` | `iterationsLimit`         | Iterative computation exceeded limit     |
-| `0x8105` | `calcInvalidDebool`       | `debool` on multi-element set at runtime |
-| `0x8106` | `iterateInfinity`         | Iteration over an infinite set           |
-| `0x8107` | `calculationNotSupported` | Construct cannot be evaluated            |
-
-## Common agent mistakes
-
-- **Setting a value on a derived constituent**: derived `term`, `axiom`, `statement` are inferrable. Use `evaluateConstituenta` / `recalculateModel`. Setting them throws `Constituent <alias> is inferrable and cannot be set directly`.
-- **Forgetting empty formal on `basic` / `constant`**: results in `definitionNotAllowed`. Pass `definitionFormal: ''`.
-- **Out-of-order dependencies**: referencing `D2` before upserting it raises `localUndeclared` or `globalNotTyped`. Always topologically sort.
-- **Wrong cstType for the role**: `axiom`/`statement` whose definition is not `Logic` raises `expectedLogic`. A `term` whose body is logical raises `expectedSetexpr`.
-- **Negative literals**: `-5` does not parse. Use `0 - 5`.
-- **Radicals in result expressions**: `[α∈R1] (α, R1)` raises `radicalUsage`. Use radicals only in parameter domains.
-- **Evaluating before bindings are set**: `evaluateExpression` referencing `X1` without a `setConstituentaValue(..., target: <X1.id>)` raises `calcGlobalMissing` (`0x8103`).
-
-## Diagnostics loop
-
-1. Run `analyzeExpression` on a scratch.
-2. If `analysis.success === false`, iterate `analysis.diagnostics`.
-3. For each diagnostic: read `code`, `from`, `to`, and `params`. Look up `code` in `RSErrorCode` (`error.ts`) and use `getRSErrorPrefix` if you need a display id.
-4. Patch `definitionFormal` based on the range — never blindly retry without changing the input.
-5. Re-send. Repeat until success.
-6. Only then call `addOrUpdateConstituenta` to commit the constituent into the session.
+# Диагностика
+
+Читай, когда `analyzeExpression` или `addOrUpdateConstituenta` вернули `diagnostics`.
+
+## `DiagnosticRecord`
+
+- `code` — числовой `RSErrorCode`.
+- `params` — аргументы сообщения.
+- `from`, `to` — диапазон в `definitionFormal`.
+- `constituentId` — есть в диагностике сессии из `listDiagnostics`.
+
+Источник истины: `@rsconcept/domain/src/rslang/error.ts`. Для короткого вида UI/логов используй `getRSErrorPrefix(code)`.
+
+## Классы кодов
+
+- `0x8400` — parser: синтаксис и скобки.
+- `0x8800` — semantic: типизации, области видимости, структура.
+- `0x8100` — runtime/evaluation: вычисление модели.
+- `0x2800` — warning: обычно не блокирует выражение.
+- `0x88Cx` — правила схемы и `cstType`.
+
+## Частые parser-коды
+
+- `0x8400 unknownSyntax` — неопределенная синтаксическая ошибка.
+- `0x8406 missingParenthesis` — не закрыты `(` `)`.
+- `0x8407 missingCurlyBrace` — не закрыты `{` `}`.
+- `0x8408 missingSquareBracket` — не закрыты `[` `]`.
+- `0x8409 bracketMismatch` — смешаны типы скобок.
+- `0x840A doubleParenthesis` — лишняя пара скобок.
+- `0x840B missingOpenBracket` — закрывающая скобка без открывающей.
+- `0x8415 expectedLocal` — нужна локальная переменная.
+- `0x8416 expectedType` — нужна явная ступень.
+
+## Локальные переменные
+
+- `0x8801 localUndeclared` — свяжи переменную квантором или параметром.
+- `0x8802 localShadowing` — переименуй внутреннюю переменную.
+- `0x8815 localOutOfScope` — перенеси использование внутрь области видимости.
+- `0x2801 localDoubleDeclare` — warning; объявление задублировано.
+- `0x2802 localNotUsed` — warning; переменная не используется.
+
+## Типизации и структура
+
+- `0x8803 typesNotEqual` / `0x8825 typesNotCompatible` — операнды несовместимы.
+- `0x8804 globalNotTyped` — сначала добавь и проанализируй поставщика.
+- `0x8805 invalidDecart`, `0x8806 invalidBoolean`, `0x8810 invalidReduce` — неверная ступень для операции.
+- `0x8808 invalidCard` — `card(...)` не над множеством.
+- `0x8809 invalidDebool` — нет гарантии синглетона.
+- `0x880B globalFuncWithoutArgs` — функция вызвана без `[]`.
+- `0x8811 invalidProjectionTuple`, `0x8812 invalidProjectionSet` — неверная проекция.
+- `0x8813 invalidEnumeration` — элементы перечисления разных ступеней.
+- `0x8816 invalidElementPredicate` — `ξ ∈ S` с несовместимыми ступенями.
+- `0x8818 invalidArgsArity`, `0x8819 invalidArgumentType` — неверный вызов функции.
+- `0x8821 radicalUsage` — радикал вне домена параметра.
+- `0x8822 invalidFilterArgumentType`, `0x8823 invalidFilterArity` — неверный `Fi`.
+- `0x8824 arithmeticNotSupported`, `0x8826 orderingNotSupported` — нужна ступень `Z`.
+- `0x8827 expectedLogic` — нужна логическая формула.
+- `0x8828 expectedSetexpr` — нужно теоретико-множественное выражение, а не логика.
+
+## Схема и вычисление
+
+- `0x8861 cstEmptyDerived` — у выводимой конституенты пустая формула.
+- `0x8862 definitionNotAllowed` — у `basic`/`constant` непустая формула.
+- `0x8840 globalNoValue` / `0x8103 calcGlobalMissing` — нет значения в модели.
+- `0x8841 invalidPropertyUsage` — `Property` использован как вычислимое значение.
+- `0x8101 setOverflow`, `0x8102 booleanBaseLimit`, `0x8104 iterationsLimit` — выражение слишком дорого вычислять.
+- `0x8105 calcInvalidDebool` — `debool` получил не синглетон.
+- `0x8106 iterateInfinity`, `0x8107 calculationNotSupported` — конструкция не исполнима в конечной модели.
+
+## Типичные ошибки агентов
+
+- Задавать значение `term`/`axiom`/`statement` напрямую.
+- Писать формулу у `basic` или `constant`.
+- Добавлять потребителя раньше поставщика.
+- Давать логическое тело `term` или нелогическое тело `axiom`/`statement`.
+- Использовать `R#` в теле результата.
+- Вычислять производные понятия до привязки данных для базовых.
+
+## Цикл исправления
+
+1. Запусти `analyzeExpression`.
+2. Прочитай `code`, `from`, `to`, `params`.
+3. Исправь именно диапазон в `definitionFormal`.
+4. Не повторяй вызов без изменения ввода.
+5. После успеха вызывай `addOrUpdateConstituenta`.