@rsconcept/rstool 1.7.1 → 2.0.0

package/skills/scripts/check-brief.ts

@@ -0,0 +1,94 @@
+/**
+ * CLI: check a session against its brief and print readiness.
+ *
+ * Usage (from the rstool package root):
+ *   tsx skills/scripts/check-brief.ts --session <session.json> --brief <brief.json> [--base <v1-session.json>] [--review] [--json]
+ *
+ * Exit code: 0 — no blockers, 1 — blockers, 2 — usage or input error.
+ */
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+import { type Brief, checkBrief, type BriefCheckResult } from './brief-check';
+
+function parseArgs(argv: string[]): Record<string, string | true> {
+  const args: Record<string, string | true> = {};
+  for (let i = 0; i < argv.length; i++) {
+    const key = argv[i];
+    if (!key.startsWith('--')) {
+      continue;
+    }
+    const next = argv[i + 1];
+    if (next === undefined || next.startsWith('--')) {
+      args[key.slice(2)] = true;
+    } else {
+      args[key.slice(2)] = next;
+      i++;
+    }
+  }
+  return args;
+}
+
+function readText(path: string): string {
+  return readFileSync(resolve(path), 'utf8').replace(/^/, '');
+}
+
+function printReport({ readiness, scenarios }: BriefCheckResult) {
+  const lines: string[] = [];
+  lines.push(`Этап: ${readiness.stage}${readiness.ready ? ' — блокеров нет' : ''}`);
+  lines.push(`Диагностики: ошибок ${readiness.diagnostics.errors}, предупреждений ${readiness.diagnostics.warnings}`);
+  lines.push(
+    `Покрытие: требования ${readiness.coverage.expressiveness}, инварианты ${readiness.coverage.invariants}, различения ${readiness.coverage.distinctions}`
+  );
+  lines.push(
+    `Сценарии: прошло ${readiness.scenarios.passed}, провалено ${readiness.scenarios.failed}, не хватает ${readiness.scenarios.missing}`
+  );
+  if (scenarios.length > 0) {
+    lines.push('', 'Матрица приёмки:');
+    for (const scenario of scenarios) {
+      lines.push(
+        `  ${scenario.passed ? '✓' : '✗'} ${scenario.id} ${scenario.title}${scenario.error ? ` — ${scenario.error}` : ''}`
+      );
+      for (const check of scenario.checks) {
+        lines.push(
+          `      ${check.passed ? '✓' : '✗'} ${check.target}: ожидалось ${check.expected}, получено ${check.actual}`
+        );
+      }
+    }
+  }
+  if (readiness.blockers.length > 0) {
+    lines.push('', 'Блокеры:', ...readiness.blockers.map(item => `  - ${item}`));
+  }
+  if (readiness.warnings.length > 0) {
+    lines.push('', 'Предупреждения:', ...readiness.warnings.map(item => `  - ${item}`));
+  }
+  lines.push('', `Дальше: ${readiness.next}`);
+  console.log(lines.join('\n'));
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (typeof args.session !== 'string' || typeof args.brief !== 'string') {
+    console.error(
+      'Usage: tsx skills/scripts/check-brief.ts --session <session.json> --brief <brief.json> [--base <session.json>] [--review] [--json]'
+    );
+    process.exit(2);
+  }
+  const result = await checkBrief({
+    session: readText(args.session),
+    brief: JSON.parse(readText(args.brief)) as Brief,
+    base: typeof args.base === 'string' ? readText(args.base) : undefined,
+    mode: args.review ? 'review' : 'build'
+  });
+  if (args.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    printReport(result);
+  }
+  process.exit(result.readiness.ready ? 0 : 1);
+}
+
+main().catch((error: unknown) => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exit(2);
+});

