@rsconcept/rstool 1.7.1 → 1.9.0

package/skills/rstool-helper/GUIDE.md

@@ -18,7 +18,7 @@
 - Stdio/MCP: **плоские** `params` — поля метода и optional `sessionId` на одном уровне (без `params.input`).
 - Состояние: `getSessionState()` (summary) или `getSessionState('full')`.
 - Импорт/экспорт Portal: `importData`, `exportPortal({ kind })`.
-- Модель: `setModelValues`, `evaluate`, `recalculateModel`.
+- Модель: `setModelValues`, `evaluate`, `recalculateModel`. Статусы вычисления приходят числами (`EvalStatus`, см. REFERENCE).
 - Перед сохранением сомнительной формулы — `analyzeExpression`.
 
 ## Задача → чтение
@@ -31,9 +31,10 @@
 | Оценить / отревьюить готовую КС (без запроса «перепиши») | этот GUIDE → [ревью / оценка](#ревью--оценка-готовой-кс); [чеклист ревью](#ревью-концептуальной-схемы); [CONCEPTUAL-SCHEMA.md](../../docs/CONCEPTUAL-SCHEMA.md); при импорте — [PORTAL-API.md](../../docs/PORTAL-API.md)             | EXAMPLES с batch patch; полный SYNTAX    |
 | Точечные правки существующей схемы                       | этот GUIDE → [редактирование](#редактирование-и-проверка-схемы); [REFERENCE.md](REFERENCE.md) при вызовах                                                                                                                            | CONCEPTUAL-SCHEMA целиком                |
 | Починить формулу / диагностики                           | этот GUIDE → [цикл диагностик](#цикл-диагностик); [DIAGNOSTICS.md](../../docs/DIAGNOSTICS.md); [EXAMPLES.md](EXAMPLES.md) «типичные диагностики»                                                                                     | CONCEPTUAL-SCHEMA; PORTAL-API            |
+| Написать формулу; синтаксис `D{}`/`I{}`/`R{}`, `F#`/`P#` | [SYNTAX.md](../../docs/SYNTAX.md); при необходимости [EXAMPLES.md](EXAMPLES.md)                                                                                                                                                      | CONSTRUCTIONS; воркфлоу сессий           |
+| Объяснить формулу или конструкцию человеку               | [CONSTRUCTIONS.md](../../docs/CONSTRUCTIONS.md)                                                                                                                                                                                      | SYNTAX целиком; воркфлоу сессий          |
 | Импорт / правка по ссылке Portal                         | этот GUIDE → [Portal](#оценка-или-правка-кс-из-portal); [PORTAL-API.md](../../docs/PORTAL-API.md)                                                                                                                                    | SYNTAX; BASE-SELECTION                   |
 | Проверить смысл на данных / КМ                           | этот GUIDE → [КМ](#проверка-на-маленькой-км); [MODEL-TESTING.md](../../docs/MODEL-TESTING.md)                                                                                                                                        | DOMAIN/ОСС; CONCEPTUAL-SCHEMA            |
-| Объяснить синтаксис / генераторы / `F#`/`P#`             | [SYNTAX.md](../../docs/SYNTAX.md); при необходимости [EXAMPLES.md](EXAMPLES.md)                                                                                                                                                      | воркфлоу сессий                          |
 | Разобрать типизацию / ступени                            | [TYPIFICATION.md](../../docs/TYPIFICATION.md)                                                                                                                                                                                        | PORTAL-API                               |
 | Вызовы API / stdio / MCP                                 | [REFERENCE.md](REFERENCE.md)                                                                                                                                                                                                         | docs языка                               |
 | Термины КС, ядро/тело, не путать ярлыки                  | [DOMAIN.md](../../docs/DOMAIN.md)                                                                                                                                                                                                    | —                                        |
@@ -56,10 +57,28 @@
 Из корня workspace Portal (после `pnpm install` и сборки `@rsconcept/domain`):
 
 ```bash
-pnpm --filter @rsconcept/rstool exec tsx path/to/your/build-schema.ts
+pnpm --filter @rsconcept/rstool exec tsx C:/path/to/review.mts
 ```
 
-В скрипте импортируй API пакета (`@rsconcept/rstool` или относительный путь к `rsconcept/rstool/src` только если скрипт лежит вне пакета и это осознанный выбор). Либо используй stdio/MCP без отдельного файла.
+Правила для скрипта **вне** `rsconcept/rstool/`:
+
+- `import … from '@rsconcept/rstool'` из такого файла **не резолвится** — пакет не поднят в корневой `node_modules`. Импортируй по абсолютному `file://` URL: `file:///<workspace>/rsconcept/rstool/src/index.ts` (или `…/dist/index.js`). На Windows абсолютный путь без `file://` тоже падает (`ERR_UNSUPPORTED_ESM_URL_SCHEME`).
+- Расширение **`.mts`**: `.ts` вне пакета трактуется как CommonJS, а `@rsconcept/*` экспортируют только ESM (`ERR_PACKAGE_PATH_NOT_EXPORTED`).
+- Helpers domain — тем же способом: `file:///…/rsconcept/domain/src/index.ts` (`TUPLE_ID`), `…/domain/src/rslang/labels.ts` (`labelType`).
+- Вывод в файл с `-Encoding utf8` (PowerShell) — в консоли cp1251 символы ЯРЭ ломаются.
+
+```ts
+import { readFileSync } from 'node:fs';
+// <workspace> — абсолютный путь к корню Portal, например D:/work/Portal или /home/me/Portal
+import { RSToolAgent } from 'file:///<workspace>/rsconcept/rstool/src/index.ts';
+import { TUPLE_ID } from 'file:///<workspace>/rsconcept/domain/src/index.ts';
+
+const tool = new RSToolAgent();
+tool.importData(readFileSync('C:/tmp/details.json', 'utf-8'));
+console.log(tool.listDiagnostics());
+```
+
+Альтернатива без резолвинга — stdio-обёртка из собранного `dist`: `RSToolWrapperClient({ command: 'node', args: ['<abs>/rsconcept/rstool/dist/wrapper/stdio-wrapper.js'], cwd: '<abs>/rsconcept/rstool' })`. Внутри пакета (тесты, штатные `examples/`) обычный `@rsconcept/rstool` работает.
 
 ## Что читать
 
@@ -72,6 +91,7 @@ pnpm --filter @rsconcept/rstool exec tsx path/to/your/build-schema.ts
 - Концептуализация, создание схемы: [../../docs/CONCEPTUAL-SCHEMA.md](../../docs/CONCEPTUAL-SCHEMA.md).
 - Конституенты и валидация: [../../docs/CONSTITUENTA.md](../../docs/CONSTITUENTA.md).
 - Синтаксис ЯРЭ: [../../docs/SYNTAX.md](../../docs/SYNTAX.md).
+- Объяснение формул и конструкций: [../../docs/CONSTRUCTIONS.md](../../docs/CONSTRUCTIONS.md).
 - Типизация: [../../docs/TYPIFICATION.md](../../docs/TYPIFICATION.md).
 - Проверка определений на КМ: [../../docs/MODEL-TESTING.md](../../docs/MODEL-TESTING.md).
 - Диагностики: [../../docs/DIAGNOSTICS.md](../../docs/DIAGNOSTICS.md).
@@ -130,19 +150,20 @@ kind `auto` (default) определит `portal-details` или `portal-schema`
 **Правило:** без явного запроса на правку не делай массовый рефакторинг и не заменяй схему «улучшенной версией». Сначала отчёт; правки — только по согласованию или если пользователь сразу сказал «исправь».
 
 1. Загрузи схему: текущая сессия, `importData`, или Portal → [PORTAL-API.md](../../docs/PORTAL-API.md).
-2. `listDiagnostics()` — раздели `expression` / `schema` / `model`; зафиксируй ошибки и предупреждения.
-3. `getSessionState('summary')` — обзор состава; при необходимости `full` для формул.
+2. `listDiagnostics()` — раздели `expression` / `schema` / `model`; зафиксируй ошибки и предупреждения. `analysisSuccess: true` в summary **не** означает отсутствие диагностик (например, `invalidPropertyUsage` даёт `error` при успешном разборе) — опирайся на `listDiagnostics`.
+3. `getSessionState('summary')` — обзор состава; при необходимости `full` для формул. Типизацию из `analysis.type` печатай через `labelType` ([TYPIFICATION.md](../../docs/TYPIFICATION.md)), а не разбирай AST вручную.
 4. Структурный проход по [чеклисту ревью](#ревью-концептуальной-схемы) и [CONCEPTUAL-SCHEMA.md](../../docs/CONCEPTUAL-SCHEMA.md):
    - неопределяемые vs производные (`S#` там, где должно быть `D#`/`F#`/`P#`);
    - `X#` / `C#` / `Z` ([BASE-SELECTION.md](../../docs/BASE-SELECTION.md));
    - терм-функции vs множества пар;
    - радикалы `R#` не объявлены конституентами;
    - покрытие задачи vs избыточность.
-5. Severity в отчёте:
-   - **блокер** — диагностики `error`, схема не анализируется / ломает вычисление;
-   - **важно** — нарушение правил проектирования (лишнее `S#`, график вместо `F#`, смешение экспликаций);
-   - **замечание** — стиль, именование, возможные упрощения, пробелы покрытия.
-6. Ответ — по [шаблону ревью](#шаблон-ответа-ревью). Предлагай конкретные правки списком; применяй их только по запросу.
+5. Severity в отчёте — по **смыслу** диагностики, а не только по полю `severity` (инструмент помечает `error` и метаданные):
+   - **блокер** — `expression` с `severity: error` (формула не разбирается, невычислима: `invalidPropertyUsage`, …), `schemaDependencyCycle`, `schemaFormalDuplicate`, `schemaHomonym`; схема не анализируется / ломает вычисление;
+   - **важно** — нарушение правил проектирования (лишнее `S#`, график вместо `F#`, смешение экспликаций, перекрёстные ссылки `C#`, термин сильнее формулы);
+   - **замечание** — `schemaMissingConvention`, `schemaMissingTerm`, `modelEmpty` у структур, не задействованных в проверке; стиль, именование, упрощения, пробелы покрытия.
+6. Проверь на маленькой КМ ключевые производные и аксиомы ([цикл КМ](#проверка-на-маленькой-км)): позитивный набор данных → ожидаемые значения, негативный → `AXIOM_FALSE`. Это чаще всего даёт главные находки (расхождение термина и формулы, лишние/пропущенные элементы).
+7. Ответ — по [шаблону ревью](#шаблон-ответа-ревью). Предлагай конкретные правки списком; применяй их только по запросу.
 
 ### Цикл диагностик
 
@@ -160,12 +181,14 @@ kind `auto` (default) определит `portal-details` или `portal-schema`
 
 Когда синтаксис верен, но смысл формулы неочевиден. Подробности и форма данных — [MODEL-TESTING.md](../../docs/MODEL-TESTING.md).
 
-1. Отдельная `createSession` или изолированная копия текущей сессии.
+1. Отдельная `createSession` или изолированная копия текущей сессии (для ревью схемы из Portal достаточно самой импортированной сессии).
 2. Только нужные поставщики: `X#`, `C#`, `S#` и проверяемые `D#` / `F#` / `P#` / `A#`.
 3. `analyzeExpression` и `applySchemaPatch`.
-4. Значения: `setModelValues`.
-5. `evaluate`; сравни с ожидаемым `value`.
-6. При нескольких зависимых определениях — `recalculateModel`.
+4. Значения: `setModelValues`. `X#` — `{ 0: 'a', 1: 'b' }` (индекс → подпись), `S#` — массив кортежей `[TUPLE_ID, i, j]` по индексам `X#`; порядок элементов не важен, значения приводятся к канонической форме автоматически.
+5. `evaluate({ constituentId })` для конституенты; `evaluate({ expression, cstType })` для scratch-выражения — `cstType` задаёт ожидаемую ступень: множества и числа — `'term'`, логические выражения (`P1[S1]`, `D2⊆S1`) — `'axiom'`. В scratch можно ссылаться на любые конституенты схемы, включая `D#` — зависимости вычисляются автоматически.
+6. `status` в ответе — **число** (`EvalStatus`): `7` `HAS_DATA`, `6` `EMPTY`, `5` `AXIOM_FALSE`, `4` `EVAL_FAIL`, `3` `INVALID_DATA`, `1` `NO_EVAL`; полный список — [REFERENCE.md](REFERENCE.md). Сравни `value` с ожидаемым.
+7. При нескольких зависимых определениях — `recalculateModel`.
+8. Для аксиом — два набора данных: корректный (истина) и нарушающий (`AXIOM_FALSE`).
 
 Для регрессий вынеси проверку в скрипт или colocated `*.test.ts` (см. [MODEL-TESTING.md](../../docs/MODEL-TESTING.md)).
 
@@ -194,8 +217,8 @@ kind `auto` (default) определит `portal-details` или `portal-schema`
 2. **Диагностики:** число ошибок / предупреждений по `expression` / `schema` / `model` (без полного JSON).
 3. **Находки** списком: блокер → важно → замечание; у каждой — имя конституенты и суть.
 4. **Покрытие:** что из задачи отражено; чего не хватает.
-5. **Рекомендации:** конкретные правки; не применяй их без запроса.
-6. **Проверки:** что уже сделано (import, listDiagnostics, выборочный анализ).
+5. **Рекомендации:** конкретные правки; не применяй их без запроса. Предложенную замену формулы прогони через анализ выражения (и по возможности через КМ) до того, как её советовать.
+6. **Проверки:** что уже сделано (импорт, диагностики, выборочный анализ) и **КМ**: данные → ожидание → результат для проверенных конституент.
 
 ### Шаблон ответа: диагностики
 
@@ -206,10 +229,14 @@ kind `auto` (default) определит `portal-details` или `portal-schema`
 
 ### Шаблон ответа: объяснение формулы
 
+Полный сценарий и карточки конструкций — [CONSTRUCTIONS.md](../../docs/CONSTRUCTIONS.md). Кратко:
+
 - роль конституенты и термин;
 - формула как есть;
-- по шагам: что вычисляется / утверждается;
-- на какие понятия опирается; типизация.
+- ТМВ или ЛВ;
+- снаружи внутрь, только конструкции из формулы;
+- ступень и опоры;
+- вычисление на данных — только по запросу.
 
 ### Язык ответа
 

package/skills/rstool-helper/REFERENCE.md

@@ -114,7 +114,9 @@ tool.listDiagnostics({ kind: 'expression' });
 tool.listDiagnostics({ kind: 'schema', constituentId: 3, severity: 'error' });
 ```
 
-Фильтры: `kind?: 'expression' | 'schema' | 'model'`, `constituentId?`, `severity?: 'error' | 'warning'`.
+Фильтры: `kind?: 'expression' | 'schema' | 'model'`, `constituentId?`, `severity?: 'error' | 'warning'`. В stdio / MCP те же поля передаются **плоско** в `params` (`{ "kind": "schema", "severity": "warning" }`); stdio дополнительно принимает устаревший вложенный `filters`.
+
+`severity` отражает правило инструмента, а не вес для ревью: `schemaMissingConvention` / `schemaMissingTerm` приходят как `error`. Как ранжировать в отчёте — [GUIDE.md](GUIDE.md), «Ревью / оценка готовой КС».
 
 Элемент диагностики (агентский вид): `kind`, `code`, `name`, `severity`, `alias?`, `expression`, `from`, `to`, `params?`, `stack?` (цепочка вызовов при ошибке внутри `F#`/`P#`). Ключ для поиска исправления — `name` ([DIAGNOSTICS.md](../../docs/DIAGNOSTICS.md)).
 
@@ -132,6 +134,8 @@ tool.analyzeExpression({
 
 **Результат:** `{ success, type, valueClass, diagnostics }`. Не сохраняет конституенту. Для черновика формулы — до `applySchemaPatch`.
 
+`type` — AST типизации; для чтения используй `labelType` из `@rsconcept/domain/rslang/labels` (`ℬ(X1×X1)`, `[X1] → ℬ(X1)`, `Logic`). `success: true` совместим с диагностикой `error` (например, `invalidPropertyUsage` при `valueClass: null`) — проверяй `diagnostics`.
+
 ## `evaluate`
 
 Ровно один вариант входа:
@@ -141,7 +145,19 @@ tool.analyzeExpression({
 
 **Результат:** `{ success, value, status, iterations, cacheHits, diagnostics }`.
 
-`status` — статус вычисления КМ (`HAS_DATA`, `EMPTY`, `AXIOM_FALSE`, `EVAL_FAIL`, … — [DOMAIN.md](../../docs/DOMAIN.md)).
+`status` — статус вычисления КМ, **числовой** код `EvalStatus` (`@rsconcept/domain`); смысл — [DOMAIN.md](../../docs/DOMAIN.md):
+
+| Код | Имя             | Смысл                                   |
+| --: | --------------- | --------------------------------------- |
+| `1` | `NO_EVAL`       | не вычисляется (`X#`, `C#`, `F#`, `P#`) |
+| `2` | `NOT_PROCESSED` | вычисление не запускалось               |
+| `3` | `INVALID_DATA`  | неверная интерпретация                  |
+| `4` | `EVAL_FAIL`     | ошибка вычисления                       |
+| `5` | `AXIOM_FALSE`   | аксиома ложна                           |
+| `6` | `EMPTY`         | результат пуст                          |
+| `7` | `HAS_DATA`      | вычислено, непусто                      |
+
+Scratch-выражение: `cstType` задаёт ожидаемую ступень (`term` — множество / число, `axiom` — логическое). Ссылки на `D#` / `A#` / `T#` внутри scratch допустимы — их значения (и зависимости через `F#` / `P#`) вычисляются перед оценкой.
 
 ## `setModelValues` / `getModelState` / `recalculateModel`
 
@@ -155,8 +171,9 @@ await tool.setModelValues({
 - `set[]`: `{ target, value, type? }` — `target` = id конституенты; `type` обычно не нужен.
 - `clear[]`: id для сброса значений.
 - Метод **async**. После изменения данных пересчитываются диагностики модели.
+- Значения `S#` приводятся к канонической форме (сортировка, без дубликатов) — порядок элементов во входе не важен; в `getModelState` хранится уже нормализованное значение.
 - `getModelState()` → `{ items: [{ id, type, value }] }`.
-- `recalculateModel()` → `{ items: [{ id, alias, value, status }] }`.
+- `recalculateModel()` → `{ items: [{ id, alias, value, status }] }` (`status` — числовой `EvalStatus`, таблица выше).
 
 Формы `value` для `X#` / `S#` — [MODEL-TESTING.md](../../docs/MODEL-TESTING.md).
 
@@ -237,6 +254,7 @@ JSON-строка сессии для последующего `importData(...,
 {"id":"9","method":"exportPortal","params":{"kind":"schema"}}
 {"id":"10","method":"importData","params":{"payload":"..."}}
 {"id":"11","method":"getSessionState","params":{"detail":"summary"}}
+{"id":"12","method":"listDiagnostics","params":{"kind":"expression","severity":"error"}}
 ```
 
 ## Help map: ошибка → документ
@@ -245,6 +263,7 @@ JSON-строка сессии для последующего `importData(...,
 | -------------------------------------------------- | ------------------------------------------------------- |
 | Код / `name` диагностики                           | [DIAGNOSTICS.md](../../docs/DIAGNOSTICS.md)             |
 | Синтаксис операторов, `D{}`/`I{}`/`R{}`, `F#`/`P#` | [SYNTAX.md](../../docs/SYNTAX.md)                       |
+| Объяснить формулу / конструкцию человеку           | [CONSTRUCTIONS.md](../../docs/CONSTRUCTIONS.md)         |
 | Ступени, `AnalysisResult.type`                     | [TYPIFICATION.md](../../docs/TYPIFICATION.md)           |
 | `X#` vs `C#` vs `Z`, переносимость                 | [BASE-SELECTION.md](../../docs/BASE-SELECTION.md)       |
 | Проектирование, `F#` vs пары, ревью                | [CONCEPTUAL-SCHEMA.md](../../docs/CONCEPTUAL-SCHEMA.md) |

package/skills/rstool-helper/SKILL.md

@@ -2,8 +2,9 @@
 name: rstool-helper
 description: >-
   ЯРЭ и концептуальные схемы через rstool: концептуализация, ревью/оценка КС,
-  правки и диагностики формул, проверка на КМ (evaluate), выбор X#/C#/Z,
-  импорт/экспорт Portal (/rsforms, /details). Читай GUIDE и docs из node_modules.
+  правки и диагностики формул, объяснение конструкций ЯРЭ, проверка на КМ (evaluate),
+  выбор X#/C#/Z, импорт/экспорт Portal (/rsforms, /details).
+  Читай GUIDE и docs из node_modules.
 ---
 
 # rstool-helper
@@ -39,9 +40,11 @@ description: >-
 | Собрать / развить КС из текста    | GUIDE: концептуализация; `docs/CONCEPTUAL-SCHEMA.md`; `docs/BASE-SELECTION.md` |
 | Оценить / отревьюить готовую КС   | GUIDE: ревью; чеклист ревью; `docs/CONCEPTUAL-SCHEMA.md`                       |
 | Починить формулу / диагностики    | GUIDE: цикл диагностик; `docs/DIAGNOSTICS.md`                                  |
+| Написать формулу / синтаксис      | `docs/SYNTAX.md`                                                               |
+| Объяснить формулу / конструкцию   | `docs/CONSTRUCTIONS.md`                                                        |
 | Импорт / правка по ссылке Portal  | GUIDE: Portal; `docs/PORTAL-API.md`                                            |
 | Проверить смысл на данных         | GUIDE: КМ; `docs/MODEL-TESTING.md`                                             |
-| Синтаксис / типизация / вызов API | `docs/SYNTAX.md` / `TYPIFICATION.md` / `REFERENCE.md`                          |
+| Типизация / вызов API             | `docs/TYPIFICATION.md` / `REFERENCE.md`                                        |
 
 Перед работой всегда открой **GUIDE.md**; остальное — по строке таблицы.
 

package/src/mappers/model-adapter.ts

@@ -1,5 +1,7 @@
 import { DiagnosticKind, expressionDiagnostic } from './diagnostic-assembly';
 import { type RSErrorDescription, type Value } from '@rsconcept/domain/rslang';
+import { extractGlobals } from '@rsconcept/domain/rslang/api';
+import { normalizeValue } from '@rsconcept/domain/rslang/eval/value-api';
 import { isBaseSet } from '@rsconcept/domain/library/rsform-api';
 import { CstType, type RSForm } from '@rsconcept/domain/library/rsform';
 import { RSEngine, type RSEngineServices } from '@rsconcept/domain/library/rsengine';
@@ -37,7 +39,11 @@ export class ModelAdapter {
       const binding = toBasicBinding(input.value as Record<string | number, string>);
       await engine.setBasicValue(input.target, binding);
     } else {
-      await engine.setStructureValue(input.target, input.value as Value);
+      // Set operations in the evaluator assume canonical form (sorted, deduplicated);
+      // agents may pass elements in arbitrary order.
+      const value = structuredClone(input.value) as Value;
+      normalizeValue(value);
+      await engine.setStructureValue(input.target, value);
     }
     session.updatedAt = new Date().toISOString();
     return structuredClone(session.model);
@@ -64,6 +70,7 @@ export class ModelAdapter {
 
   public evaluateExpression(session: SessionState, expression: string, cstType: CstType): EvaluationResult {
     const engine = this.createEngine(session);
+    this.prepareReferencedValues(engine, session, expression);
     const result = engine.evaluateExpression(expression, cstType);
     const status =
       result.value === null
@@ -120,6 +127,32 @@ export class ModelAdapter {
     return engine;
   }
 
+  /**
+   * Computes values of inferrable constituents referenced by a scratch expression (directly or
+   * through `F#` / `P#` bodies). A fresh engine only holds interpreted `X#` / `C#` / `S#` values.
+   */
+  private prepareReferencedValues(engine: RSEngine, session: SessionState, expression: string): void {
+    const schema = engine.schema;
+    if (!schema) {
+      return;
+    }
+    const globals = extractGlobals(expression);
+    const referenced = session.items.filter(item => globals.has(item.alias)).map(item => item.id);
+    if (referenced.length === 0) {
+      return;
+    }
+    const required = new Set([...referenced, ...schema.graph.expandAllInputs(referenced)]);
+    for (const cstID of schema.graph.topologicalOrder()) {
+      if (!required.has(cstID)) {
+        continue;
+      }
+      const cst = schema.cstByID.get(cstID);
+      if (cst && isInferrable(cst.cst_type)) {
+        engine.calculateCst(cstID);
+      }
+    }
+  }
+
   private validateSetInput(session: SessionState, input: SetConstituentaValueInput): void {
     const cst = session.items.find(item => item.id === input.target);
     if (!cst) {

package/src/models/rstool-agent.test.ts

@@ -1029,6 +1029,101 @@ describe('RSToolAgent modeling semantics', () => {
     expect(modelIssues.some(record => record.code === RSDiagnosticCode.modelAxiomFalse)).toBe(true);
   });
 
+  function buildGraphScratch(tool: RSToolAgent, sessionId: string) {
+    tool.applySchemaPatch(
+      {
+        items: [
+          { alias: 'X1' },
+          { alias: 'S1', definitionFormal: 'ℬ(X1×X1)' },
+          { alias: 'D1', definitionFormal: 'Pr2,1(S1)' },
+          { alias: 'D2', definitionFormal: 'S1\\D1' },
+          { alias: 'F1', definitionFormal: '[α∈X1] Pr2(Fi1[{α}](D2))' }
+        ]
+      },
+      sessionId
+    );
+  }
+
+  it('normalizes unsorted structure values before evaluation', async () => {
+    const tool = new RSToolAgent();
+    const session = tool.createSession();
+    buildGraphScratch(tool, session.sessionId);
+
+    await tool.setModelValues(
+      {
+        set: [
+          { target: 1, value: { 0: 'a', 1: 'b', 2: 'c' } },
+          {
+            target: 2,
+            value: [
+              [TUPLE_ID, 1, 2],
+              [TUPLE_ID, 0, 2],
+              [TUPLE_ID, 0, 1],
+              [TUPLE_ID, 1, 0],
+              [TUPLE_ID, 0, 1]
+            ]
+          }
+        ]
+      },
+      session.sessionId
+    );
+
+    const stored = tool.getModelState(session.sessionId).items.find(item => item.id === 2);
+    expect(stored?.value).toEqual([
+      [TUPLE_ID, 0, 1],
+      [TUPLE_ID, 0, 2],
+      [TUPLE_ID, 1, 0],
+      [TUPLE_ID, 1, 2]
+    ]);
+
+    // S1 \ inverse(S1): (0,1) and (1,0) cancel out
+    const result = tool.evaluate({ constituentId: 4 }, session.sessionId);
+    expect(result.status).toBe(EvalStatus.HAS_DATA);
+    expect(result.value).toEqual([
+      [TUPLE_ID, 0, 2],
+      [TUPLE_ID, 1, 2]
+    ]);
+  });
+
+  it('evaluates scratch expressions that reference derived constituents', async () => {
+    const tool = new RSToolAgent();
+    const session = tool.createSession();
+    buildGraphScratch(tool, session.sessionId);
+    await tool.setModelValues(
+      {
+        set: [
+          { target: 1, value: { 0: 'a', 1: 'b', 2: 'c' } },
+          {
+            target: 2,
+            value: [
+              [TUPLE_ID, 0, 1],
+              [TUPLE_ID, 0, 2],
+              [TUPLE_ID, 1, 0],
+              [TUPLE_ID, 1, 2]
+            ]
+          }
+        ]
+      },
+      session.sessionId
+    );
+
+    const direct = tool.evaluate({ expression: 'card(D2)', cstType: CstType.TERM }, session.sessionId);
+    expect(direct.success).toBe(true);
+    expect(direct.value).toBe(2);
+
+    // F1 body references D2, which must be computed before the call
+    const viaFunction = tool.evaluate(
+      { expression: 'card(red(I{F1[ξ] | ξ:∈Pr1(D2)}))', cstType: CstType.TERM },
+      session.sessionId
+    );
+    expect(viaFunction.success).toBe(true);
+    expect(viaFunction.value).toBe(1);
+
+    const logic = tool.evaluate({ expression: 'D2⊆S1', cstType: CstType.AXIOM }, session.sessionId);
+    expect(logic.success).toBe(true);
+    expect(logic.value).toBe(1);
+  });
+
   it('throws when evaluate input is incomplete', () => {
     const tool = new RSToolAgent();
     const session = tool.createSession();

package/src/wrapper/client.test.ts

@@ -5,14 +5,53 @@ import { describe, expect, it } from 'vitest';
 import { CstType, EvalStatus, RSToolWrapperClient } from '../index';
 
 const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../..');
+const tsxCli = fileURLToPath(import.meta.resolve('tsx/cli'));
+const wrapperEntry = resolve(packageRoot, 'src/wrapper/stdio-wrapper.ts');
 
 describe('RSToolWrapperClient integration', () => {
+  it('rejects readiness and calls when the wrapper command cannot start', async () => {
+    const client = new RSToolWrapperClient({
+      command: resolve(packageRoot, 'definitely-missing-rstool-wrapper-binary'),
+      args: [],
+      cwd: packageRoot
+    });
+    try {
+      await expect(client.waitUntilReady()).rejects.toThrow(/ENOENT/);
+      await expect(client.call('methods')).rejects.toThrow(/ENOENT/);
+    } finally {
+      await client.close();
+    }
+  }, 30_000);
+
+  it('rejects outstanding calls when the wrapper exits before responding', async () => {
+    const client = new RSToolWrapperClient({
+      command: process.execPath,
+      args: ['-e', 'process.stdin.resume(); setTimeout(() => process.exit(3), 200)'],
+      cwd: packageRoot
+    });
+    try {
+      await expect(client.call('methods')).rejects.toThrow(/exited before responding \(code 3/);
+    } finally {
+      await client.close();
+    }
+  }, 30_000);
+
+  it('starts the default npm wrapper without a shell', async () => {
+    const client = new RSToolWrapperClient({ cwd: packageRoot });
+    try {
+      await client.waitUntilReady();
+      const methods = await client.call<string[]>('methods');
+      expect(methods).toContain('applySchemaPatch');
+    } finally {
+      await client.close();
+    }
+  }, 30_000);
+
   it('runs createSession, patch, model, and evaluate over stdio', async () => {
     const client = new RSToolWrapperClient({
-      command: 'npx',
-      args: ['tsx', resolve(packageRoot, 'src/wrapper/stdio-wrapper.ts')],
-      cwd: packageRoot,
-      shell: true
+      command: process.execPath,
+      args: [tsxCli, wrapperEntry],
+      cwd: packageRoot
     });
 
     try {