@rsconcept/rstool 0.2.1 → 0.4.0

package/docs/PORTAL-API.md

@@ -1,45 +1,31 @@
-# Portal REST API (read-only reference)
+# Portal REST API
 
-When an agent needs to **inspect existing** RSForms, OSS, or RSModels persisted on the Portal, use the REST API on `api.portal.acconcept.ru`. The rstool library itself never calls the Portal API — it always works on in-memory sessions. This document is for agents that combine rstool sessions with data fetched from a live Portal.
+Справка только для чтения существующих КС, ОСС и RSModel. `rstool` сам не ходит в REST API: он работает с in-memory сессиями.
 
-## Hosts
+## Хосты
 
-- **UI:** `https://portal.acconcept.ru/`
-- **REST API:** `https://api.portal.acconcept.ru/`
+- UI: `https://portal.acconcept.ru/`
+- REST API: `https://api.portal.acconcept.ru/`
 
-## Path rewrite rules
+## Пути
 
-| Portal UI path                   | REST target                                             |
-| -------------------------------- | ------------------------------------------------------- |
-| `/rsforms/:id`                   | `GET /api/rsforms/:id` (metadata: owner, titles)        |
-| `/rsforms/:id` (full payload)    | `GET /api/rsforms/:id/details`                          |
-| `/rsforms/:id` (a saved version) | `GET /api/library/:id/versions/:version`                |
-| `/oss/:id`                       | `GET /api/oss/:id` (and the sibling OSS viewset routes) |
-| `/models/:id`                    | `GET /api/models/:id` (RSModel router)                  |
+- `/rsforms/:id` в UI → `GET /api/rsforms/:id` для метаданных.
+- Полная КС → `GET /api/rsforms/:id/details`.
+- Версия КС → `GET /api/library/:id/versions/:version`.
+- ОСС → `GET /api/oss/:id` и соседние routes viewset.
+- Модель → `GET /api/models/:id`.
+- OpenAPI JSON → `GET https://api.portal.acconcept.ru/schema`.
 
-## OpenAPI
+## Как перенести КС в rstool
 
-Machine-readable schema:
+1. Получи `GET /api/rsforms/:id/details`.
+2. Создай `createSession`.
+3. Перенеси конституенты через `addOrUpdateConstituenta`: `alias`, `cstType`, `definitionFormal`, `term`, `definitionText`, `convention`.
+4. Работай локально: анализ, правки, вычисления.
+5. Для передачи результата используй `exportSession`.
 
-```
-GET https://api.portal.acconcept.ru/schema
-```
+## Не делай
 
-Prefer `/schema` for JSON. The Swagger UI is separate.
-
-## What rstool consumes
-
-rstool itself works with in-memory sessions via `RSToolAgent` or the stdio wrapper. To bridge between the REST payload and a rstool session, the typical flow is:
-
-1. `GET /api/rsforms/:id/details` to fetch the persisted RSForm.
-2. Convert the response (constituents, formal definitions, term, convention, etc.) into a series of `addOrUpdateConstituenta` calls inside a fresh `createSession`.
-3. Operate offline: analyse, edit, evaluate, then `exportSession` for hand-off.
-
-There is no backend write path in rstool: edits never round-trip to the Portal automatically. Publish changes back to the Portal through the existing Portal UI or REST writes.
-
-## Don'ts
-
-- Do not scrape the SPA HTML.
-- Do not pass UI hash params (`?tab=editor`, etc.) to REST.
-- Do not call `/api/rsforms/:id/details` for trivial metadata — `GET /api/rsforms/:id` is cheaper.
-- Do not assume the API host is the same as the UI host in production — they are different.
+- Не парси HTML SPA.
+- Не переноси UI query/hash вроде `?tab=editor` в REST.
+- Не запрашивай `/details`, если нужны только метаданные.

package/docs/README.md

@@ -1,16 +1,17 @@
-# rstool docs
+# Документация rstool
 
-Standalone English reference distilled from the Portal manuals and `CONTEXT.md`. Bundled with `@rsconcept/rstool` so external agents never need to read the Portal frontend source tree.
+Краткая русская справка для агентов.
 