package/skills/scripts/rstool-skills.mjs

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+/**
+ * Writes the `rstool` entry skill stub into a project skills directory.
+ *
+ * The stub holds only `name`, `description` and the path to the real router skill,
+ * so nothing has to be re-synced after a package update. Which directory a host loads
+ * is the agent's call (skills/INSTALL.md), so there is no default `--dir`.
+ *
+ * Usage:
+ *   rstool-skills install --dir <skills-dir>... [--source <router SKILL.md>] [--target <path>]
+ *   rstool-skills stub [--source <router SKILL.md>] [--target <path>]   (prints the stub)
+ *
+ * Defaults: --source — router skill of this package; --target — its path from the
+ * current directory, or node_modules/@rsconcept/rstool/skills/rstool/SKILL.md when
+ * the package lies outside it.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROUTER = fileURLToPath(new URL('../rstool/SKILL.md', import.meta.url));
+
+/** Extracts the YAML front matter `description` block (folded `>-` or single line) verbatim. */
+export function readDescription(skillText) {
+  const match = /^---\n([\s\S]*?)\n---/.exec(skillText.replace(/\r\n/g, '\n'));
+  if (!match) {
+    throw new Error('SKILL.md has no front matter');
+  }
+  const lines = match[1].split('\n');
+  const start = lines.findIndex(line => line.startsWith('description:'));
+  if (start < 0) {
+    throw new Error('SKILL.md has no description');
+  }
+  const block = [lines[start]];
+  for (const line of lines.slice(start + 1)) {
+    if (!line.startsWith(' ')) {
+      break;
+    }
+    block.push(line);
+  }
+  return block.join('\n');
+}
+
+/** Renders the stub skill pointing at `targetPath` (written as is, use forward slashes). */
+export function renderStub(skillText, targetPath) {
+  return [
+    '---',
+    'name: rstool',
+    readDescription(skillText),
+    '---',
+    '',
+    '# rstool',
+    '',
+    `Заглушка для автосрабатывания. Прочитай \`${targetPath}\` и следуй ему.`,
+    '',
+    'Содержимое скилла — только там; эта заглушка его не повторяет и обновлять её после обновления пакета не нужно.',
+    ''
+  ].join('\n');
+}
+
+function parseArgs(argv) {
+  const args = { dirs: [], source: undefined, target: undefined };
+  for (let i = 0; i < argv.length; i++) {
+    const value = argv[i + 1];
+    if (argv[i] === '--dir') {
+      args.dirs.push(value);
+      i++;
+    } else if (argv[i] === '--source') {
+      args.source = value;
+      i++;
+    } else if (argv[i] === '--target') {
+      args.target = value;
+      i++;
+    }
+  }
+  return args;
+}
+
+function stubTarget(args, source) {
+  const fromProject = relative(process.cwd(), source).split('\\').join('/');
+  return (
+    args.target ??
+    (fromProject.startsWith('..') ? 'node_modules/@rsconcept/rstool/skills/rstool/SKILL.md' : fromProject)
+  );
+}
+
+function install(args) {
+  const source = resolve(args.source ?? ROUTER);
+  const text = readFileSync(source, 'utf8');
+  const target = stubTarget(args, source);
+  for (const dir of args.dirs) {
+    const path = join(dir, 'rstool', 'SKILL.md');
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, renderStub(text, target), 'utf8');
+    console.log(`wrote ${path} → ${target}`);
+    const legacy = join(dir, 'rstool-helper', 'SKILL.md');
+    if (existsSync(legacy)) {
+      console.log(`note: ${legacy} is the old copied skill; remove it — rstool replaces it`);
+    }
+  }
+}
+
+const isMain = process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  const [command, ...rest] = process.argv.slice(2);
+  const args = parseArgs(rest);
+  if (command === 'install' && args.dirs.length > 0) {
+    install(args);
+  } else if (command === 'stub') {
+    const source = resolve(args.source ?? ROUTER);
+    process.stdout.write(renderStub(readFileSync(source, 'utf8'), stubTarget(args, source)));
+  } else {
+    console.error(
+      'Usage: rstool-skills install --dir <skills-dir>... | rstool-skills stub [--source <SKILL.md>] [--target <path>]\n' +
+        'Which skills directory to use: node_modules/@rsconcept/rstool/skills/INSTALL.md'
+    );
+    process.exit(2);
+  }
+}

package/skills/scripts/skill-stubs.test.ts

