@rsconcept/rstool 0.2.0 → 0.3.0

package/docs/CONCEPTUAL-SCHEMA.md

@@ -0,0 +1,78 @@
+# Концептуальная схема
+
+Справка про проектирование КС как системы определений. Для механики см. `CONSTITUENTA.md`, `SYNTAX.md`, `TYPIFICATION.md`.
+
+## Цель схемы
+
+КС ценна не числом конституент, а различениями, которые она вводит.
+
+- Добавляй понятие, если оно дает новый критерий, роль, отношение, инвариант или правило.
+- Если пользователь постоянно переформулирует одно различие, введи отдельную конституенту.
+
+## Текстовые поля
+
+`term`, `definitionText`, `convention` держи в языке схемы и в ее словаре.
+
+- `term` — короткое имя понятия.
+- `definitionText` — текстовая интерпретация формального определения.
+- `convention` — соглашение для неопределяемого понятия.
+
+Перед записью `definitionText` проверь существительные: важный предметный термин должен быть введен как `N#`, `X#`, `C#`, `S#` или `D#`.
+
+## Номиноиды и атрибутирование
+
+`N#` — номиноид: именованная сущность для словаря схемы. Он помогает фиксировать термин до точной родоструктурной формализации.
+
+Атрибутирование связывает номиноид с другими конституентами через атрибуты. Это отдельная атрибутивная экспликация, не замена `S#`, `D#`, `A#` в родоструктурной экспликации.
+
+Правило для `rstool`: не смешивай атрибутивную и родоструктурную экспликацию. Используй `N#` как словарную опору, но не превращай атрибуты в RS-формулы и не добавляй атрибутивные связи, если пользователь явно не просит совместить эти способы.
+
+## Родовые структуры
+
+`S#` — родовая структура. Ее `definitionFormal` задает типизацию, а смысл задают конвенция, интерпретация и аксиомы.
+
+Паттерн для отношения:
+
+1. `X1` — базисное множество.
+2. `S1: ℬ(X1×X1)` — отношение; порядок пары описан в `convention`.
+3. `D# := Pr1(S1)`, `D# := Pr2(S1)` — именованные компоненты.
+4. Сложные термы строятся поверх этих `D#`.
+
+Если повторяется цепочка вроде `Pr2(Fi1[D](S7))`, введи промежуточный терм или уточни конвенцию/аксиому для `S7`.
+
+## Аксиомы
+
+`A#` — логическое требование к модели. Используй аксиомы, чтобы:
+
+- фиксировать смысл `S#`;
+- задавать уникальность, тотальность, непересечение, порядок, область и диапазон;
+- оправдывать `debool(...)`: внутреннее множество должно быть гарантированно одноэлементным.
+
+## Проверка на маленькой модели
+
+Когда семантика определения не очевидна, используй концептуальную модель как тестовый стенд: задай минимальные значения для `X#`, `C#`, `S#` и вычисли проверяемые `D#`, `F#`, `P#`, `A#`.
+
+Это особенно полезно для проекций, фильтров, `red`, `bool` / `debool` и аксиом. Если проверка важна для будущих изменений, перенеси ее в скрипт-тест: собрать маленькую сессию, задать значения неопределяемых конституент, вычислить целевые конституенты и проверить не только `success`, но и ожидаемое `value`.
+
+Подробный цикл: `MODEL-TESTING.md`.
+
+## Быстрое ревью
+
+- Атрибутивная экспликация не смешана с родоструктурной без явного запроса пользователя.
+- Не добавляй проверки принадлежности к собственной типизации: если `x` уже объявлен в `X1`, `x ∈ X1` избыточно.
+- Покрыты главные предметные сущности, роли, отношения и утверждения.
+- Слои идут так: `X#`/`C#` → `S#` → простые `D#` → сложные `D#`/`F#`/`P#` → `A#`/`T#`.
+- У каждой аксиомы понятная цель.
+- Частые падения аксиом в модели указывают на ошибку данных или семантики схемы.
+- Сомнительные выражения проверены на маленькой КМ, если есть показательные тестовые данные.
+
+## Рабочий порядок
+
+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,71 +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` на одном языке: в языке схемы или, для новой схемы, в языке запроса.
 
-## `cstType` table
+## `cstType`
 
-| `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                                                                                |
+- `nominal` / `N#` — номиноид. В родоструктурной экспликации не используется.
+- `basic` / `X#` — базисное множество; формула пустая.
+- `constant` / `C#` — константное множество; формула пустая.
+- `structure` / `S#` — родовая структура; формула задает типизацию.
+- `term` / `D#` — терм; формула задает вычисляемое значение.
+- `function` / `F#` — терм-функция.
+- `predicate` / `P#` — предикат-функция.
+- `axiom` / `A#` — аксиома; нужна типизация `Logic`.
+- `statement` / `T#` — высказывание; нужна типизация `Logic`.
 