-| File | Read when |
-|------|-----------|
-| [`DOMAIN.md`](DOMAIN.md) | You need the Concept Portal vocabulary (constituenta, conceptual schema/model, OSS, synthesis). |
-| [`CONCEPTUAL-SCHEMA.md`](CONCEPTUAL-SCHEMA.md) | You are designing/reviewing a conceptual schema as a system (thesaurus value, closed-world text definitions, genus structures, axioms). |
-| [`CONSTITUENTA.md`](CONSTITUENTA.md) | You are upserting constituents — fields, `cstType` table, validation rules, recommended order. |
-| [`SYNTAX.md`](SYNTAX.md) | You are constructing RSLang expressions — operators, quantifiers, parameterised functions, examples. |
-| [`TYPIFICATION.md`](TYPIFICATION.md) | You are interpreting `AnalysisResult.type` / `valueClass` or constructing template expressions with radicals. |
-| [`DIAGNOSTICS.md`](DIAGNOSTICS.md) | You received `analysis.diagnostics` and need to map error codes to fixes. |
-| [`PORTAL-API.md`](PORTAL-API.md) | You need to fetch an existing RSForm/OSS/RSModel from the live Portal REST API. |
-| [`GRAMMAR-REF.md`](GRAMMAR-REF.md) | You need a compact token / precedence table; the full grammar lives in `@rsconcept/domain`. |
+## Какой файл читать
 
-For the rstool agent contract itself (methods, types, stdio protocol) see [`../skills/rstool-helper/REFERENCE.md`](../skills/rstool-helper/REFERENCE.md).
+- **DOMAIN.md** — термины Portal: конституента, концептуальная схема/модель, ОСС, синтез.
+- **CONCEPTUAL-SCHEMA.md** — проектирование и ревью концептуальных схем.
+- **CONSTITUENTA.md** — структура и правила конституент.
+- **SYNTAX.md** — операторы, кванторы, функции и примеры выражений.
+- **TYPIFICATION.md** — типизация (`AnalysisResult.type`, `valueClass`).
+- **MODEL-TESTING.md** — проверка семантики определений на маленьких концептуальных моделях.
+- **DIAGNOSTICS.md** — диагностики анализа и способы исправления ошибок.
+- **PORTAL-API.md** — объекты REST API Portal.
+- **GRAMMAR-REF.md** — краткая карта токенов и приоритетов.
+
+Контракт агента `rstool` см. в `../skills/rstool-helper/REFERENCE.md`.

package/docs/SYNTAX.md

@@ -1,139 +1,84 @@
-# RSLang syntax reference
+# Синтаксис RSLang
 
-Use this when constructing or repairing RSLang expressions. For full grammar tokens see `GRAMMAR-REF.md`. For typification rules see `TYPIFICATION.md`.
+Читай, когда строишь или исправляешь `definitionFormal`. Токены и приоритеты — в `GRAMMAR-REF.md`, типизация — в `TYPIFICATION.md`.
 
-## Identifier rules
+## Имена и литералы
 
-- **Globals** (concept aliases): uppercase Latin letter + digits — `X1`, `C2`, `S3`, `D11`, `F7`, `P4`, `A6`, `T9`, `N12`. The leading letter must match the constituent's role.
-- **Radicals**: identifiers starting with `R` — used inside template parameterised expressions to denote arbitrary typifications (`R1`, `R2`).
-- **Locals** (bound variables): lowercase Latin or Greek letter, optionally with digits — `x`, `ξ`, `μ2`, `y1`.
-- **Special identifiers** — reserved tokens (`Z`, `∅`, operators).
+- Глобальные алиасы: `X1`, `C2`, `S3`, `D11`, `F7`, `P4`, `A6`, `T9`; буква совпадает с ролью.
+- Радикалы: `R1`, `R2` — шаблонные ступени в параметрах.
+- Локальные переменные: `x`, `ξ`, `μ2`, `y1`.
+- Целые: `0`, `42`; отрицательного литерала нет, пиши `0 - 5`.
+- `Z` — множество целых, `∅` — пустое множество с типизацией `ℬ(R0)`.
 
-## Literals
+## Теоретико-множественные выражения (STE)
 