@@ -0,0 +1,48 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+
+import { describe, expect, it } from 'vitest';
+
+const SCRIPT = resolve(import.meta.dirname, 'rstool-skills.mjs');
+const ROUTER = resolve(import.meta.dirname, '../rstool/SKILL.md');
+const WORKSPACE = resolve(import.meta.dirname, '../../../..');
+const STUBS = ['.agents/skills/rstool/SKILL.md', '.claude/skills/rstool/SKILL.md'];
+
+function renderStub(target: string): string {
+  return execFileSync('node', [SCRIPT, 'stub', '--source', ROUTER, '--target', target], { encoding: 'utf8' });
+}
+
+describe('rstool skill stubs', () => {
+  it.each(STUBS)('workspace %s matches the router skill', stub => {
+    const path = join(WORKSPACE, stub);
+    if (!existsSync(path)) {
+      return;
+    }
+    expect(readFileSync(path, 'utf8')).toBe(renderStub('rsconcept/rstool/skills/rstool/SKILL.md'));
+  });
+
+  it('install requires an explicit skills directory', () => {
+    const project = mkdtempSync(join(tmpdir(), 'rstool-skills-'));
+    try {
+      expect(() => execFileSync('node', [SCRIPT, 'install'], { cwd: project, stdio: 'pipe' })).toThrow();
+      expect(existsSync(join(project, '.claude'))).toBe(false);
+      expect(existsSync(join(project, '.agents'))).toBe(false);
+    } finally {
+      rmSync(project, { recursive: true, force: true });
+    }
+  });
+
+  it('installs a stub that points into node_modules', () => {
+    const project = mkdtempSync(join(tmpdir(), 'rstool-skills-'));
+    try {
+      execFileSync('node', [SCRIPT, 'install', '--dir', 'skills'], { cwd: project, encoding: 'utf8' });
+      const stub = readFileSync(join(project, 'skills/rstool/SKILL.md'), 'utf8');
+      expect(stub).toBe(renderStub('node_modules/@rsconcept/rstool/skills/rstool/SKILL.md'));
+      expect(stub).toContain('name: rstool');
+    } finally {
+      rmSync(project, { recursive: true, force: true });
+    }
+  });
+});

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 {

package/src/wrapper/client.ts

@@ -1,4 +1,6 @@
 import { spawn, type ChildProcessByStdio } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
 import readline from 'node:readline';
 import { type Readable, type Writable } from 'node:stream';
 
@@ -16,14 +18,38 @@ export interface WrapperResponse<T = unknown> {
 
 /** Options for spawning the `rstool-wrapper` child process. */
 export interface RSToolWrapperClientOptions {
-  /** Executable to spawn. Default: `npm`. */
+  /** Executable to spawn. Default: `npm`. Passed as argv, not a shell string. */
   command?: string;
   /** Arguments passed to `command`. Default: `['run', 'wrapper']`. */
   args?: string[];
   /** Working directory for the child process. Default: `process.cwd()`. */
   cwd?: string;
-  /** Whether to run the command in a shell. Default: `true`. */
-  shell?: boolean;
+}
+
+/**
+ * Rewrite Windows npm/npx shims to `node <npm-cli.js>` so spawn() never needs a shell.
+ * Node 20+ refuses to exec `.cmd` files without `shell: true` (CVE-2024-27980).
+ */
+function resolveSpawn(command: string, args: string[]): { command: string; args: string[] } {
+  if (process.platform !== 'win32') {
+    return { command, args };
+  }
+  const base = (command.replaceAll('\\', '/').split('/').pop() ?? command).toLowerCase();
+  if (base === 'npm' || base === 'npm.cmd') {
+    return { command: process.execPath, args: [bundledNpmBin('npm-cli.js'), ...args] };
+  }
+  if (base === 'npx' || base === 'npx.cmd') {
+    return { command: process.execPath, args: [bundledNpmBin('npx-cli.js'), ...args] };
+  }
+  return { command, args };
+}
+
+function bundledNpmBin(bin: 'npm-cli.js' | 'npx-cli.js'): string {
+  const cli = join(dirname(process.execPath), 'node_modules', 'npm', 'bin', bin);
+  if (!existsSync(cli)) {
+    throw new Error(`Cannot resolve ${bin} next to Node at ${process.execPath}`);
+  }
+  return cli;
 }
 
 /**
@@ -34,16 +60,20 @@ export interface RSToolWrapperClientOptions {
 export class RSToolWrapperClient {
   private process: ChildProcessByStdio<Writable, Readable, null>;
   private input: readline.Interface;
-  private pending = new Map<string, (value: WrapperResponse) => void>();
+  private pending = new Map<string, PendingCall>();
   private requestCounter = 1;
+  /** Set once the child cannot start or has exited; every later request fails with this error. */
+  private failure: Error | null = null;
+  private closing = false;
 
   /**
    * @param options - Spawn configuration; defaults run `npm run wrapper` in the current directory.
    */
   public constructor(options: RSToolWrapperClientOptions = {}) {
-    this.process = spawn(options.command ?? 'npm', options.args ?? ['run', 'wrapper'], {
+    const resolved = resolveSpawn(options.command ?? 'npm', options.args ?? ['run', 'wrapper']);
+    this.process = spawn(resolved.command, resolved.args, {
       cwd: options.cwd ?? process.cwd(),
-      shell: options.shell ?? true,
+      windowsHide: true,
       stdio: ['pipe', 'pipe', 'inherit']
     });
     this.input = readline.createInterface({
@@ -51,9 +81,25 @@ export class RSToolWrapperClient {
       crlfDelay: Infinity
     });
     this.input.on('line', line => this.handleLine(line));
+
+    // Without these listeners a failed spawn (ENOENT, EACCES) or a broken stdin pipe
+    // surfaces as an uncaught exception instead of a rejected promise.
+    this.process.on('error', error => this.fail(error));
+    this.process.stdin.on('error', error => this.fail(error));
+    this.process.on('exit', (code, signal) => {
+      if (this.closing) {
+        this.fail(new Error('Wrapper closed'));
+        return;
+      }
+      this.fail(new Error(`Wrapper exited before responding (code ${code ?? 'null'}, signal ${signal ?? 'null'})`));
+    });
   }
 
-  /** Block until the wrapper emits its initial `{ ready: true }` event. */
+  /**
+   * Block until the wrapper emits its initial `{ ready: true }` event.
+   *
+   * @throws When the wrapper process cannot be started or exits before becoming ready.
+   */
   public async waitUntilReady(): Promise<void> {
     for (;;) {
       const line = await this.readOneEvent();
@@ -74,13 +120,16 @@ export class RSToolWrapperClient {
    *
    * @param method - Stdio method name (matches {@link RSToolAgentContract} operations).
    * @param params - Method parameters object.
-   * @throws When the wrapper responds with `ok: false`.
+   * @throws When the wrapper responds with `ok: false`, cannot be started, or exits before responding.
    */
   public async call<T>(method: string, params: unknown = {}): Promise<T> {
+    if (this.failure) {
+      throw this.failure;
+    }
     const id = String(this.requestCounter++);
     const payload = JSON.stringify({ id, method, params });
-    const responsePromise = new Promise<WrapperResponse>(resolve => {
-      this.pending.set(id, resolve);
+    const responsePromise = new Promise<WrapperResponse>((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
     });
     this.process.stdin.write(`${payload}\n`);
     const response = await responsePromise;
@@ -92,14 +141,20 @@ export class RSToolWrapperClient {
 
   /** Close stdin and terminate the wrapper process. */
   public async close(): Promise<void> {
+    this.closing = true;
     this.input.close();
-    this.process.stdin.end();
-    if (!this.process.killed) {
+    if (!this.process.stdin.destroyed) {
+      this.process.stdin.end();
+    }
+    if (this.process.exitCode === null && !this.process.killed) {
       this.process.kill();
     }
   }
 
   private async readOneEvent(): Promise<string> {
+    if (this.failure) {
+      throw this.failure;
+    }
     return new Promise((resolve, reject) => {
       const onLine = (line: string) => {
         cleanup();
@@ -107,17 +162,36 @@ export class RSToolWrapperClient {
       };
       const onExit = () => {
         cleanup();
-        reject(new Error('Wrapper exited before ready'));
+        reject(this.failure ?? new Error('Wrapper exited before ready'));
+      };
+      const onError = (error: Error) => {
+        cleanup();
+        reject(error);
       };
       const cleanup = () => {
         this.input.off('line', onLine);
         this.process.off('exit', onExit);
+        this.process.off('error', onError);
       };
       this.input.on('line', onLine);
       this.process.on('exit', onExit);
+      this.process.on('error', onError);
     });
   }
 
+  /** Records the terminal failure and rejects every outstanding request. */
+  private fail(error: Error): void {
+    if (this.failure) {
+      return;
+    }
+    this.failure = error;
+    const outstanding = [...this.pending.values()];
+    this.pending.clear();
+    for (const entry of outstanding) {
+      entry.reject(error);
+    }
+  }
+
   private handleLine(line: string): void {
     let parsed: WrapperResponse;
     try {
@@ -129,11 +203,16 @@ export class RSToolWrapperClient {
       return;
     }
     const id = String(parsed.id);
-    const resolver = this.pending.get(id);
-    if (!resolver) {
+    const entry = this.pending.get(id);
+    if (!entry) {
       return;
     }
     this.pending.delete(id);
-    resolver(parsed);
+    entry.resolve(parsed);
   }
 }
+
+interface PendingCall {
+  resolve: (value: WrapperResponse) => void;
+  reject: (reason: Error) => void;
+}