-### Interpretability and inferrability
+`basic`, `constant`, `structure` можно интерпретировать через `setConstituentaValue`. `term`, `axiom`, `statement` вычисляются и напрямую не задаются.
 
-- **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.
+## `S#` и `D#`
 
-## Structure (`S#`) vs term (`D#`)
+`S#` — неопределяемая родовая структура. `definitionFormal: 'ℬ(X1×X1)'` описывает ступень элемента: множество пар над `X1`.
 
-Do not treat `structure` and `term` as interchangeable because both may contain `×`, `ℬ`, or projections.
+`D#` — терм. `definitionFormal: 'X1×X1'` строит полный декартов продукт.
 
-|                    | `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. `X1` — базисное множество.
+2. `S1` — `definitionFormal: 'ℬ(X1×X1)'`; конвенция объясняет порядок пары.
+3. `D#` — проекции и фильтры: `Pr1(S1)`, `Pr2(S1)`, `Fi1[D1](S1)`.
 
-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.
+Пример: `examples/build-kinship-rsform.ts`.
 
-Worked example: `examples/build-kinship-rsform.ts`.
+## Валидация
 
-## Validation rules
+1. Префикс `alias` соответствует `cstType`.
+2. У `basic` и `constant` пустая формула, иначе `definitionNotAllowed` (`0x8862`).
+3. Все глобальные ссылки уже есть в сессии.
+4. `axiom` и `statement` имеют типизацию `Logic`, иначе `expectedLogic`.
+5. Выводимая конституента с пустой формулой дает `cstEmptyDerived`.
 