-- **Integers**: digit sequence, no negative literal: `0`, `42`. Negation is a binary subtraction `0 - n`.
-- **Integer set**: `Z`.
-- **Empty set**: `∅` (typification `ℬ(R0)` — set of arbitrary element structure).
+- `D1 ∪ D2`, `D1 ∩ D2`, `D1 \ D2`, `D1 ∆ D2` — операции над множествами.
+- `X1 × X2` — декартово произведение.
+- `ℬ(X1)` — булеан, множество всех подмножеств.
+- `(a, b, c)` — кортеж, арность минимум 2.
+- `{a, b, c}` — перечисление.
+- `bool(a)` — синглетон, `debool(S)` — извлечение единственного элемента.
+- `red(S)` — суммарное множество; `S` должно иметь ступень `ℬ(ℬ(H))`.
+- `pr1(tuple)` — малая проекция кортежа.
+- `Pr1(S)` — большая проекция множества кортежей.
+- `Fi1[D](S)` — фильтр по принадлежности выбранной проекции в `D`.
 
-## Set-theoretic expressions
+Мультииндексы разрешены: `pr1,3(...)`, `Pr2,4(S1)`, `Fi1,2[D1](S1)`.
 
-| Construct            | Syntax              | Notes                                           |
-| -------------------- | ------------------- | ----------------------------------------------- |
-| Union                | `D1 ∪ D2`           |                                                 |
-| Intersection         | `D1 ∩ D2`           |                                                 |
-| Difference           | `D1 \ D2`           |                                                 |
-| Symmetric difference | `D1 ∆ D2`           |                                                 |
-| Cartesian product    | `X1 × X2`           | typification: tuple                             |
-| Boolean / power set  | `ℬ(X1)`             | set of all subsets                              |
-| Tuple                | `(a, b, c)`         | ordered, n ≥ 2                                  |
-| Enumeration          | `{a, b, c}`         | unordered, n ≥ 1                                |
-| Singleton            | `bool(a)` ≡ `{a}`   |                                                 |
-| Desingleton          | `debool({a})` ≡ `a` | only for one-element sets                       |
-| Sum set              | `red(S1)`           | union of inner sets; `S1` must be a set of sets |
-| Small projection     | `pr1((a1, …, an))`  | returns `a1`                                    |
-| Large projection     | `Pr1(S1)`           | set of first components of tuples in `S1`       |
-| Filter               | `Fi1[D1](S1)`       | subset of `S1` whose first projection ∈ `D1`    |
+## Логические выражения (LE)
 
-Indices `1` may be any natural number or comma-separated multi-index (`pr1,3((a1, a2, a3, a4)) = (a1, a3)`, `Fi1,2[D1](S1)`).
+- Предикаты множеств: `ξ ∈ S`, `ξ ∉ S`, `S1 = S2`, `S1 ≠ S2`, `S1 ⊆ S2`, `S1 ⊂ S2`, `S1 ⊄ S2`.
+- Арифметические предикаты: `=`, `≠`, `<`, `≤`, `>`, `≥` над `Z`.
+- Связки: `¬A`, `A & B`, `A ∨ B`, `A ⇒ B`, `A ⇔ B`.
 
-## Logical expressions
+`TRUE` и `FALSE` в экспликации КС не используют.
 
-### Set-theoretic predicates
+## Кванторы
 
-| Predicate        | Syntax    |
-| ---------------- | --------- |
-| Membership       | `ξ ∈ S`   |
-| Non-membership   | `ξ ∉ S`   |
-| Set equality     | `S1 = S2` |
-| Set inequality   | `S1 ≠ S2` |
-| Inclusion        | `S1 ⊆ S2` |
-| Strict inclusion | `S1 ⊂ S2` |
-| Non-inclusion    | `S1 ⊄ S2` |
+- `∀ξ∈D1 (LE(ξ))` — всеобщность.
+- `∃ξ∈D1 (LE(ξ))` — существование.
+- `∀(ξ1, ξ2)∈S1 (LE(ξ1, ξ2))` — объявление кортежа.
+- `∀ξ1, ξ2∈D1 (LE(ξ1, ξ2))` — сокращение вложенных кванторов.
 
-### Arithmetic predicates (typification `Logic`)
+Скобки вокруг `LE` можно опустить для атомарного логического выражения.
 
-`a = b`, `a ≠ b`, `a < b`, `a ≤ b`, `a > b`, `a ≥ b`.
+## Арифметика
 
