npm - @rsconcept/rstool - Versions diffs - 0.5.0 → 0.5.2 - Mend

@rsconcept/rstool 0.5.0 → 0.5.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

package/README.md +16 -17
package/docs/CONCEPTUAL-SCHEMA.md +50 -68
package/docs/CONSTITUENTA.md +0 -2
package/docs/DIAGNOSTICS.md +1 -5
package/docs/DOMAIN.md +9 -1
package/docs/MODEL-TESTING.md +7 -10
package/docs/README.md +5 -3
package/package.json +1 -1
package/skills/README.md +3 -3
package/skills/rstool-helper/EXAMPLES.md +47 -117
package/skills/rstool-helper/GUIDE.md +107 -53
package/skills/rstool-helper/REFERENCE.md +108 -114
package/skills/rstool-helper/SKILL.md +5 -7

package/README.md CHANGED Viewed

@@ -4,7 +4,7 @@ Agent-facing library for **incremental RSForm construction**, **RSLang expressio
 ## Agent skill
-RS language + rstool workflows for agents: `skills/rstool-helper/` (`GUIDE.md`, `REFERENCE.md`, `EXAMPLES.md`) and `docs/` (`DOMAIN.md`, `CONCEPTUAL-SCHEMA.md` for relation-first KS design, `SYNTAX.md`, …). A **thin** entry skill is installed into the project’s agent skills folder; see [Installing the agent skill](#installing-the-agent-skill) below.
+RS language + rstool workflows for agents: `skills/rstool-helper/` (`GUIDE.md`, `REFERENCE.md`, `EXAMPLES.md`) and `docs/` (`DOMAIN.md`, `CONCEPTUAL-SCHEMA.md`, `SYNTAX.md`, …). A **thin** entry skill is installed into the project’s agent skills folder; see [Installing the agent skill](#installing-the-agent-skill) below.
 ## Install
@@ -12,7 +12,21 @@ RS language + rstool workflows for agents: `skills/rstool-helper/` (`GUIDE.md`,
 npm install @rsconcept/rstool
 ```
-`@rsconcept/domain` is a peer-of-dependency installed automatically. No Portal checkout is required.
+`@rsconcept/domain` is a peer-of-dependency installed automatically.
+## Installing the agent skill
+After `npm install @rsconcept/rstool`, **you do not copy files yourself**. Ask your agent, for example:
+> Install the rstool agent skill according to the package instructions.
+The agent should read and follow:
+`node_modules/@rsconcept/rstool/skills/INSTALL.md`
+That copies `skills/rstool-helper/SKILL.md` from the package into your host’s project skills directory (for example `.agents/skills/rstool-helper/SKILL.md`). Full guidance stays in the package (`skills/rstool-helper/GUIDE.md`, `docs/*.md`) and is read from `node_modules` when needed.
+Details: `skills/README.md`.
 ## Quick use (library)
@@ -50,7 +64,6 @@ await client.close();
 - Parse / syntax / semantic / type analysis for expressions.
 - In-memory modeling: set base bindings and structured values; evaluate expressions and constituents.
 - Deterministic diagnostics and export/import for reproducible agent workflows.
-- Library API + stdio JSON wrapper as the only supported transports (MCP adapter lives in [`@rsconcept/rstool-mcp`](../rstool-mcp/)).
 ## Publishing
@@ -128,20 +141,6 @@ The example:
 - sets a base binding and evaluates a term
 - fetches diagnostics
-## Installing the agent skill
-After `npm install @rsconcept/rstool`, **you do not copy files yourself**. Ask your agent, for example:
-> Install the rstool agent skill according to the package instructions.
-The agent should read and follow:
-`node_modules/@rsconcept/rstool/skills/INSTALL.md`
-That copies `skills/rstool-helper/SKILL.md` from the package into your host’s project skills directory (for example `.agents/skills/rstool-helper/SKILL.md`). Full guidance stays in the package (`skills/rstool-helper/GUIDE.md`, `docs/*.md`) and is read from `node_modules` when needed.
-Details: `skills/README.md`.
 ## License
 MIT

package/docs/CONCEPTUAL-SCHEMA.md CHANGED Viewed

@@ -1,57 +1,70 @@
 # Концептуальная схема
-Справка про проектирование КС как системы определений. Для механики см. `CONSTITUENTA.md`, `SYNTAX.md`, `TYPIFICATION.md`.
+Общие правила проектирования КС как системы определений. Механика: `CONSTITUENTA.md`, `SYNTAX.md`, `TYPIFICATION.md`.
-## Цель схемы
+## Цель
-КС ценна не числом конституент, а различениями, которые она вводит.
+КС ценна не числом конституент, а различениями.
-- Добавляй понятие, если оно дает новый критерий, роль, отношение, инвариант или правило.
-- Если пользователь постоянно переформулирует одно различие, введи отдельную конституенту.
+- Добавляй конституенту, если есть новый критерий выбора, роль, отношение, инвариант или правило.
+- Если одно различие постоянно переформулируется, выдели отдельную конституенту.
+- Не копируй источник дословно. Строй предметную модель.
+- Разработка КС ведется итеративно - вводи понятия, экспликцируй определения, формируй новый понтия, исследуй предметную область.
-Подробнее про структуру и поля конституент см. в [CONSTITUENTA.md](./CONSTITUENTA.md).
+## Предметная редукция
+Концептуализация решает задачу, не переписывает весь источник.
+- Рассматривай только нужный аспект определения.
+- Нужно опускать неважные отношения.
+- Можно не различать предметные термины, если задача не требует различения.
+- Если различение влияет на критерий, вывод или проверку, введи его явно.
 ## Номиноиды и атрибутирование
-`N#` — номиноид: именованная сущность для словаря схемы. Он помогает фиксировать термин до точной родоструктурной формализации.
+`N#` — номиноид: именованная сущность словаря до точной родоструктурной формализации.
+Атрибутирование связывает `N#` с конституентами отношением "быть атрибутом". Это отдельная атрибутивная экспликация, не замена `S#`, `D#`, `A#`.
+Правило: не смешивай атрибутивную и родоструктурную экспликацию без явного запроса.
-Атрибутирование связывает номиноид с другими конституентами через атрибуты. Это отдельная атрибутивная экспликация, не замена `S#`, `D#`, `A#` в родоструктурной экспликации.
+## Базовые понятия
-Правило для `rstool`: не смешивай атрибутивную и родоструктурную экспликацию если явно не указано пользователем.
+`X#`, `C#`, и `S#` — это базовые понятия, их нельзя строить одно из другого и включать друг в друга как элементы или подмножества.
+Если такое возникает — значит есть скрытое отношение, его нужно явно оформить отдельной производной конституентой.
+Если базисные множества пересекаются по интерпретации или набор констант показывает какой-то атрибут — отсутствует нужное отношение, его надо ввести.
 ## Родовые структуры
-`S#` — родовая структура. Ее `definitionFormal` задает типизацию, а смысл задают конвенция, интерпретация и аксиомы.
+`S#` — родовая структура. `definitionFormal` задает типизацию; смысл задают `convention`, интерпретация, аксиомы.
-Паттерн для отношения:
+Паттерн отношения:
 1. `X1` — базисное множество.
 2. `S1: ℬ(X1×X1)` — отношение; предметное пояснение в `convention`.
 3. `D# := Pr1(S1)`, `D# := Pr2(S1)` — именованные компоненты.
 4. Сложные термы строятся поверх этих `D#` и `S#`.
-Если повторяется цепочка вроде `Pr2(Fi1[D](S7))`, введи промежуточный терм или функцию `F#`.
+Повторяется `Pr2(Fi1[...](...))` или похожая цепочка -> введи промежуточный `D#` или `F#`.
-## Подход relation-first
+## Relation-first
-Используй при объединении нескольких исходных КС в одну предметную модель и при появлении длинных цепочек `∃d1…∃dn` в разных термах.
+Используй, когда нужно объединить несколько КС или в термах повторяются длинные цепочки `∃d1…∃dn`.
-### Семантическая лестница
+Строй слоями; слой ссылается только на предыдущие:
-Строй схему слоями; каждый следующий слой ссылается только на предыдущие:
+| Слой | Роль                  | Ввод                                                                           |
+| :--- | :-------------------- | :----------------------------------------------------------------------------- |
+| 1    | Базисные множества    | `X#`, `C#`; пустой `definitionFormal`, смысл в `convention` / `definitionText` |
+| 2    | Структуры             | `S#`; типизация `ℬ(…×…)`, конвенция кортежа                                    |
+| 3    | Инварианты            | `A#`; короткие ограничения, чаще через `card`                                  |
+| 4    | Доступ                | `F#`; локальный API вида `[α∈…] Pr*(Fi*[…](S#))`                               |
+| 5    | Центральное отношение | один `D#` или `S#`, задающий полную траекторию синтеза                         |
+| 6    | Витрина               | `D#` через `Pr*`, `Fi*`, `card`, `red`; узкие `F#` для аналитики               |
-| Слой | Роль                   | Что вводить                                                                                  |
-| :--- | :--------------------- | :------------------------------------------------------------------------------------------- |
-| 1    | Базис                  | `X#`, `C#` — пустой `definitionFormal`, смысл в `convention` / `definitionText` из источника |
-| 2    | Структуры              | `S#` — типизация `ℬ(…×…)` и конвенция на кортеж                                              |
-| 3    | Инварианты             | `A#` — короткие ограничения (см. ниже про `card`)                                            |
-| 4    | Параметрический доступ | `F#` — «локальный API»: `[α∈…] Pr*(Fi*[…](S#))`                                              |
-| 5    | Центральное отношение  | один `D#` (или `S#` с конвенцией), задающий полную траекторию синтеза                        |
-| 6    | Витрина понятий        | `D#` через `Pr*`, `Fi*`, `card`, `red`; узкие `F#` для аналитики                             |
+## Центральное отношение
-### Центральное отношение
-Когда в тексте описан единый сценарий, зафиксируй его **одним** объектом:
+Единый сценарий фиксируй одним объектом:
 ```text
 D13 ::= I{(α, ξ1, τ, ξ2, β1, β2, ρ, ξ3) |
@@ -59,58 +72,27 @@ D13 ::= I{(α, ξ1, τ, ξ2, β1, β2, ρ, ξ3) |
 }
 ```
-(Имена и арность — по предметной области; важна форма: кортеж + ограничения через уже введённые `F#` и `S#`.)
+Имена и арность зависят от предметной области. Важна форма: кортеж + ограничения через уже введенные `F#` и `S#`.
-Далее можешь дать название необходимым частям кортежа с помощью `D#` через `Pr#`
+Части кортежа называй через `D# := Pr#(D13)`.
-### Инварианты: `card` вместо длинных `∀`
+## Инварианты
-Для функциональности отношения удобно:
+Для функциональности отношения предпочитай `card`:
 ```text
 card(S1) = card(Pr1,2(S1))
 ```
-Эквивалентно идее `∀d1,d2∈S1 ...`
-Оставляй `∀`/`∃`, когда не получается заменить на теоретико-множественные и структурные конструкции.
+Это заменяет длинные `∀d1,d2∈S1 ...`. Оставляй `∀` / `∃`, только если выражение нельзя задать через множества, проекции, фильтры, `card`.
-### Проекции вместо повторных кванторов
+## Производные термы
-Если условие уже задано на `S#` или центральном `D#`, производный терм — это почти всегда:
+Если условие уже задано на `S#` или центральном `D#`, производный терм обычно:
 - `Prk(…)` / `Pri,j(…)`;
 - `Fi*k[{…}](…)`;
-- `D{ξ∈… | F[ξ] = …}` или `card(F[ξ]) = 1`.
-Перед тем как писать `D{x∈… | ∃d1∈… ∃d2∈…}`, проверь: нельзя ли выразить через `Pr` от уже введённого отношения.
-## Проверка на маленькой модели
-Когда семантика определения не очевидна, используй концептуальную модель как тестовый стенд: задай минимальные значения для `X#`, `C#`, `S#` и вычисли проверяемые `D#`, `F#`, `P#`, `A#`.
-Это особенно полезно для проекций, фильтров, `red`, `bool` / `debool` и аксиом. Если проверка важна для будущих изменений, перенеси ее в скрипт-тест: собрать маленькую сессию, задать значения неопределяемых конституент, вычислить целевые конституенты и проверить не только `success`, но и ожидаемое `value`.
-Подробный цикл: `MODEL-TESTING.md`.
-## Быстрое ревью
-- Атрибутивная экспликация не смешана с родоструктурной без явного запроса пользователя.
-- Не добавляй проверки принадлежности к собственной типизации: если `x` уже объявлен в `X1`, `x ∈ X1` избыточно.
-- Покрыты главные предметные сущности, роли, отношения и утверждения.
-- Повторяющиеся отборы вынесены в `F#`, а не размазаны по термам.
-- У каждой аксиомы понятна цель.
-- Частые падения аксиом в модели указывают на ошибку данных или семантики схемы.
-- Сомнительные выражения проверены на маленькой КМ, если есть показательные тестовые данные.
-## Рабочий порядок
+- `D{ξ∈… | F[ξ] = …}`;
+- `card(F[ξ]) = 1`.
-1. Собери словарь предметной области (базисы, ключевые отношения, сценарий синтеза).
-2. Добавь `X#` и `C#` с конвенциями из источника.
-3. Добавь базовые `S#` (трансформация, перевод, допускание, выбор, цели, субъекты).
-4. Добавь `A#` на структуры (`card`, покрытие `Pr1,2(S#)=…`, принадлежность выбора).
-5. Введи `F#` для типовых запросов.
-6. Производные понятия — `Pr*` / `Fi*` / `F#` от центрального `D#` и базовых `S#`.
-7. Узкие классификаторы (`для любой обстановки`, `для одного индивида`) — через `F#` и `card`/`=` с `X#`, не новые монолиты.
-8. Перед каждым upsert — `analyzeExpression`.
-9. Для сомнительной семантики — маленькая КМ (`MODEL-TESTING.md`).
+Перед `D{x∈… | ∃d1∈… ∃d2∈…}` проверь, нельзя ли взять `Pr` от уже введенного отношения.

package/docs/CONSTITUENTA.md CHANGED Viewed

@@ -51,5 +51,3 @@
 3. Все глобальные ссылки уже есть в сессии.
 4. `axiom` и `statement` имеют типизацию `Logic`, иначе `expectedLogic`.
 5. Выводимая конституента с пустой формулой дает `cstEmptyDerived`.
-Цикл: `analyzeExpression` на черновике → исправить `diagnostics[].from/to` → `addOrUpdateConstituenta`.

package/docs/DIAGNOSTICS.md CHANGED Viewed

@@ -78,8 +78,4 @@
 ## Цикл исправления
-1. Запусти `analyzeExpression`.
-2. Прочитай `code`, `from`, `to`, `params`.
-3. Исправь именно диапазон в `definitionFormal`.
-4. Не повторяй вызов без изменения ввода.
-5. После успеха вызывай `addOrUpdateConstituenta`.
+Пошаговый цикл — в `../skills/rstool-helper/GUIDE.md`, раздел «Цикл диагностик». Здесь — справочник кодов и типичных ошибок.

package/docs/DOMAIN.md CHANGED Viewed

@@ -12,13 +12,21 @@
 - **Типизация / ступень** — структура значений выражения: элемент, целое, кортеж, множество, `Logic`.
 - **Граф термов** — зависимости: конституента ссылается на другую в формальном определении.
+## Классификация понятий КС
+- **Базовое (неопределяемое) понятие** — конституента, вводимая конвенцией (и при необходимости аксиомами), а не формальным определением. В родоструктурной экспликации: `X#`, `C#`, `S#`. Смысл задают `convention`, интерпретация и аксиомы.
+- **Производное понятие** — конституента с формальным определением на RSLang: `D#`, `F#`, `P#` и связанные выводимые конструкции. Значение получают из определения при заданной интерпретации базовых понятий.
+- **Ядро КС** — базовые понятия, аксиомы и производные понятия, необходимые для их формулировки.
+- **Тело КС** — остальные конституенты схемы, не входящие в ядро.
+- **Интерпретация** — соотнесение понятий КС с сущностями предметной области. В концептуальной модели задаётся значениями неопределяемых конституент и вычислением производных.
 ## Конституенты
 **Конституента** — часть КС. Главное для агента: `alias`, `cstType`, `definitionFormal`, `term`, `definitionText`, `convention`. `comment` — комментарий и пояснения разработчика схемы, полезно для контекста.
 - `N#` — **номиноид**: словарная сущность. В родоструктурной экспликации не используется.
 - `X#` — **базисное множество**: неопределяемое понятие, формула пустая.
-- `C#` — **константное множество**: неопределяемое множество для арифметики и порядка, формула пустая.
+- `C#` — **константное множество**: неопределяемое понятие для арифметики и порядка, формула пустая.
 - `S#` — **родовая структура**: неопределяемое структурное понятие; формула задает типизацию.
 - `D#` — **терм**: определяемое понятие; формула вычисляет значение.
 - `F#` — **терм-функция**: параметризованный терм.

package/docs/MODEL-TESTING.md CHANGED Viewed

@@ -11,15 +11,6 @@
 Для простой проверки типизации сначала используй `analyzeExpression`. КМ нужна, когда вопрос зависит от интерпретации данных и вычисленного значения.
-## Минимальный цикл
-1. Создай отдельную `createSession` или изолированную копию текущей сессии.
-2. Добавь только нужные поставщики: `X#`, `C#`, `S#` и проверяемые `D#` / `F#` / `P#` / `A#`.
-3. Проверь формулы через `analyzeExpression` и `addOrUpdateConstituenta`.
-4. Задай значения базисов и структур через `setConstituentaValue` или `setConstituentaValues`.
-5. Вычисли проверяемую формулу через `evaluateExpression` или сохраненную конституенту через `evaluateConstituenta`.
-6. Сравни результат с ожидаемым значением; если есть несколько зависимых определений, запусти `recalculateModel`.
 ## Что задавать руками
 `basic`, `constant`, `structure` можно интерпретировать напрямую. `term`, `function`, `predicate`, `axiom`, `statement` должны вычисляться из формулы, поэтому их напрямую не задавай.
@@ -32,7 +23,13 @@ const TUPLE_ID = -111;
 tool.setConstituentaValues(sessionId, {
   items: [
     { target: 1, value: { 0: 'ann', 1: 'bob', 2: 'cat' } },
-    { target: 2, value: [[TUPLE_ID, 0, 1], [TUPLE_ID, 0, 2]] }
+    {
+      target: 2,
+      value: [
+        [TUPLE_ID, 0, 1],
+        [TUPLE_ID, 0, 2]
+      ]
+    }
   ]
 });
 ```

package/docs/README.md CHANGED Viewed

@@ -1,10 +1,12 @@
 # Документация rstool
-Краткая русская справка для агентов.
+Краткая справка для агентов.
+**Воркфлоу и чеклисты** — в `../skills/rstool-helper/GUIDE.md` (начинай с него). Здесь — справочные правила языка и предметной области.
 ## Какой файл читать
-- **DOMAIN.md** — термины Portal: конституента, концептуальная схема/модель, ОСС, синтез.
+- **DOMAIN.md** — термины Portal: конституента, базовые и производные понятия, ядро/тело КС, интерпретация, ОСС, синтез.
 - **CONCEPTUAL-SCHEMA.md** — проектирование и ревью концептуальных схем.
 - **CONSTITUENTA.md** — структура и правила конституент.
 - **SYNTAX.md** — операторы, кванторы, функции и примеры выражений.
@@ -14,4 +16,4 @@
 - **PORTAL-API.md** — объекты REST API Portal.
 - **GRAMMAR-REF.md** — краткая карта токенов и приоритетов.
-Контракт агента `rstool` см. в `../skills/rstool-helper/REFERENCE.md`.
+Контракт агента `rstool` и примеры — `../skills/rstool-helper/REFERENCE.md`, `EXAMPLES.md` (на русском, вместе с `GUIDE.md`).

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@rsconcept/rstool",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Agent-facing library for incremental RSForm construction, RSLang analysis, diagnostics, modeling, and evaluation. Wraps @rsconcept/domain with a deterministic session contract and stdio wrapper.",
   "license": "MIT",
   "author": "IRBorisov",

package/skills/README.md CHANGED Viewed

@@ -6,9 +6,9 @@ Each skill lives in its own subdirectory: `skills/<skill-name>/SKILL.md` (plus r
 - `INSTALL.md`: agent procedure after `npm install`
 - `rstool-helper/SKILL.md`: thin entry skill — copy into the project’s agent skills folder (see `INSTALL.md`)
-- `rstool-helper/GUIDE.md`: canonical workflow and language primer
-- `rstool-helper/REFERENCE.md`: API, stdio, contract
-- `rstool-helper/EXAMPLES.md`: worked examples and pitfalls
+- `rstool-helper/GUIDE.md`: единая точка входа — воркфлоу, чеклисты, обзор языка (на русском)
+- `rstool-helper/REFERENCE.md`: API, stdio, контракт (на русском)
+- `rstool-helper/EXAMPLES.md`: примеры и типичные ошибки (на русском)
 - `../docs/*.md`: language reference (DOMAIN, SYNTAX, DIAGNOSTICS, …)
 ## npm workflow

package/skills/rstool-helper/EXAMPLES.md CHANGED Viewed

@@ -1,10 +1,8 @@
-# rstool Examples
+# Примеры rstool
-Short examples for agents. For full scripts, see `../../examples/`.
+Короткие примеры для агентов. Полные скрипты — `../../examples/`. Воркфлоу — [GUIDE.md](GUIDE.md).
-## Minimal Session
-`S1` carries typification `ℬ(X1×X1)` for relation pairs. `D1` computes `Pr1(S1)`. Do not put bare `X1×X1` on a `term` when you mean a relation structure.
+## Минимальная сессия
 ```ts
 import { CstType, RSToolAgent } from '@rsconcept/rstool';
@@ -22,7 +20,7 @@ tool.addOrUpdateConstituenta(sessionId, {
     alias: 'S1',
     cstType: CstType.STRUCTURED,
     definitionFormal: 'ℬ(X1×X1)',
-    convention: 'Elements are (parent, child) pairs with parent, child ∈ X1.'
+    convention: 'Элементы — пары (родитель, потомок); родитель, потомок ∈ X1.'
   }
 });
@@ -33,9 +31,9 @@ const { state, diagnostics } = tool.addOrUpdateConstituenta(sessionId, {
 console.log(state.analysis.success, diagnostics.length);
 ```
-## Analyze Before Upsert
+## Анализ перед upsert
-Use scratch analysis when syntax or `cstType` is uncertain.
+Черновой анализ, когда синтаксис или `cstType` под вопросом.
 ```ts
 const analysis = tool.analyzeExpression(sessionId, {
@@ -48,60 +46,9 @@ if (!analysis.success) {
 }
 ```
-Fix the reported `from` / `to` range, then re-run analysis. Do not retry unchanged input.
-## Wrapper Client
+Исправь диапазон `from` / `to` из отчёта и повтори анализ. При необходимости пересмотри определение целиком или разбей на несколько конституент.
-Use the wrapper when the agent talks to a separate `rstool-wrapper` process.
-```ts
-import { CstType } from '@rsconcept/rstool';
-import { RSToolWrapperClient } from '@rsconcept/rstool/wrapper';
-const client = new RSToolWrapperClient();
-await client.waitUntilReady();
-const { sessionId } = await client.call<{ sessionId: string }>('createSession');
-await client.call('addOrUpdateConstituenta', {
-  sessionId,
-  input: {
-    draft: { id: 1, alias: 'X1', cstType: CstType.BASE, definitionFormal: '' }
-  }
-});
-const diagnostics = await client.call('listDiagnostics', { sessionId });
-console.log(diagnostics);
-await client.close();
-```
-Manual stdio is one JSON request per line:
-```jsonl
-{ "id": "1", "method": "createSession", "params": {} }
-{ "id": "2", "method": "addOrUpdateConstituenta", "params": { "sessionId": "...", "input": { "draft": { "id": 1, "alias": "X1", "cstType": "basic", "definitionFormal": "" } } } }
-```
-## Export / Import
-```ts
-const payload = tool.exportSession(sessionId);
-const restored = tool.importSession(payload);
-```
-Export includes session state and model values.
-To create files the user can upload to an existing Portal object:
-```ts
-const schemaJson = tool.exportPortalSchema(sessionId);
-const modelJson = tool.exportPortalModel(sessionId);
-```
-Use `schemaJson` on a schema page and `modelJson` on a model page via **Load from JSON**.
-## Evaluation
+## Вычисление
 ```ts
 tool.setConstituentaValue(sessionId, {
@@ -117,11 +64,11 @@ const scratch = tool.evaluateExpression(sessionId, {
 console.log(scratch.success, scratch.value); // true, 3
 ```
-For stored definitions, set values for `basic`, `constant`, and `structure`, then call `evaluateConstituenta` or `recalculateModel`.
+Для сохранённых определений задай значения `basic`, `constant` и `structure`, затем вызови `evaluateConstituenta` или `recalculateModel`.
-## Semantic Smoke Test
+## Семантический smoke-тест
-When syntax is valid but meaning is uncertain, build a tiny model and assert the value.
+Синтаксис верен, но смысл неочевиден — собери маленькую модель и проверь значение.
 ```ts
 import { CstType, EvalStatus, RSToolAgent } from '@rsconcept/rstool';
@@ -156,76 +103,59 @@ tool.setConstituentaValues(sessionId, {
 const result = tool.evaluateConstituenta(sessionId, { constituentId: 3 });
 if (!result.success || result.status !== EvalStatus.HAS_DATA || JSON.stringify(result.value) !== '[0]') {
-  throw new Error(`Expected Pr1(S1) to select the first coordinate; got ${JSON.stringify(result)}`);
+  throw new Error(`Ожидалось Pr1(S1) = первая координата; получено ${JSON.stringify(result)}`);
 }
 ```
-Use this pattern for tests that protect important definitions. Full kinship model: `../../examples/build-kinship-rsmodel.ts`. More notes: `../../docs/MODEL-TESTING.md`.
+Подробнее: `../../docs/MODEL-TESTING.md`.
+## Клиент обёртки
-## Relation-first synthesis (layered KS)
+Когда агент общается с отдельным процессом `rstool-wrapper`.
-Pattern for merging sub-schemas (transformation + transition + choice → stimulation). Reference: Portal `D01B03` / rsform `843`.
+```ts
+import { CstType } from '@rsconcept/rstool';
+import { RSToolWrapperClient } from '@rsconcept/rstool/wrapper';
-1. **Structures** — one `S#` per mechanism, typification only:
+const client = new RSToolWrapperClient();
+await client.waitUntilReady();
-```text
-S1: ℬ(X1×X2×X1)   // transformation
-S2: ℬ(X2×X3×X2)   // transition
-S4: ℬ(X2×X1×X3)   // allowance (flat triple, not ℬ(X2×X1×ℬ(X3)))
-S5: ℬ(X1×ℬ(X3)×X3) // choice
-```
+const { sessionId } = await client.call<{ sessionId: string }>('createSession');
+await client.call('addOrUpdateConstituenta', {
+  sessionId,
+  input: {
+    draft: { id: 1, alias: 'X1', cstType: CstType.BASE, definitionFormal: '' }
+  }
+});
-2. **Axioms** — short invariants:
+const diagnostics = await client.call('listDiagnostics', { sessionId });
+console.log(diagnostics);
-```text
-A1: Pr1,2(S1) = X1×X2
-A2: card(S1) = card(Pr1,2(S1))
-A4: card(S5) = card(Pr1,2(S5))
-A5: ∀d∈S5 pr3(d)∈pr2(d)
+await client.close();
 ```
-3. **Functions** — parameterized access (reuse everywhere):
+Ручной stdio — один JSON-запрос на строку:
-```text
-F5[α,β] := Pr3(Fi1,2[{(β,α)}](S4))   // possible actions
-F7[α,ξ] := F6[α, F5[α,ξ]]            // chosen action in situation
+```jsonl
+{ "id": "1", "method": "createSession", "params": {} }
+{ "id": "2", "method": "addOrUpdateConstituenta", "params": { "sessionId": "...", "input": { "draft": { "id": 1, "alias": "X1", "cstType": "basic", "definitionFormal": "" } } } }
 ```
-4. **Central term** — one tuple relation, then projections:
+## Экспорт / импорт
-```text
-D13 ::= I{(α,ξ1,τ,ξ2,β1,β2,ρ,ξ3) | α∈S6; ξ1∈X2; τ∈F7[α,ξ1]; …; ξ3∈S3}
-D14 := Pr3(D13)   // stimuli
-D18 := Pr2(D13)   // initial situations
+```ts
+const payload = tool.exportSession(sessionId);
+const restored = tool.importSession(payload);
 ```
-5. **Classifiers** — filter via `F#`, not a new `∃` chain:
+Экспорт включает состояние сессии и значения модели.
-```text
-F8[α] := Pr2(Fi3[{α}](D13))
-D22 := D{ξ∈D14 | F8[ξ] = X2}   // stimulus valid in any situation
+Файлы для загрузки пользователем в существующий объект Portal:
+```ts
+const schemaJson = tool.exportPortalSchema(sessionId);
+const modelJson = tool.exportPortalModel(sessionId);
 ```
-Upsert in dependency order; run `analyzeExpression` on `I{…}` before committing the central `D#`.
-## Common mistakes
-- `definitionFormal: 'Z'` on `basic` / `constant` → `definitionNotAllowed`.
-- `D1` uses `D2` before `D2` exists → global not typed / undeclared.
-- Wrong `cstType` in `analyzeExpression` → role-specific errors.
-- `term` with `X1×X1` for a relation → full Cartesian product, not relation typification.
-- `structure` with `Pr1(S1)` → wrong role; projections belong on `term` / `function`.
-- Same long `∃d1…∃dn` chain in many `D#` → define one central `D#` and use `Pr*` / `F#`.
-- `S4: ℬ(X2×X1×ℬ(X3))` when you only need «individual allows actions» → prefer `ℬ(X2×X1×X3)` + `F5`.
-- `∀x∈A, ∀y∈B` → invalid; nest: `∀x∈A (∀y∈B (…))`.
-- Functional relation axiom as huge `∀⇒` → prefer `card(S)=card(Pr1,2(S))` when equivalent.
-- `setConstituentaValue` on `term`, `axiom`, or `statement` → cannot set computed constituents directly.
-- Evaluation before base bindings → missing value, empty result, or evaluation failure.
-## Fix Syntax
-1. `analyzeExpression` with the broken fragment and correct `cstType`.
-2. Read `{ code, from, to, params }`.
-3. Edit the substring of `definitionFormal` at those offsets.
-4. Re-run analysis.
-5. Upsert with the same `id` / `alias`.
+`schemaJson` — на странице схемы, `modelJson` — на странице модели, через **Load from JSON**.

package/skills/rstool-helper/GUIDE.md CHANGED Viewed

@@ -1,68 +1,122 @@
-# RS Language & rstool
+# RSLang и rstool
-Compact entry guide for agents. Keep details in linked docs.
+Краткий входной гайд для агентов. Детали — в связанных документах.
-**RSLang** is a formal notation for conceptual schemas: concepts, relations, operations, assertions. Core ideas: membership `x∈y`, set-theoretic expressions, logical expressions, typification.
+**RSLang** — формальная нотация концептуальных схем: понятия, отношения, операции, утверждения. Основа: принадлежность `x∈y`, теоретико-множественные и логические выражения, типизация.
-**rstool** is the agent API for sessions, upserts, analysis, diagnostics, model values, evaluation, export/import.
+**rstool** — API агента для сессий, upsert, анализа, диагностик, значений модели, вычисления, экспорта/импорта.
-- Library: `@rsconcept/rstool`.
-- Analyzer: `@rsconcept/domain`.
-- Stdio wrapper: `npx rstool-wrapper`, JSON per line.
-- Node client: `RSToolWrapperClient`.
+- Библиотека: `@rsconcept/rstool`.
+- Анализатор: `@rsconcept/domain`.
+- Stdio-обёртка: `npx rstool-wrapper`, JSON построчно.
+- Node-клиент: `RSToolWrapperClient`.
-## What to Read
+## Что читать
-Paths are relative to this file.
+Пути — относительно этого файла.
-- API, methods, stdio, error codes: [REFERENCE.md](REFERENCE.md).
-- Worked examples and pitfalls: [EXAMPLES.md](EXAMPLES.md).
-- Domain terms: [../../docs/DOMAIN.md](../../docs/DOMAIN.md).
-- Schema design rules: [../../docs/CONCEPTUAL-SCHEMA.md](../../docs/CONCEPTUAL-SCHEMA.md).
-- Constituents and validation: [../../docs/CONSTITUENTA.md](../../docs/CONSTITUENTA.md).
-- Syntax: [../../docs/SYNTAX.md](../../docs/SYNTAX.md).
-- Typification: [../../docs/TYPIFICATION.md](../../docs/TYPIFICATION.md).
-- Definition testing with small conceptual models: [../../docs/MODEL-TESTING.md](../../docs/MODEL-TESTING.md).
-- Diagnostics: [../../docs/DIAGNOSTICS.md](../../docs/DIAGNOSTICS.md).
-- Portal REST reads: [../../docs/PORTAL-API.md](../../docs/PORTAL-API.md).
-- Grammar pointers: [../../docs/GRAMMAR-REF.md](../../docs/GRAMMAR-REF.md).
+- API, методы, stdio, коды ошибок: [REFERENCE.md](REFERENCE.md).
+- Примеры: [EXAMPLES.md](EXAMPLES.md).
+- Термины предметной области: [../../docs/DOMAIN.md](../../docs/DOMAIN.md).
+- Концептуализация, создание схемы: [../../docs/CONCEPTUAL-SCHEMA.md](../../docs/CONCEPTUAL-SCHEMA.md).
+- Конституенты и валидация: [../../docs/CONSTITUENTA.md](../../docs/CONSTITUENTA.md).
+- Синтаксис: [../../docs/SYNTAX.md](../../docs/SYNTAX.md).
+- Типизация: [../../docs/TYPIFICATION.md](../../docs/TYPIFICATION.md).
+- Проверка определений на КМ: [../../docs/MODEL-TESTING.md](../../docs/MODEL-TESTING.md).
+- Диагностики: [../../docs/DIAGNOSTICS.md](../../docs/DIAGNOSTICS.md).
+- Грамматика: [../../docs/GRAMMAR-REF.md](../../docs/GRAMMAR-REF.md).
+- REST Portal: [../../docs/PORTAL-API.md](../../docs/PORTAL-API.md).
-## Workflow
+## Воркфлоу
-Use this when editing or checking schemas and models.
+Все пошаговые сценарии собраны здесь. Справочные документы дают правила и детали.
-1. `createSession`.
-2. Add `basic` (`X#`) and `constant` (`C#`) with `definitionFormal: ''`.
-3. Add dependencies before dependents.
-4. Use `analyzeExpression` before upsert when unsure.
-5. When unsure about semantics, build a tiny conceptual model and evaluate test data.
-6. Fix diagnostics by `from` / `to` range in `definitionFormal`.
-7. `commitStep` when the state is coherent.
-8. Set base/model values with `setConstituentaValue(s)`.
-9. Evaluate with `evaluateExpression`, `evaluateConstituenta`, or `recalculateModel`.
-10. Persist with `exportSession` / `importSession`.
-11. For user-uploadable Portal files, use `exportPortalSchema` for schema JSON or `exportPortalModel` for model JSON.
+### Редактирование и проверка схемы
-## Diagnostics Loop
+Когда схема уже есть и нужны точечные правки, новые конституенты или проверка формул.
-1. Check `analysis.success`.
-2. If false, read `analysis.diagnostics` or `listDiagnostics`.
-3. Map `code` to a fix in `DIAGNOSTICS.md`.
-4. Patch the reported `from` / `to` range.
-5. Re-run only after changing input.
+1. `createSession` (или продолжить существующую сессию).
+2. Развивай схему — добавляй конституенты с корректным `cstType` и атрибутами.
+3. Добавляй поставщиков раньше потребителей (см. [порядок объявления](#порядок-объявления-конституент)).
+4. Перед upsert при сомнении вызывай `analyzeExpression`.
+5. Исправляй диагностики по диапазону `from` / `to` в `definitionFormal` ([DIAGNOSTICS.md](../../docs/DIAGNOSTICS.md)).
+6. При сомнении в семантике собери маленькую КМ и проверь тестовые данные ([цикл КМ](#проверка-на-маленькой-км)).
+7. Задай базовые/модельные значения: `setConstituentaValue(s)`; вычисли: `evaluateExpression`, `evaluateConstituenta`, `recalculateModel`.
+8. `commitStep`, когда состояние согласовано.
+9. Сохрани: `exportSession` / `importSession`.
+10. Для загрузки в Portal: `exportPortalSchema` (схема) или `exportPortalModel` (модель).
-## Declaration Order
+### Концептуализация (КС из содержания источника)
+Когда нужно построить или существенно развить КС по тексту ПО, требованиям или предметному описанию. Правила редукции, слоёв и паттернов — [CONCEPTUAL-SCHEMA.md](../../docs/CONCEPTUAL-SCHEMA.md).
+1. Собери словарь: базовые понятия, ключевые отношения, сценарий синтеза.
+2. Добавь `X#`, `C#` с конвенциями из источника (не копируй дословно).
+3. Добавь базовые `S#`: трансформация, перевод, допускание, выбор, цели, субъекты.
+4. Проверь независимость базовых понятий — они не выводятся друг из друга.
+5. Добавь `A#` на структуры: `card`, покрытие `Pr1,2(S#)=…`, принадлежность выбора.
+6. Введи `F#` для типовых запросов.
+7. Производные понятия строй через `Pr*`, `Fi*`, `F#` от центрального `D#` и базовых `S#`.
+8. Перед каждым upsert — `analyzeExpression`; при ошибках — [цикл диагностик](#цикл-диагностик).
+9. Сомнительную семантику проверь на маленькой КМ ([цикл КМ](#проверка-на-маленькой-км), [MODEL-TESTING.md](../../docs/MODEL-TESTING.md)).
+10. Перед показом результата пройди [чеклист ревью КС](#ревью-концептуальной-схемы).
+Дальше — обычное [редактирование и проверка](#редактирование-и-проверка-схемы): commit, export.
+### Цикл диагностик
+Когда `analysis.success === false` или `listDiagnostics` не пуст. Коды и типичные ошибки — [DIAGNOSTICS.md](../../docs/DIAGNOSTICS.md).
+1. Запусти `analyzeExpression` (черновик без сохранения).
+2. Прочитай `code`, `from`, `to`, `params` в `analysis.diagnostics` или через `listDiagnostics`.
+3. Сопоставь `code` с исправлением в [DIAGNOSTICS.md](../../docs/DIAGNOSTICS.md).
+4. Исправь именно диапазон в `definitionFormal`.
+5. Не повторяй вызов без изменения ввода.
+6. После успеха — `addOrUpdateConstituenta`.
+### Проверка на маленькой КМ
+Когда синтаксис верен, но смысл формулы неочевиден. Подробности и форма данных — [MODEL-TESTING.md](../../docs/MODEL-TESTING.md).
+1. Отдельная `createSession` или изолированная копия текущей сессии.
+2. Только нужные поставщики: `X#`, `C#`, `S#` и проверяемые `D#` / `F#` / `P#` / `A#`.
+3. `analyzeExpression` и `addOrUpdateConstituenta`.
+4. Значения базовых понятий: `setConstituentaValue` / `setConstituentaValues`.
+5. `evaluateExpression` или `evaluateConstituenta`; сравни с ожидаемым `value`.
+6. При нескольких зависимых определениях — `recalculateModel`.
+Для регрессий вынеси проверку в скрипт или colocated `*.test.ts` (см. [MODEL-TESTING.md](../../docs/MODEL-TESTING.md)).
+### Порядок объявления конституент
 1. `basic`, `constant`.
-2. Core structures and key concepts.
-3. Derived constituents in topological order.
-4. Axioms and statements after their references.
-## Checklist
-- [ ] `sessionId` tracked.
-- [ ] `cstType` matches the role.
-- [ ] Check schema and fix errors before showing result.
-- [ ] Diagnostics handled before commit/export.
-- [ ] Ambiguous semantics checked on a small model.
-- [ ] Base values set before evaluation.
+2. Базовые структуры и ключевые понятия.
+3. Производные конституенты в топологическом порядке.
+4. Аксиомы и утверждения после всех ссылок.
+Правила валидации по типам — [CONSTITUENTA.md](../../docs/CONSTITUENTA.md).
+## Чеклисты
+### Сессия и rstool
+- [ ] Отслеживается `sessionId`.
+- [ ] `cstType` соответствует роли конституенты.
+- [ ] Поставщики добавлены раньше потребителей.
+### Перед показом, commit и export
+- [ ] Схема проверена; ошибки исправлены.
+- [ ] Диагностики обработаны до `commitStep` и экспорта.
+### Ревью концептуальной схемы
+Перед завершением концептуализации или крупного изменения. Правила — [CONCEPTUAL-SCHEMA.md](../../docs/CONCEPTUAL-SCHEMA.md).
+- [ ] Атрибутивная и родоструктурная экспликации не смешаны без явного запроса.
+- [ ] Нет избыточной проверки принадлежности к собственной типизации (`x∈X1`, если `x` уже в `X1`).
+- [ ] Базовые понятия независимы, введены необходимые по смысле аксиомы.
+- [ ] Покрыты главные сущности, роли, отношения, утверждения.
+- [ ] В текстовых определениях используются только понятия из схемы.
+- [ ] Повторяющиеся части формальных определений вынесены в производные понятия `D#` и `F#`.
+- [ ] Сомнительная семантика проверена на маленькой КМ при наличии тестовых данных.

package/skills/rstool-helper/REFERENCE.md CHANGED Viewed

@@ -1,41 +1,41 @@
-# RS language and rstool — reference
-## rstool contract
-- Package: `@rsconcept/rstool`
-- Contract version: `1.4.0` (`CONTRACT_VERSION`)
-- Core class: `RSToolAgent`
-- Public imports: `@rsconcept/rstool` and `@rsconcept/rstool/wrapper`
-### Methods
-| Method                                                      | Purpose                                                            |
-| ----------------------------------------------------------- | ------------------------------------------------------------------ |
-| `createSession(initial?)`                                   | New in-memory session → `{ sessionId, contractVersion }`           |
-| `addOrUpdateConstituenta(sessionId, { draft })`             | Merge draft; analyze in session context → `{ state, diagnostics }` |
-| `analyzeExpression(sessionId, { expression, cstType })`     | Parse/typecheck snippet without persisting a constituent           |
-| `getFormState(sessionId)`                                   | Clone of full session state                                        |
-| `listDiagnostics(sessionId, filters?)`                      | Accumulated diagnostics; optional `constituentId` filter           |
-| `commitStep(sessionId, message?)`                           | Record revision checkpoint                                         |
-| `exportSession(sessionId)`                                  | JSON string `{ contractVersion, state, diagnostics }`              |
-| `exportPortalSchema(sessionId)`                             | Portal schema import JSON string using versioned schema shape      |
-| `exportPortalModel(sessionId)`                              | Portal model import JSON string using versioned model values shape |
-| `importSession(payload)`                                    | New session from export                                            |
-| `setConstituentaValue(sessionId, { target, type?, value })` | Set one base binding or structured value → `SessionModelState`     |
-| `setConstituentaValues(sessionId, { items })`               | Batch set values → `SessionModelState`                             |
-| `clearConstituentaValues(sessionId, { items })`             | Clear values by constituent id → `SessionModelState`               |
-| `getModelState(sessionId)`                                  | Clone of session interpretation state                              |
-| `evaluateExpression(sessionId, { expression, cstType })`    | Evaluate snippet in session context → `EvaluationResult`           |
-| `evaluateConstituenta(sessionId, { constituentId })`        | Evaluate stored definition → `EvaluationResult`                    |
-| `recalculateModel(sessionId)`                               | Recalculate all inferrable constituents → `{ items[] }`            |
+# RSLang и rstool — справочник
+## Контракт rstool
+- Пакет: `@rsconcept/rstool`
+- Версия контракта: `1.4.0` (`CONTRACT_VERSION`)
+- Основной класс: `RSToolAgent`
+- Публичные импорты: `@rsconcept/rstool` и `@rsconcept/rstool/wrapper`
+### Методы
+| Метод                                                       | Назначение                                                                    |
+| ----------------------------------------------------------- | ----------------------------------------------------------------------------- |
+| `createSession(initial?)`                                   | Новая in-memory сессия → `{ sessionId, contractVersion }`                     |
+| `addOrUpdateConstituenta(sessionId, { draft })`             | Слияние черновика; анализ в контексте сессии → `{ state, diagnostics }`       |
+| `analyzeExpression(sessionId, { expression, cstType })`     | Разбор/типизация фрагмента без сохранения конституенты                        |
+| `getFormState(sessionId)`                                   | Клон полного состояния сессии                                                 |
+| `listDiagnostics(sessionId, filters?)`                      | Накопленные диагностики; опциональный фильтр `constituentId`                  |
+| `commitStep(sessionId, message?)`                           | Зафиксировать контрольную точку ревизии                                       |
+| `exportSession(sessionId)`                                  | JSON-строка `{ contractVersion, state, diagnostics }`                         |
+| `exportPortalSchema(sessionId)`                             | JSON импорта схемы Portal                                                     |
+| `exportPortalModel(sessionId)`                              | JSON импорта модели Portal                                                    |
+| `importSession(payload)`                                    | Новая сессия из экспорта                                                      |
+| `setConstituentaValue(sessionId, { target, type?, value })` | Одна привязка базового понятия или структурное значение → `SessionModelState` |
+| `setConstituentaValues(sessionId, { items })`               | Пакетная установка значений → `SessionModelState`                             |
+| `clearConstituentaValues(sessionId, { items })`             | Очистка значений по id конституент → `SessionModelState`                      |
+| `getModelState(sessionId)`                                  | Клон состояния интерпретации сессии                                           |
+| `evaluateExpression(sessionId, { expression, cstType })`    | Вычисление фрагмента в контексте сессии → `EvaluationResult`                  |
+| `evaluateConstituenta(sessionId, { constituentId })`        | Вычисление сохранённого определения → `EvaluationResult`                      |
+| `recalculateModel(sessionId)`                               | Пересчёт всех выводимых конституент → `{ items[] }`                           |
 ### `ConstituentaDraft`
 ```ts
 {
-  id: number;           // stable id within session
-  alias: string;        // e.g. "D1", "X1"
-  cstType: CstType;     // see GUIDE.md table
+  id: number;           // стабильный id внутри сессии
+  alias: string;
+  cstType: CstType;
   definitionFormal: string;
   term?: string;
   definitionText?: string;
@@ -43,27 +43,27 @@
 }
 ```
-Omitted text fields default to `''` in stored state.
+Пропущенные текстовые поля в сохранённом состоянии по умолчанию `''`.
-### `SessionState` metadata
+### Метаданные `SessionState`
-Set on `createSession(initial?)` or via `importSession`:
+Задаются в `createSession(initial?)` или через `importSession`:
 ```ts
 {
-  alias: string; // library item alias
-  title: string; // display title
-  comment: string; // developer notes
+  alias: string; // alias объекта библиотеки
+  title: string; // отображаемое название
+  comment: string; // заметки разработчика
 }
 ```
-All default to `''` when omitted.
+При опускании все поля по умолчанию `''`.
-### Model and evaluation types
+### Типы модели и вычисления
 ```ts
-type RSToolValue = number | RSToolValue[]; // runtime value (sets, tuples, logic 0/1)
-type BasicBinding = Record<number, string>; // base-set element labels
+type RSToolValue = number | RSToolValue[]; // значение во время выполнения
+type BasicBinding = Record<number, string>; // подписи элементов базового множества
 interface SessionModelState {
   items: { id: number; type: string; value: RSToolValue | BasicBinding }[];
@@ -79,19 +79,19 @@ interface EvaluationResult {
 }
 ```
-Base/constant bindings use `type: "basic"` and `value: { "0": "label", … }`. Structured values use normalized typification as `type` and nested arrays for sets/tuples.
+Привязки `basic`/`constant` используют `type: "basic"` и `value: { "0": "label", … }`. Структурные значения — нормализованная типизация в `type` и вложенные массивы для множеств/кортежей.
-### Stdio protocol
+### Протокол stdio
-Process: `npx rstool-wrapper`
+Процесс: `npx rstool-wrapper`
-1. **Ready** (no request): `{"id":null,"ok":true,"result":{"ready":true,"wrapper":"rstool-stdio","contractVersion":"1.4.0"}}`
-2. **Request**: `{"id":"<unique>","method":"<name>","params":{...}}`
-3. **Response**: `{"id":"<same>","ok":true,"result":...}` or `{"id":"...","ok":false,"error":{"code":"...","message":"..."}}`
+1. **Ready** (без запроса): `{"id":null,"ok":true,"result":{"ready":true,"wrapper":"rstool-stdio","contractVersion":"1.4.0"}}`
+2. **Запрос**: `{"id":"<unique>","method":"<name>","params":{...}}`
+3. **Ответ**: `{"id":"<same>","ok":true,"result":...}` или `{"id":"...","ok":false,"error":{"code":"...","message":"..."}}`
-Extra methods: `ping`, `methods`.
+Дополнительные методы: `ping`, `methods`.
-Example chain:
+Пример цепочки:
 ```json
 {"id":"1","method":"createSession","params":{}}
@@ -108,96 +108,90 @@ Example chain:
 {"id":"9","method":"evaluateConstituenta","params":{"sessionId":"…","input":{"constituentId":3}}}
 ```
-`RSToolWrapperClient`: spawns `rstool-wrapper` by default and implements `waitUntilReady()`, `call(method, params)`, `close()`.
+`RSToolWrapperClient`: по умолчанию запускает `rstool-wrapper`; методы `waitUntilReady()`, `call(method, params)`, `close()`.
-### Analysis result
+### Результат анализа
 ```ts
 interface AnalysisResult {
   success: boolean;
-  type: Record<string, unknown> | null; // typification tree
+  type: Record<string, unknown> | null;
   valueClass: 'value' | 'property' | null;
   diagnostics: { code: number; from: number; to: number; params?: string[] }[];
 }
 ```
-## RS language — conceptual model
+## RSLang
-- **Typification**: structure type of an expression; grades include elements (`Xi`, `Ci`), `Z`, tuples `(H1×…×Hn)`, sets `ℬ(H)`, logic `Logic`, parameterized `Hr 🠔 [H1,…,Hi]`. On `structure` (`S#`), `definitionFormal` **is** the typification. On `term` (`D#`), typification is **inferred from** the definition.
-- **Term graph**: directed dependencies between constituenta via alias references in definitions.
-- **`S#` vs `D#`**: same `×` token — in `ℬ(X1×X1)` on `S#` it forms a **grade** (pair type); in `X1×X1` on `D#` it is the **Cartesian product** (all pairs). Relations: `S#` + `convention`, then derived `D#` (`Pr1(S1)`, …).
+Кратко: язык на базе логики первого порядка; разделение множественных и логических выражений; параметризованные шаблоны для функций и предикатов.
-Intro (help): language is FOL-based; set vs logic expression split; parameterized templates for term/predicate functions.
+- **Типизация**: структурный тип выражения; ступени включают элементы (`Xi`, `Ci`), `Z`, кортежи `(H1×…×Hn)`, множества `ℬ(H)`, логику `Logic`, параметризованные `Hr 🠔 [H1,…,Hi]`. У `structure` (`S#`) поле `definitionFormal` **задаёт** типизацию. У `term` (`D#`) типизация **выводится** из определения.
-## Grammar tokens (selected)
+## Токены грамматики
-From `rslang.grammar`:
+Из `rslang.grammar`:
-| Category               | Tokens / forms                                             |
-| ---------------------- | ---------------------------------------------------------- |
-| Globals                | `X`, `C`, `S`, `D`, `A`, `T`, `N` + digits (`Global` rule) |
-| Functions / predicates | `F<n>`, `P<n>`                                             |
-| Radicals               | `R<n>`                                                     |
-| Locals                 | `_a-zα-ω` + optional digits                                |
-| Logic                  | `¬` `∀` `∃` `⇔` `⇒` `∨` `&`                                |
-| Sets                   | `ℬ` `∪` `\` `∆` `∩` `×` `∈` `∉` `⊆` `⊂` …                  |
-| Ops                    | `Pr`, `pr`, `Fi`, `card`, `bool`, `debool`, `red`          |
-| Literals               | digits, `Z`, `∅`                                           |
+| Категория           | Токены / формы                                          |
+| ------------------- | ------------------------------------------------------- |
+| Глобальные          | `X`, `C`, `S`, `D`, `A`, `T` + цифры (правило `Global`) |
+| Функции / предикаты | `F<n>`, `P<n>`                                          |
+| Радикалы            | `R<n>`                                                  |
+| Локальные           | `_a-zα-ω` + опциональные цифры                          |
+| Логика              | `¬` `∀` `∃` `⇔` `⇒` `∨` `&`                             |
+| Множества           | `ℬ` `∪` `\` `∆` `∩` `×` `∈` `∉` `⊆` `⊂` …               |
+| Операции            | `Pr`, `pr`, `Fi`, `card`, `bool`, `debool`, `red`       |
+| Литералы            | цифры, `Z`, `∅`                                         |
-Full grammar pointers and precedence notes: `docs/GRAMMAR-REF.md`.
+Полная грамматика и приоритеты: `docs/GRAMMAR-REF.md`.
-## Help topic map (companion docs)
+## Документация
-Standalone agents should consult the bundled distilled docs (`docs/*.md` inside `@rsconcept/rstool`):
+| Тема                                     | Документ                                                     |
+| ---------------------------------------- | ------------------------------------------------------------ |
+| Идентификаторы, литералы                 | `docs/SYNTAX.md` § «Имена и литералы»                        |
+| Ступени, `Logic`, параметризованные типы | `docs/TYPIFICATION.md` § «Ступени»                           |
+| Логические выражения                     | `docs/SYNTAX.md` § «Логические выражения (LE)»               |
+| Операторы над множествами                | `docs/SYNTAX.md` § «Теоретико-множественные выражения (STE)» |
+| Целочисленная арифметика                 | `docs/SYNTAX.md` § «Арифметика»                              |
+| Дополнительные и производные типизации   | `docs/TYPIFICATION.md` § «Дополнительные типизации»          |
+| Кванторы                                 | `docs/SYNTAX.md` § «Кванторы»                                |
+| Параметризованные функции, шаблоны       | `docs/SYNTAX.md` § «Параметризованные выражения»             |
+| Модель корректности / валидация          | `docs/SYNTAX.md` § «Корректность»                            |
+| Семантические тесты определений          | `docs/MODEL-TESTING.md`                                      |
+| Словарь предметной области               | `docs/DOMAIN.md`                                             |
+| Поля конституент и порядок               | `docs/CONSTITUENTA.md`                                       |
+| REST API Portal                          | `docs/PORTAL-API.md`                                         |
+| Токены грамматики / приоритеты           | `docs/GRAMMAR-REF.md`                                        |
-| Topic                                | Bundled doc                                |
-| ------------------------------------ | ------------------------------------------ |
-| Identifiers, literals                | `docs/SYNTAX.md` § _Identifier rules_      |
-| Grades, `Logic`, parameterized types | `docs/TYPIFICATION.md`                     |
-| Logical expressions                  | `docs/SYNTAX.md` § _Logical expressions_   |
-| Set operators                        | `docs/SYNTAX.md` § _Set-theoretic_         |
-| Integer arithmetic                   | `docs/SYNTAX.md` § _Arithmetic_            |
-| Structural / typification reshaping  | `docs/TYPIFICATION.md` § _Forming/derived_ |
-| Quantifiers                          | `docs/SYNTAX.md` § _Quantifiers_           |
-| Parameterized functions, templates   | `docs/SYNTAX.md` § _Parameterised_         |
-| Correctness / validation mindset     | `docs/SYNTAX.md` § _Correctness model_     |
-| Definition semantic tests            | `docs/MODEL-TESTING.md`                    |
-| Domain vocabulary                    | `docs/DOMAIN.md`                           |
-| Constituent fields and ordering      | `docs/CONSTITUENTA.md`                     |
-| Portal REST API                      | `docs/PORTAL-API.md`                       |
-| Grammar tokens / precedence          | `docs/GRAMMAR-REF.md`                      |
+Воркфлоу и чеклисты — `skills/rstool-helper/GUIDE.md`.
-## Error codes (rstool-relevant)
+## Коды ошибок
-rstool re-exports `RSErrorCode.definitionNotAllowed` (`0x8862`) for base/constant violations.
+Категории и исправления по коду: `docs/DIAGNOSTICS.md`.
-Categories and per-code fix guidance: `docs/DIAGNOSTICS.md`.
+Категории:
-Categories:
+- `0x84xx` — синтаксис / разбор
+- `0x28xx` — предупреждения локальных объявлений
+- `0x88xx` — семантика / типы
+- `0x886x` — уровень конституент (пустая производная, запрещённое определение)
+- `0x81xx` — вычисление (runtime; из `evaluateExpression` / `evaluateConstituenta`)
-- `0x84xx` — syntax / parse
-- `0x28xx` — local declaration warnings
-- `0x88xx` — semantic / type
-- `0x886x` — constituent-level (empty derived, definition not allowed)
-- `0x81xx` — evaluation (runtime; returned by `evaluateExpression` / `evaluateConstituenta`)
+## Форма экспорта сессии
-## Exported session shape
+`exportSession(sessionId)` возвращает JSON-строку `{ contractVersion, state, diagnostics }`.
-`exportSession(sessionId)` returns a JSON string with `{ contractVersion, state, diagnostics }`.
+- `state.alias`, `state.title`, `state.comment` — метаданные объекта библиотеки для экспорта в Portal (`comment` → JSON `description`).
+- `state.items[]` — каждая конституента с `id`, `alias`, `cstType`, `definitionFormal`, опциональными текстовыми полями и вложенным результатом анализа.
+- `state.model.items[]` — присутствует, если заданы значения интерпретации.
+- `diagnostics[]` — накопленные диагностики со смещениями и кодами.
-- `state.alias`, `state.title`, `state.comment` — library-item metadata for Portal export (`comment` → JSON `description`).
-- `state.items[]` contains each constituent with `id`, `alias`, `cstType`, `definitionFormal`, optional text fields, and nested analysis output.
-- `state.model.items[]` is present when interpretation values have been set.
-- `diagnostics[]` contains accumulated diagnostics with offsets and codes.
+## JSON импорта Portal
-## Portal import JSON
+Для **Load from JSON** на существующей схеме или модели Portal:
-For **Load from JSON** on an existing Portal schema or model:
+- `exportPortalSchema(sessionId)` — файл схемы
+- `exportPortalModel(sessionId)` — файл модели
-- `exportPortalSchema(sessionId)` — schema file
-- `exportPortalModel(sessionId)` — model file
-Both return `contract_version` `1.0.0` plus required `title`, `alias`, `description`, and `items`. Schema files may include `attribution`. Values come from `state.title`, `state.alias`, and `state.comment` (empty fields fall back to `Conceptual schema` / `SCHEMA` or `Conceptual model` / `MODEL` and `""`).
-- Schema `items[]`: versioned constituent fields (`cst_type`, `definition_formal`, `term_raw`, …).
-- Model `items[]`: `{ id, type, value }` per binding.
+- Схема `items[]`: поля конституент (`cst_type`, `definition_formal`, `term_raw`, …).
+- Модель `items[]`: `{ id, type, value }` на каждую привязку.

package/skills/rstool-helper/SKILL.md CHANGED Viewed

@@ -1,12 +1,10 @@
 ---
 name: rstool-helper
 description: >-
-  RS language and @rsconcept/rstool for agents. After npm install, read GUIDE and
-  docs from node_modules. If the entry skill is not installed in the project yet,
-  follow skills/INSTALL.md in this package.
+  RS language, formal definitions and conceptual schema design for agents. Read GUIDE and docs from node_modules.
 ---
-# rstool-helper (npm install)
+# rstool-helper
 Thin **entry** skill. Full guide and docs stay in the package — use the Read tool on the paths below (from the project root).
@@ -20,9 +18,9 @@ Then continue with the canonical files below.
 ## Canonical files (read before rstool work)
-- **Start here** — workflow: `node_modules/@rsconcept/rstool/skills/rstool-helper/GUIDE.md`
-- API, stdio, contract: `node_modules/@rsconcept/rstool/skills/rstool-helper/REFERENCE.md`
-- Examples, pitfalls: `node_modules/@rsconcept/rstool/skills/rstool-helper/EXAMPLES.md`
+- **Start here** — воркфлоу и чеклисты: `node_modules/@rsconcept/rstool/skills/rstool-helper/GUIDE.md`
+- API, stdio, контракт: `node_modules/@rsconcept/rstool/skills/rstool-helper/REFERENCE.md`
+- Примеры, типичные ошибки: `node_modules/@rsconcept/rstool/skills/rstool-helper/EXAMPLES.md`
 - Language / domain docs: `node_modules/@rsconcept/rstool/docs/*.md`
 - Install procedure: `node_modules/@rsconcept/rstool/skills/INSTALL.md`