-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`.

package/docs/DOMAIN.md

@@ -1,91 +1,68 @@
-# Domain reference
-
-Compact English distillation of the canonical Russian domain glossary (`CONTEXT.md`). Read this first if you are an agent unfamiliar with the Concept Portal vocabulary.
-
-## Core concepts
-
-- **Subject domain** — a sphere of human activity that requires coordination and communication.
-- **Conceptual schema (`КС`)** — a formal system of definitions for a subject domain, made of constituents.
-- **Conceptual model (`РСМодель`)** — a pairing of a conceptual schema with an interpretation in concrete data.
-- **Operations Synthesis Schema (`ОСС`)** — a graph of load and synthesis operations that drives schema construction and evolution.
-- **RS language (`родоструктурная экспликация`)** — the formal genus-structure language used to define concepts, relations and operations inside a schema.
-- **Typification** — the computable structural type of a constituent's formal definition; the formal constraint on admissible interpretations.
-- **Term graph** — a directed dependency graph over constituents; an edge means "constituent A appears in constituent B's definition".
-
-## Constituents
-
-A **constituent** is the atomic building block of a conceptual schema. Each constituent may carry a term, a convention, a typification, a formal definition, a textual interpretation, and a comment. By role, a constituent is either undefined, derived, or a statement.
-
-Constituent aliases follow a strict prefix scheme:
-
-| Alias prefix | Role | Notes |
-|-----|------|-------|
-| `N#` | Nominoid | Free vocabulary item, no formal definition |
-| `X#` | Base set | Undefined concept, set of distinguishable elements |
-| `C#` | Constant set | Undefined concept, set-theoretic constant with operations |
-| `S#` | Structured concept (**genus structure**) | Undefined concept; `definitionFormal` gives **typification**; meaning via `convention` / axioms |
-| `D#` | Term | Derived concept; `definitionFormal` is the **definition**; value computed in a model |
-| `F#` | Term-function | Parameterised derived concept yielding an STE |
-| `P#` | Predicate-function | Parameterised derived concept yielding a logical expression |
-| `A#` | Axiom | Logical statement asserting requirements |
-| `T#` | Statement | Logical assertion about the model |
-| `R#` | Radical | Template placeholder for arbitrary typification |
-
-**Undefined concepts** (`X#`, `C#`, `S#`) are introduced by conventions (and optional axioms). For `S#`, the formal field states **typification** (the grade of elements), not a defining construction. **Derived concepts** (`D#`, `F#`, `P#`, `A#`, `T#`) carry a formal **definition** and must follow declaration order — every referenced constituent must already exist; their model values are obtained by evaluation.
-
-**Structure vs term:** `S#` with `ℬ(X1×X1)` declares “elements are pairs over `X1`”; the actual pairs come from interpretation. `D#` with `X1×X1` as the whole expression denotes the **full Cartesian product** (all pairs), which is a computed set — use `S#` + projections when modeling a relation.
-
-A **crucial constituent** is marked as content-bearing for filtering / focus; it has no semantic effect on the formal calculus.
-
-## Statuses
-
-Each constituent has one of the following correctness statuses:
-
-| Status | Meaning |
-|--------|---------|
-| Unknown | Not yet validated |
-| OK | Validated as correct |
-| Error | Validation failed |
-| Property | Defines a non-computable set; only membership tests are admissible |
-| Incalculable | Cannot be evaluated directly (e.g. expected exponential blow-up) |
-
-## RSModel evaluation states
-
-In a conceptual model each item has one of the following evaluation statuses:
-
-| Status | Meaning |
-|--------|---------|
-| `NO_EVAL` (1) | Not evaluated (definition is not interpretable) |
-| `NOT_PROCESSED` (2) | Interpretation has not been computed yet |
-| `INVALID_DATA` (3) | Provided data is invalid |
-| `EVAL_FAIL` (4) | Evaluation raised an error |
-| `AXIOM_FALSE` (5) | Axiom evaluated to FALSE |
-| `EMPTY` (6) | Result is the empty set |
-| `HAS_DATA` (7) | Interpretation computed and non-empty |
-
-## Synthesis and OSS
-
-- **Load operation** attaches an existing schema to the OSS graph.
-- **Synthesis operation** combines operand schemas via an **identification table** (pairs of constituents to be treated as equivalent) and produces a result schema with **inherited constituents**.
-- **Cross-cutting changes** propagate edits from a **source constituent** to its **inherited constituents** through the OSS. Inherited constituents are not edited directly.
-- **Diamond synthesis** uses operand schemas with shared ancestors.
-- **Concept block** is a nominal grouping of schemas inside the OSS.
-
-## Relationships
-
-- A conceptual schema **contains** many constituents.
-- A conceptual model **interprets** exactly one schema at a given state.
-- An OSS **contains** load and synthesis operations.
-- A synthesis operation **consumes** one or more input schemas plus an identification table and **produces** a result schema with inherited constituents.
-- Cross-cutting changes **propagate** from a source constituent to its inherited descendants.
-- The term graph is **derived** from the formal definitions of constituents.
-
-## Dependency vocabulary
-
-- **Consumers** — constituents that mention this one in their definitions.
-- **Suppliers** — constituents this one mentions in its definition.
-- **Dependents** — direct and transitive consumers.
-- **Influencers** — direct and transitive suppliers.
-- **Generating expression** — a definition referencing a single external constituent with no added content.
-- **Base concept (for generation)** — the constituent on which a generating expression is built.
-- **Generated concept** — a constituent produced from a generating expression.
+# Доменная справка
+
+Термины, используемые в Concept Portal.
+
+## Основные термины
+
+- **Предметная область** — область, для которой строится система определений.
+- **Концептуальная схема (`КС`)** — система понятий, утверждений и связей между ними.
+- **Концептуальная модель (`КМ`)** — КС плюс интерпретация ее понятий на конечных данных.
+- **Операционная схема синтеза (`ОСС`)** — граф загрузок и синтезов КС.
+- **Родоструктурная экспликация (`RSLang`)** — формальный язык для понятий, отношений, операций и утверждений.
+- **Типизация / ступень** — структура значений выражения: элемент, целое, кортеж, множество, `Logic`.
+- **Граф термов** — зависимости: конституента ссылается на другую в формальном определении.
+
+## Конституенты
+
+**Конституента** — часть КС. Главное для агента: `alias`, `cstType`, `definitionFormal`, `term`, `definitionText`, `convention`. `comment` — комментарий и пояснения разработчика схемы, полезно для контекста.
+
+- `N#` — **номиноид**: словарная сущность. В родоструктурной экспликации не используется.
+- `X#` — **базисное множество**: неопределяемое понятие, формула пустая.
+- `C#` — **константное множество**: неопределяемое множество для арифметики и порядка, формула пустая.
+- `S#` — **родовая структура**: неопределяемое структурное понятие; формула задает типизацию.
+- `D#` — **терм**: определяемое понятие; формула вычисляет значение.
+- `F#` — **терм-функция**: параметризованный терм.
+- `P#` — **предикат-функция**: параметризованное логическое выражение.
+- `A#` — **аксиома**: логическое требование к модели.
+- `T#` — **высказывание**: логическое утверждение о модели.
+- `R#` — **радикал**: шаблонная ступень в параметрах.
+
+Правило: `X#`, `C#`, `S#` задаются конвенцией и интерпретацией; `D#`, `F#`, `P#`, `A#`, `T#` выводятся по формуле. Поставщики должны идти раньше потребителей.
+
+Не путай `S#` и `D#`: `S1: ℬ(X1×X1)` — интерпретируемое отношение из пар; `D1 := X1×X1` — декартово произведение.
+
+## Статусы выражений
+
+- `Unknown` — не проверено.
+- `OK` — корректно.
+- `Error` — ошибка в определении.
+- `Property` — неразмерное: доступна только проверка принадлежности.
+- `Incalculable` — невычислимо напрямую.
+
+## Статусы вычисления в модели
+
+- `NO_EVAL` — нечего вычислять.
+- `NOT_PROCESSED` — вычисление не запускалось.
+- `INVALID_DATA` — неверная интерпретация.
+- `EVAL_FAIL` — ошибка вычисления.
+- `AXIOM_FALSE` — аксиома ложна.
+- `EMPTY` — результат пуст.
+- `HAS_DATA` — результат вычислен и непустой.
+
+## Зависимости
+
+- **Поставщики** — конституенты, на которые ссылается текущая.
+- **Потребители** — конституенты, которые ссылаются на текущую.
+- **Влияющие** — прямые и транзитивные поставщики.
+- **Зависимые** — прямые и транзитивные потребители.
+- **Основание** — конституента, из которой формально порождают новые термы.
+- **Порожденная конституента** — построена из основания без новой предметной договоренности.
+
+## ОСС и синтез
+
+- **Загрузка** добавляет внешнюю или собственную КС в ОСС.
+- **Синтез** строит новую КС из операций-аргументов через таблицу отождествлений.
+- **Наследованные конституенты** пришли из исходных схем; их определения обычно read-only.
+- **Сквозные изменения** идут от исходной конституенты к наследникам.
+- **Ромбовидный синтез** использует КС с общими предками; чаще требует ручного отождествления дублей.
+- **Концептуальный блок** — группа схем внутри предметной области.