-### Connectives
+`a + b`, `a - b`, `a * b` дают `Z`. `card(S)` возвращает мощность конечного множества.
 
-| Connective  | Syntax  |
-| ----------- | ------- |
-| Negation    | `¬A`    |
-| Conjunction | `A & B` |
-| Disjunction | `A ∨ B` |
-| Implication | `A ⇒ B` |
-| Equivalence | `A ⇔ B` |
+## Параметризованные выражения
 
-The constants `TRUE` and `FALSE` are **not** used inside schema explications.
-
-## Quantifiers
-
-| Form          | Syntax                       |
-| ------------- | ---------------------------- |
-| Universal     | `∀ξ∈STE (LE(ξ))`             |
-| Existential   | `∃ξ∈STE (LE(ξ))`             |
-| Tuple binding | `∀(ξ1, ξ2)∈STE (LE(ξ1, ξ2))` |
-| Variable list | `∀ξ1, ξ2 ∈ STE (LE(ξ1, ξ2))` |
-
-Parentheses around `LE` may be omitted for atomic logical expressions.
-
-## Arithmetic
-
-Operations `a + b`, `a - b`, `a * b` form set-theoretic expressions with typification `Z`. Negative numbers are computed, never literal.
-
-`card(S)` returns the integer cardinality of `S` (always finite in practice).
-
-## Parameterised expressions
-
-### Term-function declaration
-
-```
+```text
 F1 ::= [α1∈STE1, α2∈STE2(α1)] STE(α1, α2)
-```
-
-- Inside `[]` is an ordered list of parameter declarations separated by commas.
-- A parameter is declared with `∈`: `local_var ∈ domain`.
-- A declared variable can appear in subsequent parameter domains and in the result STE.
-
-### Predicate-function declaration
-
-```
 P1 ::= [α1∈STE1, α2∈STE2(α1)] LE(α1, α2)
 ```
 
-The only difference from a term-function is that the body is a logical expression.
+- В `[]` идут параметры через `∈`.
+- Параметр доступен в следующих доменах и теле.
+- Вызов позиционный: `F1[ξ1, S1]`, `P1[ξ1\ξ2, ξ3]`.
+- `F#` возвращает теоретико-множественное выражение, `P#` — логическое.
 
-### Calling parameterised functions
+## Радикалы
 
-`F1[ξ1, S1]`, `P1[ξ1\ξ2, ξ3]` — arguments are positional and listed in square brackets after the function name. Argument typifications are checked against parameter typifications. Result is an STE (term-function) or LE (predicate-function).
-
-### Template expressions
-
-Functions that use radicals as parameter typifications are templates:
-
-```
+```text
 F2 ::= [α1∈R1×R2, α2∈R1] α2 = pr1(α1)
 ```
 
-- Radical values are **inferred** from the call-site argument typifications. All inferred values for the same radical index must agree.
-- Different radical indices are independent.
-- Radicals may only appear in parameter domains — never in the result expression.
+- `R#` выводится по типизациям аргументов в месте вызова.
+- Все вхождения одного `R#` должны совпасть.
+- Радикалы допустимы только в доменах параметров.
 
-## Examples
+## Примеры
 
 - `¬α ∈ S1`
-- `D1 ∈ S1 ⇒ 2 + 2 = 5`
 - `D1 ⊆ D2 ⇔ ∀x∈D1 x∈D2`
 - `∀x∈D1 ∃y∈D2 (x, y)∈S1 & (x, x)∈S1`
 - `(4 + 5) * 3`, `card(X1) > 5`
-- `ℬ(2) = {{}, {1}, {2}, {1, 2}}`
 - `pr2((5, 4, 3, 2, 1)) = 4`
 - `red({{1, 2, 3}, {3, 4}}) = {1, 2, 3, 4}`
-- `Fi2[{2, 4}]({((1, 2), (3, 4), (5, 6))}) = {((1, 2), (3, 4))}`
 
-## Correctness model
+## Корректность
 
