@rsconcept/rstool 0.2.1 → 0.4.0

package/dist/wrapper/stdio-wrapper.js.map

@@ -1 +1 @@
-{"version":3,"file":"stdio-wrapper.js","names":[],"sources":["../../src/wrapper/stdio-wrapper.ts"],"sourcesContent":["#!/usr/bin/env node\nimport readline from 'node:readline';\n\nimport { RSToolAgent } from '../models/rstool-agent';\n\ninterface StdioRequest {\n  id: string | number;\n  method: string;\n  params?: unknown;\n}\n\ninterface StdioResponse {\n  id: string | number | null;\n  ok: boolean;\n  result?: unknown;\n  error?: {\n    code: string;\n    message: string;\n    details?: unknown;\n  };\n}\n\nconst tool = new RSToolAgent();\n\nconst METHODS = [\n  'createSession',\n  'addOrUpdateConstituenta',\n  'analyzeExpression',\n  'getFormState',\n  'listDiagnostics',\n  'commitStep',\n  'exportSession',\n  'importSession',\n  'setConstituentaValue',\n  'setConstituentaValues',\n  'clearConstituentaValues',\n  'getModelState',\n  'evaluateExpression',\n  'evaluateConstituenta',\n  'recalculateModel'\n] as const;\n\nfunction writeResponse(response: StdioResponse): void {\n  if (!process.stdout.writable || process.stdout.destroyed || process.stdout.writableEnded) {\n    return;\n  }\n  try {\n    process.stdout.write(`${JSON.stringify(response)}\\n`);\n  } catch {\n    // The client might have already closed stdout (EPIPE). Safe to ignore.\n  }\n}\n\nfunction asObject(value: unknown): Record<string, unknown> {\n  if (!value || typeof value !== 'object' || Array.isArray(value)) {\n    return {};\n  }\n  return value as Record<string, unknown>;\n}\n\nfunction requiredString(input: Record<string, unknown>, key: string): string {\n  const value = input[key];\n  if (typeof value !== 'string' || value.length === 0) {\n    throw new Error(`Missing or invalid \"${key}\"`);\n  }\n  return value;\n}\n\nasync function handleRequest(request: StdioRequest): Promise<StdioResponse> {\n  try {\n    const params = asObject(request.params);\n    switch (request.method) {\n      case 'ping':\n        return { id: request.id, ok: true, result: { pong: true } };\n      case 'methods':\n        return { id: request.id, ok: true, result: METHODS };\n      case 'createSession':\n        return {\n          id: request.id,\n          ok: true,\n          result: tool.createSession(params.initial as never)\n        };\n      case 'addOrUpdateConstituenta':\n        return {\n          id: request.id,\n          ok: true,\n          result: tool.addOrUpdateConstituenta(requiredString(params, 'sessionId'), params.input as never)\n        };\n      case 'analyzeExpression':\n        return {\n          id: request.id,\n          ok: true,\n          result: tool.analyzeExpression(requiredString(params, 'sessionId'), params.input as never)\n        };\n      case 'getFormState':\n        return {\n          id: request.id,\n          ok: true,\n          result: tool.getFormState(requiredString(params, 'sessionId'))\n        };\n      case 'listDiagnostics':\n        return {\n          id: request.id,\n          ok: true,\n          result: tool.listDiagnostics(requiredString(params, 'sessionId'), params.filters as never)\n        };\n      case 'commitStep':\n        return {\n          id: request.id,\n          ok: true,\n          result: tool.commitStep(requiredString(params, 'sessionId'), params.message as string | undefined)\n        };\n      case 'exportSession':\n        return {\n          id: request.id,\n          ok: true,\n          result: tool.exportSession(requiredString(params, 'sessionId'))\n        };\n      case 'importSession':\n        return {\n          id: request.id,\n          ok: true,\n          result: tool.importSession(requiredString(params, 'payload'))\n        };\n      case 'setConstituentaValue':\n        return {\n          id: request.id,\n          ok: true,\n          result: await tool.setConstituentaValue(requiredString(params, 'sessionId'), params.input as never)\n        };\n      case 'setConstituentaValues':\n        return {\n          id: request.id,\n          ok: true,\n          result: await tool.setConstituentaValues(requiredString(params, 'sessionId'), params.input as never)\n        };\n      case 'clearConstituentaValues':\n        return {\n          id: request.id,\n          ok: true,\n          result: await tool.clearConstituentaValues(requiredString(params, 'sessionId'), params.input as never)\n        };\n      case 'getModelState':\n        return {\n          id: request.id,\n          ok: true,\n          result: tool.getModelState(requiredString(params, 'sessionId'))\n        };\n      case 'evaluateExpression':\n        return {\n          id: request.id,\n          ok: true,\n          result: tool.evaluateExpression(requiredString(params, 'sessionId'), params.input as never)\n        };\n      case 'evaluateConstituenta':\n        return {\n          id: request.id,\n          ok: true,\n          result: tool.evaluateConstituenta(requiredString(params, 'sessionId'), params.input as never)\n        };\n      case 'recalculateModel':\n        return {\n          id: request.id,\n          ok: true,\n          result: tool.recalculateModel(requiredString(params, 'sessionId'))\n        };\n      default:\n        return {\n          id: request.id ?? null,\n          ok: false,\n          error: {\n            code: 'METHOD_NOT_FOUND',\n            message: `Unknown method: ${request.method}`\n          }\n        };\n    }\n  } catch (error) {\n    return {\n      id: request.id ?? null,\n      ok: false,\n      error: {\n        code: 'INTERNAL_ERROR',\n        message: error instanceof Error ? error.message : 'Unknown error',\n        details: error\n      }\n    };\n  }\n}\n\nconst input = readline.createInterface({\n  input: process.stdin,\n  crlfDelay: Infinity\n});\n\nwriteResponse({\n  id: null,\n  ok: true,\n  result: {\n    ready: true,\n    wrapper: 'rstool-stdio',\n    contractVersion: tool.contractVersion\n  }\n});\n\ninput.on('line', line => {\n  if (!line.trim()) {\n    return;\n  }\n  try {\n    const request = JSON.parse(line) as StdioRequest;\n    if (!('id' in request) || !('method' in request)) {\n      throw new Error('Request must include \"id\" and \"method\"');\n    }\n    void handleRequest(request).then(writeResponse);\n  } catch (error) {\n    writeResponse({\n      id: null,\n      ok: false,\n      error: {\n        code: 'BAD_REQUEST',\n        message: error instanceof Error ? error.message : 'Invalid JSON'\n      }\n    });\n  }\n});\n"],"mappings":"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"}
+{"version":3,"file":"stdio-wrapper.js","names":[],"sources":["../../src/wrapper/stdio-wrapper.ts"],"sourcesContent":["#!/usr/bin/env node\nimport readline from 'node:readline';\n\nimport { RSToolAgent } from '../models/rstool-agent';\n\ninterface StdioRequest {\n  id: string | number;\n  method: string;\n  params?: unknown;\n}\n\ninterface StdioResponse {\n  id: string | number | null;\n  ok: boolean;\n  result?: unknown;\n  error?: {\n    code: string;\n    message: string;\n    details?: unknown;\n  };\n}\n\nconst tool = new RSToolAgent();\n\nconst METHODS = [\n  'createSession',\n  'addOrUpdateConstituenta',\n  'analyzeExpression',\n  'getFormState',\n  'listDiagnostics',\n  'commitStep',\n  'exportSession',\n  'exportPortalSchema',\n  'exportPortalModel',\n  'importSession',\n  'setConstituentaValue',\n  'setConstituentaValues',\n  'clearConstituentaValues',\n  'getModelState',\n  'evaluateExpression',\n  'evaluateConstituenta',\n  'recalculateModel'\n] as const;\n\nfunction writeResponse(response: StdioResponse): void {\n  if (!process.stdout.writable || process.stdout.destroyed || process.stdout.writableEnded) {\n    return;\n  }\n  try {\n    process.stdout.write(`${JSON.stringify(response)}\\n`);\n  } catch {\n    // The client might have already closed stdout (EPIPE). Safe to ignore.\n  }\n}\n\nfunction asObject(value: unknown): Record<string, unknown> {\n  if (!value || typeof value !== 'object' || Array.isArray(value)) {\n    return {};\n  }\n  return value as Record<string, unknown>;\n}\n\nfunction requiredString(input: Record<string, unknown>, key: string): string {\n  const value = input[key];\n  if (typeof value !== 'string' || value.length === 0) {\n    throw new Error(`Missing or invalid \"${key}\"`);\n  }\n  return value;\n}\n\nasync function handleRequest(request: StdioRequest): Promise<StdioResponse> {\n  try {\n    const params = asObject(request.params);\n    switch (request.method) {\n      case 'ping':\n        return { id: request.id, ok: true, result: { pong: true } };\n      case 'methods':\n        return { id: request.id, ok: true, result: METHODS };\n      case 'createSession':\n        return {\n          id: request.id,\n          ok: true,\n          result: tool.createSession(params.initial as never)\n        };\n      case 'addOrUpdateConstituenta':\n        return {\n          id: request.id,\n          ok: true,\n          result: tool.addOrUpdateConstituenta(requiredString(params, 'sessionId'), params.input as never)\n        };\n      case 'analyzeExpression':\n        return {\n          id: request.id,\n          ok: true,\n          result: tool.analyzeExpression(requiredString(params, 'sessionId'), params.input as never)\n        };\n      case 'getFormState':\n        return {\n          id: request.id,\n          ok: true,\n          result: tool.getFormState(requiredString(params, 'sessionId'))\n        };\n      case 'listDiagnostics':\n        return {\n          id: request.id,\n          ok: true,\n          result: tool.listDiagnostics(requiredString(params, 'sessionId'), params.filters as never)\n        };\n      case 'commitStep':\n        return {\n          id: request.id,\n          ok: true,\n          result: tool.commitStep(requiredString(params, 'sessionId'), params.message as string | undefined)\n        };\n      case 'exportSession':\n        return {\n          id: request.id,\n          ok: true,\n          result: tool.exportSession(requiredString(params, 'sessionId'))\n        };\n      case 'exportPortalSchema':\n        return {\n          id: request.id,\n          ok: true,\n          result: tool.exportPortalSchema(requiredString(params, 'sessionId'))\n        };\n      case 'exportPortalModel':\n        return {\n          id: request.id,\n          ok: true,\n          result: tool.exportPortalModel(requiredString(params, 'sessionId'))\n        };\n      case 'importSession':\n        return {\n          id: request.id,\n          ok: true,\n          result: tool.importSession(requiredString(params, 'payload'))\n        };\n      case 'setConstituentaValue':\n        return {\n          id: request.id,\n          ok: true,\n          result: await tool.setConstituentaValue(requiredString(params, 'sessionId'), params.input as never)\n        };\n      case 'setConstituentaValues':\n        return {\n          id: request.id,\n          ok: true,\n          result: await tool.setConstituentaValues(requiredString(params, 'sessionId'), params.input as never)\n        };\n      case 'clearConstituentaValues':\n        return {\n          id: request.id,\n          ok: true,\n          result: await tool.clearConstituentaValues(requiredString(params, 'sessionId'), params.input as never)\n        };\n      case 'getModelState':\n        return {\n          id: request.id,\n          ok: true,\n          result: tool.getModelState(requiredString(params, 'sessionId'))\n        };\n      case 'evaluateExpression':\n        return {\n          id: request.id,\n          ok: true,\n          result: tool.evaluateExpression(requiredString(params, 'sessionId'), params.input as never)\n        };\n      case 'evaluateConstituenta':\n        return {\n          id: request.id,\n          ok: true,\n          result: tool.evaluateConstituenta(requiredString(params, 'sessionId'), params.input as never)\n        };\n      case 'recalculateModel':\n        return {\n          id: request.id,\n          ok: true,\n          result: tool.recalculateModel(requiredString(params, 'sessionId'))\n        };\n      default:\n        return {\n          id: request.id ?? null,\n          ok: false,\n          error: {\n            code: 'METHOD_NOT_FOUND',\n            message: `Unknown method: ${request.method}`\n          }\n        };\n    }\n  } catch (error) {\n    return {\n      id: request.id ?? null,\n      ok: false,\n      error: {\n        code: 'INTERNAL_ERROR',\n        message: error instanceof Error ? error.message : 'Unknown error',\n        details: error\n      }\n    };\n  }\n}\n\nconst input = readline.createInterface({\n  input: process.stdin,\n  crlfDelay: Infinity\n});\n\nwriteResponse({\n  id: null,\n  ok: true,\n  result: {\n    ready: true,\n    wrapper: 'rstool-stdio',\n    contractVersion: tool.contractVersion\n  }\n});\n\ninput.on('line', line => {\n  if (!line.trim()) {\n    return;\n  }\n  try {\n    const request = JSON.parse(line) as StdioRequest;\n    if (!('id' in request) || !('method' in request)) {\n      throw new Error('Request must include \"id\" and \"method\"');\n    }\n    void handleRequest(request).then(writeResponse);\n  } catch (error) {\n    writeResponse({\n      id: null,\n      ok: false,\n      error: {\n        code: 'BAD_REQUEST',\n        message: error instanceof Error ? error.message : 'Invalid JSON'\n      }\n    });\n  }\n});\n"],"mappings":"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"}

package/docs/CONCEPTUAL-SCHEMA.md

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

package/docs/CONSTITUENTA.md

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