-- Expression checking happens in the **global context**: known typifications and bijective portability of every referenced identifier. Unknown identifiers are errors.
-- Set-theoretic rules follow from bijective portability of the membership predicate — an element must match the typification of the set it is tested against.
-- Logical consistency cannot generally be checked automatically. The existence of an interpretation example in a conceptual model is a basis for accepting consistency.
-- All formal definitions must be **bijectively portable**: values are independent of any bijective replacement of undefined-concept interpretations.
+- Анализ идет в глобальном контексте: все алиасы должны быть известны и типизированы.
+- Формальные определения должны быть биективно переносимыми (гарантируется семантическим анализатором).
+- Логическая непротиворечивость проверяется примером интерпретации в модели.

package/docs/TYPIFICATION.md

@@ -1,84 +1,65 @@
-# Typification reference
+# Типизация
 
-Distilled from `help-rslang-typification`, `help-rslang-expression-structure`, and `help-rslang-expression-parameter`. Agents must understand grades to interpret `AnalysisResult.type` and to construct correct expressions.
+Читай, когда разбираешь `AnalysisResult.type`, `valueClass` или радикалы.
 
-## Grades
+## Ступени
 
-A genus-structure expression `ξ` has typification (a _structure_) if `ξ ∈ H` holds, where `H` is a valid **grade**. Grades are built recursively:
+Выражение типизировано, если его значения принадлежат ступени `H`.
 
-| Grade            | Form                 | Notes                                |
-| ---------------- | -------------------- | ------------------------------------ |
-| Element          | `Xi`, `Ci`           | grade of a basic concept's elements  |
-| Integer          | `Z`                  | grade of integer                     |
-| Tuple of arity n | `(H1 × H2 × … × Hn)` | ordered structured grade             |
-| Set              | `ℬ(H)`               | unordered set of values of grade `H` |
+- `Xi`, `Ci` — элемент базисного или константного множества.
+- `Z` — целое число.
+- `(H1 × H2 × ... × Hn)` — кортеж.
+- `ℬ(H)` — множество значений ступени `H`.
 
-The empty set `∅` has typification `ℬ(R0)` — a set with arbitrary element structure. The radical `R0` ensures it conforms to any element grade in context.
+`∅` имеет типизацию `ℬ(R0)`: пустое множество подстраивается под контекст.
 
-## Extended typifications
+## Дополнительные типизации
 
-Beyond set-theoretic grades, RSLang uses two additional grade-like markers:
+- `Logic` — логические выражения: аксиомы, высказывания, тела предикат-функций.
+- `Hr <- [H1, H2, ..., Hi]` — параметризованная типизация функций: результат и аргументы.
 
-- **Logic** — typification of logical expressions (axioms, statements, predicate bodies) that evaluate to TRUE or FALSE.
-- **Parameterised** — typification of term-functions and predicate-functions:
+## Радикалы
 
-  ```
-  Hr 🠔 [H1, H2, …, Hi]
-  ```
+`R1`, `R2`, ... — шаблонные ступени.
 
-  where `Hr` is the result typification (an STE grade or `Logic`) and `H1 … Hi` are the argument typifications.
+- Значение `R#` выводится по аргументам в месте вызова.
+- Все вхождения одного `R#` должны дать одну ступень.
+- Разные `R#` независимы.
+- Радикалы можно писать только в доменах параметров; в теле результата будет `radicalUsage`.
 
-## Radicals
+## `AnalysisResult.type`
 
-Template parameterised expressions may contain notations `R1, R2, …` (and `R0` for `∅`). Each radical corresponds to an arbitrary grade that is **inferred** from the typifications of the arguments at the point of use.
+`type` приходит как JSON анализатора: `Record<string, unknown> | null`.
 
-- All occurrences of the same radical index must resolve to the same grade.
-- Radicals with different indices are independent.
-- Radicals may only appear in parameter domains, **not in the result expression**.
+Правила:
 
-## Encoded shape in `AnalysisResult.type`
+1. Сначала проверь `analysis.success === true` и `analysis.type !== null`.
+2. Не разбирай объект вручную; используй helpers из `@rsconcept/domain`.
+3. `valueClass` уточняет вычислимость: `Value`, `Property`, `Invalid`.
 
-The contract exposes `type: Record<string, unknown> | null` because typifications are JSON-encoded by the analyzer. Useful properties exposed by `@rsconcept/domain` helpers:
+Полезные API: `TypeID`, `TypePath`, `makeTypePath`, `parseTypeText(...)`.
 
-- `TypeID` enum: `Element`, `Integer`, `Tuple`, `Boolean`, `Logic`, `Functional` — discriminates the top-level shape.
-- `TypePath` (sequence of indices) addresses positions inside a tuple-of-sets-of-tuples structure; use `makeTypePath` to construct.
-- `parseTypeText(...)` parses an ASCII representation `B(X1)`, `(X1×X2)`, etc., into a `Typification`.
+## `S#` и `D#`
 
-For agents inspecting types from rstool output:
+- У `structure` (`S#`) `definitionFormal` читается как типизация. `ℬ(X1×X1)` описывает множество пар.
+- У `term` (`D#`) `definitionFormal` читается как определение. `X1×X1` строит декартов продукт.
 
-1. Check `analysis.success === true` and `analysis.type !== null`.
-2. Use `analysis.type` (object) only as opaque input to `@rsconcept/domain` helpers — do not pattern-match it manually.
-3. The `valueClass` companion indicates `Value`, `Property` (non-computable membership only), or `Invalid`.
+Для отношений предпочитай `S#` с `ℬ(X1×X1)` и конвенцией; выводимые понятия делай через `Pr*`, `Fi*`, фильтры и функции.
 
-## Typification on `S#` vs definition on `D#`
+## Операции
 
-- On a **`structure`** (`S#`), `definitionFormal` is read as **typification**. Subexpressions such as `X1×X1` describe **element shape** (here: one pair of base elements).
-- On a **`term`** (`D#`), the same token sequence is a **definition** evaluated in the model. `X1×X1` alone is the Cartesian product — all ordered pairs from `X1` — not the typification of a relation stored in `S#`.
+Создают ступень: `ℬ(H)`, `H1 × H2`, `(a, b)`, `{a, b}`, `bool(a)`.
 
-Prefer `S#` with `ℬ(X1×X1)` plus `convention` for relations; derive `D#` with `Pr*`, `Fi*`, filters, etc.
+Требуют подходящую ступень:
 
-## Forming structures vs. derived structures
+- `red(S)` — нужно `S : ℬ(ℬ(H))`.
+- `debool(S)` — нужно одноэлементное множество.
+- `pr1(tuple)`, `Pr1(S)` — нужна достаточная арность.
+- `Fi1[D](S)` — `D` должен соответствовать выбранной проекции.
 
-Forming operations build a new grade:
+## Частые ошибки
 
-- `ℬ(H)` — power set
-- `H1 × H2` — Cartesian product
-- `(a, b, c)` — tuple
-- `{a, b, c}` — enumeration
-- `bool(a)` — singleton
-
-Derived structures consume a grade:
-
-- `red(S)` — union of inner sets; requires `S : ℬ(ℬ(H))`
-- `debool({a})` — extracts the single element of a singleton
-- `pr1((a1, …, an))`, `Pr1(S)` — projections (multi-indices allowed: `pr1,3`, `Pr2,4`)
-- `Fi1[D](S)` — filters by membership in `D`; multi-index variants must match parameter arity
-
-## Common typification pitfalls
-
-- Negative integer literals do not exist — use `0 - n`.
-- `debool(S)` fails if `S` is not a singleton.
-- Tuple projections require the argument to be a tuple of sufficient arity; `pr3((a, b))` is an error.
-- Filter parameter list arity must match the multi-index in `Fi[...]`.
-- A radical in the **result expression** of a template is a hard error (`radicalUsage`).
-- An `axiom` or `statement` must have typification `Logic`; non-logical formal definitions raise `expectedLogic`.
+- `debool(S)` без гарантии синглетона.
+- `pr3((a, b))`: индекс вне арности.
+- `Fi1,2[D](S)`: параметр `D` не совпал с двумя проекциями.
+- `A#` и `T#` не имеют `Logic`: будет `expectedLogic`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsconcept/rstool",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "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

@@ -4,14 +4,12 @@ Each skill lives in its own subdirectory: `skills/<skill-name>/SKILL.md` (plus r
 
 ## Layout
 
-| Path | Role |
-| :--- | :--- |
-| `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 |
-| `../docs/*.md` | Language reference (DOMAIN, SYNTAX, DIAGNOSTICS, …) |
+- `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
+- `../docs/*.md`: language reference (DOMAIN, SYNTAX, DIAGNOSTICS, …)
 
 ## npm workflow