rea-agents 2.0.0 → 2.2.0

package/dist/server/toolRegistrationOptions.js

@@ -32,8 +32,8 @@ const advertisedOutputSchema = (schema) => {
         "~standard": {
             ...standard,
             jsonSchema: {
-                input: () => closeObjectSchemas(converter({ target: "draft-2020-12" })),
-                output: () => closeObjectSchemas(converter({ target: "draft-2020-12" })),
+                input: () => describeRootProperties(closeObjectSchemas(converter({ target: "draft-2020-12" }))),
+                output: () => describeRootProperties(closeObjectSchemas(converter({ target: "draft-2020-12" }))),
             },
         },
     };
@@ -70,7 +70,7 @@ const describeProperties = (value) => Object.fromEntries(Object.entries(value).m
             isObject(schema) && typeof schema.description !== "string"
                 ? {
                     ...describeProperties(schema),
-                    description: property.replaceAll("_", " "),
+                    description: fallbackPropertyDescription(property),
                 }
                 : describeValue(schema),
         ])),
@@ -81,4 +81,102 @@ const describeValue = (value) => {
         return value.map(describeValue);
     return isObject(value) ? describeProperties(value) : value;
 };
+const describeRootProperties = (value) => {
+    const properties = value.properties;
+    if (!isObject(properties))
+        return { ...value };
+    return {
+        ...value,
+        properties: Object.fromEntries(Object.entries(properties).map(([property, schema]) => [
+            property,
+            isObject(schema) && typeof schema.description !== "string"
+                ? {
+                    ...schema,
+                    description: fallbackPropertyDescription(property),
+                }
+                : schema,
+        ])),
+    };
+};
+const PROPERTY_DESCRIPTIONS = {
+    addresses: "Ordered provider-normalized procedure addresses to analyze.",
+    approved: "Explicit operator approval to perform this operation.",
+    after: "The later or right-hand observation to compare.",
+    before: "The earlier or left-hand observation to compare.",
+    boundary_id: "Exact reconstruction boundary identifier to evaluate.",
+    case_sensitive: "Whether text matching distinguishes uppercase and lowercase.",
+    cdp_endpoint: "Approved literal loopback Chrome DevTools Protocol endpoint.",
+    comment: "Exact analyst comment text to write.",
+    comparisons: "Validated comparison Evidence records to aggregate.",
+    coverage: "Exact reconstruction-coverage commitment to verify.",
+    detail: "Requested response detail level.",
+    direction: "Direction in which to traverse or compare relationships.",
+    document: "Exact provider document or program identity.",
+    error: "Structured, caller-actionable error when the operation fails.",
+    evidence: "Evidence v2 record produced by this operation.",
+    evidence_id: "Stable identifier of the recorded Evidence v2 observation.",
+    evidence_uri: "Session resource URI for the recorded Evidence v2 observation.",
+    executable: "Approved absolute path of the executable to run.",
+    format: "Declared input artifact format.",
+    name: "Exact name used by this operation.",
+    pattern: "Text or bounded pattern used to filter matching results.",
+    phase: "Current plan or execution phase of the operation.",
+    plan: "Content-bound execution plan and its approval commitment.",
+    query: "Non-empty feature or text query to investigate.",
+    question: "Concrete unresolved question to retain for later investigation.",
+    result: "Primary structured result returned by this operation.",
+    left: "Left-hand input used for comparison or differential execution.",
+    limit: "Maximum number of results to return in this page.",
+    limits: "Bounded resource-consumption and result-size limits for this operation.",
+    mode: "Operation mode that selects the requested behavior.",
+    offset: "Zero-based index of the first result to return.",
+    overwrite: "Whether an existing destination may be replaced.",
+    path: "Local filesystem path used by this operation.",
+    provider_id: "Exact deep-analysis provider ID, or automatic selection when omitted.",
+    right: "Right-hand input used for comparison or differential execution.",
+    schema_version: "Version of this structured result schema.",
+    source_evidence: "Evidence records supporting the prepared source transformation.",
+    status: "Current lifecycle or verification status.",
+    summary: "Concise evidence-backed summary of the result.",
+    symbols: "Ordered bounded Swift symbols to demangle.",
+    target_id: "Exact authorized CDP target identifier.",
+    unknown_id: "Exact residual-unknown identifier.",
+    unknown_registry_approved: "Explicit approval to record bounded residual uncertainty in the session registry.",
+    workspace_path: "Approved local path of the persistent investigation workspace.",
+};
+const fallbackPropertyDescription = (property) => {
+    const explicit = PROPERTY_DESCRIPTIONS[property];
+    if (explicit !== undefined)
+        return explicit;
+    const words = property.replaceAll("_", " ");
+    if (property.endsWith("_approved"))
+        return `Explicit operator approval for ${words.slice(0, -9)}.`;
+    if (property.endsWith("_offset"))
+        return `Zero-based index of the first ${words.slice(0, -7)} to return.`;
+    if (property.endsWith("_limit"))
+        return `Maximum number of ${words.slice(0, -6)} entries to return.`;
+    if (property.startsWith("max_"))
+        return `Maximum permitted ${words.slice(4)} for this operation.`;
+    if (property.startsWith("include_"))
+        return `Whether to include ${words.slice(8)} in the result.`;
+    if (property.startsWith("expected_"))
+        return `Expected ${words.slice(9)} used to reject stale or mismatched input.`;
+    if (property.endsWith("_sha256"))
+        return `Exact SHA-256 digest of ${words.slice(0, -7)}.`;
+    if (property.endsWith("_evidence_id"))
+        return `Exact Evidence v2 identifier for the ${words.slice(0, -12)} observation.`;
+    if (property.endsWith("_evidence_ids"))
+        return `Ordered Evidence v2 identifiers for the ${words.slice(0, -13)} observations.`;
+    if (property.endsWith("_path"))
+        return `Local filesystem path for ${words.slice(0, -5)}.`;
+    if (property.endsWith("_uri"))
+        return `Canonical URI for ${words.slice(0, -4)}.`;
+    if (property.endsWith("_bytes"))
+        return `Bounded byte count for ${words.slice(0, -6)}.`;
+    if (property.endsWith("_root") || property.endsWith("_roots"))
+        return `Approved canonical filesystem ${words}.`;
+    if (property.startsWith("is_") || property.startsWith("has_"))
+        return `Whether ${words}.`;
+    return `Value for ${words}.`;
+};
 const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);

package/dist/server/toolResult.js

@@ -22,7 +22,7 @@ const errorResult = (error) => {
     };
 };
 const successResult = (value, contract, options) => {
-    const candidate = compactEvidence(value) ??
+    const candidate = compactEvidence(value, options.evidenceResultProjection) ??
         (contract.kind === "session" ? { result: value } : value);
     const parsed = contract.outputSchema.safeParse(candidate);
     if (!parsed.success) {
@@ -42,14 +42,25 @@ const successResult = (value, contract, options) => {
     }
     return {
         content: [
-            { type: "text", text: JSON.stringify(parsed.data) },
+            {
+                type: "text",
+                text: JSON.stringify(options.evidenceTextProjection === undefined
+                    ? parsed.data
+                    : (compactEvidence(value, options.evidenceTextProjection) ??
+                        options.evidenceTextProjection)),
+            },
             ...evidenceResourceLinks(value, contract.kind === "session" ||
                 options.evidenceResourcesAvailable === true),
+            ...(options.resourceLinks ?? []).map((resource) => ({
+                type: "resource_link",
+                ...resource,
+                mimeType: "application/json",
+            })),
         ],
         structuredContent: candidate,
     };
 };
-const compactEvidence = (value) => {
+const compactEvidence = (value, resultProjection) => {
     if (typeof value !== "object" ||
         value === null ||
         Array.isArray(value) ||
@@ -58,7 +69,7 @@ const compactEvidence = (value) => {
         !("normalized_result" in value))
         return undefined;
     return {
-        result: value.normalized_result,
+        result: resultProjection ?? value.normalized_result,
         evidence_id: value.evidence_id,
         evidence_uri: `rea://evidence/${value.evidence_id}`,
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rea-agents",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "Reverse engineer anything from your terminal or agent with one CLI and MCP server.",
   "license": "MIT",
   "repository": {
@@ -30,7 +30,8 @@
   },
   "type": "module",
   "bin": {
-    "rea": "scripts/rea.mjs"
+    "rea": "scripts/rea.mjs",
+    "rea-agents": "scripts/rea.mjs"
   },
   "engines": {
     "node": "^22.19.0 || >=24.11.0"
@@ -42,8 +43,6 @@
     "bridge/hopper_bridge.py",
     "bridge/ghidra/ReaGhidraBridge.java",
     "scripts/rea.mjs",
-    "scripts/prepare-node-pty.mjs",
-    "scripts/rebuild-native.mjs",
     "scripts/hopper-demo-x11.py",
     "skills",
     "README.md",
@@ -66,7 +65,6 @@
     "scan:todos": "node scripts/scan-todos.mjs",
     "start": "node scripts/rea.mjs mcp",
     "pretest": "npm run build",
-    "postinstall": "node scripts/prepare-node-pty.mjs",
     "test": "vitest run",
     "pretest:coverage": "npm run build",
     "test:coverage": "vitest run --coverage.enabled --coverage.provider=v8",
@@ -75,16 +73,21 @@
     "typecheck": "tsc --noEmit",
     "verify:hopper": "npm run build && node scripts/verify-real-hopper.mjs",
     "verify:ghidra": "npm run build && node scripts/verify-real-ghidra.mjs",
+    "verify:ghidra:windows": "npm run build && npm run build:ghidra-windows-fixture && node scripts/verify-real-ghidra-windows.mjs",
     "verify:browser": "npm run build && node scripts/verify-real-browser.mjs",
     "verify:javascript-runtime": "npm run build && node scripts/verify-local-javascript-runtime.mjs",
     "verify:application-workflows": "npm run build && node scripts/verify-local-application-workflows.mjs",
     "verify:managed": "npm run build && node scripts/verify-managed-conformance.mjs",
     "verify:replay": "npm run build && node scripts/verify-real-javascript-replay.mjs",
+    "verify:agent": "npm run build && node scripts/verify-agent-experience.mjs",
     "verify:hopper:linux": "npm run build && node scripts/verify-real-hopper-linux.mjs",
     "verify:setup:linux": "npm run build && node scripts/verify-linux-setup-e2e.mjs",
     "build:fixtures": "node scripts/build-conformance-fixtures.mjs",
+    "build:ghidra-windows-fixture": "node scripts/create-ghidra-windows-fixture.mjs",
     "verify:fixtures": "npm run build:fixtures && node scripts/verify-conformance-fixtures.mjs",
     "verify:package": "npm run build && node scripts/verify-package.mjs",
+    "verify:package:windows": "npm run build && node scripts/verify-windows-package.mjs",
+    "probe:windows-capabilities": "npm run build && node scripts/windows-capabilities.mjs",
     "verify:published": "node scripts/verify-published-package.mjs",
     "config:print": "node scripts/print-mcp-config.mjs",
     "docs:generate": "npm run build && node scripts/generate-skill-metadata.mjs && node scripts/generate-product-catalog.mjs && typedoc && node scripts/generate-error-schema.mjs",
@@ -92,8 +95,7 @@
     "docs:error-schema": "npm run build && node scripts/generate-error-schema.mjs",
     "prepack": "npm run deps:check && node scripts/generate-skill-metadata.mjs --check",
     "prepublishOnly": "npm run deps:check && node scripts/generate-skill-metadata.mjs --check",
-    "prepare": "npm run build && husky",
-    "rebuild:native": "node scripts/rebuild-native.mjs"
+    "prepare": "npm run build && husky"
   },
   "lint-staged": {
     "*.{ts,mjs,json,md,yml,yaml}": "prettier --write",
@@ -102,8 +104,10 @@
   "dependencies": {
     "@babel/parser": "8.0.4",
     "@babel/types": "8.0.4",
+    "@clack/prompts": "1.7.0",
     "@electron/asar": "4.2.0",
     "@jridgewell/trace-mapping": "0.3.31",
+    "@lydell/node-pty": "1.1.0",
     "@modelcontextprotocol/server": "2.0.0-beta.4",
     "@xterm/addon-serialize": "0.14.0",
     "@xterm/headless": "6.0.0",
@@ -115,7 +119,6 @@
     "ignore": "7.0.6",
     "incur": "0.4.13",
     "isomorphic-git": "1.38.7",
-    "node-pty": "1.1.0",
     "pino": "9.14.0",
     "plist": "5.0.0",
     "semver": "7.8.5",
@@ -141,8 +144,5 @@
     "typedoc": "0.28.20",
     "typescript": "5.9.3",
     "vitest": "4.1.10"
-  },
-  "allowScripts": {
-    "node-pty@1.1.0": true
   }
 }

package/skills/reverse-engineer-anything/SKILL.md

@@ -0,0 +1,76 @@
+---
+name: reverse-engineer-anything
+description: Reverse engineer native, managed, Electron/JavaScript, packaged, and browser applications with REA. Use shipped-artifact or approved runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.
+metadata:
+  version: "23"
+  tool_count: 95
+  catalog_digest: "f8a4a8392f73780686234656e3e4555539a828e021c72754e4131c83df349b9f"
+---
+
+# REA
+
+Use REA when a claim depends on a shipped binary or package, decompilation,
+passive application runtime evidence, controlled replay, or comparison with
+behavior not established by available source. For ordinary analysis of a
+complete source repository, use normal repository tools and do not run REA
+readiness or provider commands.
+
+## Route the target first
+
+Choose the first tool from the target the user supplied. Do not call
+`open_binary` unless the target is native or an analysis database.
+
+- ASAR or extracted JavaScript/Electron tree:
+  `analyze_javascript_application`.
+- Archive, application package, ZIP/APK/IPA, or DMG: `inventory_artifact`.
+- Managed PE/CLI assembly: `inspect_managed_artifact`.
+- User-owned browser page already open: `list_browser_targets`.
+- User-owned Electron runtime already open: `list_electron_targets`.
+- Native executable, library, or analysis database: `open_binary`, then
+  `binary_overview`.
+
+If the app is missing, ask which app to inspect. Resolve a human-readable app
+name to one clear installed artifact when possible; ask only when matches are
+ambiguous. Never choose an example app on the user's behalf.
+
+## Work summary-first
+
+Start with the default summary projection. Do not repeat an identical tool call.
+Do not fetch full Evidence or a full application graph unless a specific claim
+requires detail absent from the summary. For JavaScript graphs, follow the
+paged resource URIs returned by the summary and fetch only the relevant page.
+
+Every conclusion must distinguish observations, inferences, and unknowns. Cite
+Evidence IDs, preserve limitations and incomplete coverage, and never imply
+that static analysis observed execution. Ask for approval only where a tool or
+policy requires it; approval never broadens a different authority boundary.
+
+## Read only the relevant guide
+
+- Native binaries, managed assemblies, archives, and extraction:
+  [references/native-and-artifacts.md](references/native-and-artifacts.md)
+- ASARs, extracted JavaScript, feature tracing, and version comparison:
+  [references/javascript-applications.md](references/javascript-applications.md)
+- Passive browser/Electron observation and static/runtime reconciliation:
+  [references/runtime-observation.md](references/runtime-observation.md)
+- Evidence paging, comparisons, residual unknowns, and verification:
+  [references/evidence-workflows.md](references/evidence-workflows.md)
+- Controlled JavaScript replay:
+  [references/controlled-replay.md](references/controlled-replay.md)
+
+## Readiness and setup
+
+If REA tools are available, use them directly; do not run `doctor` on every
+task. If the MCP server is unavailable or registration is reported stale, run
+`npx -y rea-agents@latest doctor`. Propose
+`npx -y rea-agents@latest setup` only when doctor identifies an alignment or
+provider problem. Show the exact plan and obtain approval before setup writes
+configuration or installs Hopper. Restart the agent after MCP registration
+changes; direct CLI commands remain available immediately.
+
+## Finish the task
+
+Explain findings in plain language and tie them to returned evidence. When the
+user asks to build something, use normal coding tools and separate observed
+behavior from design choices. Close an opened native session with
+`close_binary` when the investigation is complete.

package/skills/reverse-engineer-anything/references/controlled-replay.md

@@ -0,0 +1,12 @@
+# Controlled JavaScript replay
+
+Use `run_controlled_replay` only for operator-selected extracted modules when
+the separate replay policy is enabled. Call `mode: plan` first. Review the exact
+module, stub, runtime, sandbox, case, limits, and policy commitments. Execute
+only with `approved: true` and that exact plan digest.
+
+Treat return values, exceptions, denials, limits, and crashes as observations of
+the isolated experiment with controlled-replay authority, not facts about the
+real application. Never substitute browser/Electron permission, process
+capture, or an in-process `vm` run. Reproducer export requires separate literal
+approval and evidence-write authority after sandbox cleanup.

package/skills/reverse-engineer-anything/references/evidence-workflows.md

@@ -0,0 +1,33 @@
+# Evidence, comparison, and verification workflows
+
+REA results are Evidence v2. Cite evidence IDs and preserve authority,
+limitations, coverage, and residual unknowns. Read the smallest deterministic
+page that answers the question. Continue from a returned next offset while
+`has_more` is true only when exhaustive coverage matters.
+
+Use `record_unknown` only with explicit approval and name the authority or
+environment still required. Supply supporting and contradicting evidence IDs.
+Use `update_unknown` with the current revision; reread after a stale revision
+instead of retrying blindly. Only qualifying observed evidence can verify a
+resolution.
+
+Use comparisons with complete, compatible page sets when claiming equivalence
+or absence:
+
+- `compare_artifacts` compares inventory pages by occurrence path, content,
+  metadata, and graph relations.
+- `compare_functions` compares explicit function Evidence, not fuzzy
+  whole-binary matches.
+- `compare_bundles` compares canonical bundle membership and unknown history.
+- `find_changed_behavior` combines existing comparisons; static differences
+  remain candidates, not causal proof.
+- `build_call_path` needs explicit function dossiers from one artifact/provider;
+  an incomplete frontier makes absence unknown.
+- `correlate_static_and_runtime` uses explicit mappings; matching patterns are
+  hypotheses, not causality.
+- `verify_reconstruction` evaluates a finite typed specification. A pass covers
+  only declared comparable claims, not global equivalence.
+
+Process captures are opt-in behavioral evidence, not a security sandbox. V3
+captures cannot be upgraded to V4; rerun the original scenario. Distinguish root
+exit from descendant settlement and require freshness when the task needs it.

package/skills/reverse-engineer-anything/references/javascript-applications.md

@@ -0,0 +1,25 @@
+# JavaScript and Electron application artifacts
+
+Use `analyze_javascript_application` for an operator-supplied ASAR or extracted
+tree beneath an approved investigation root. Every call requires `approved:
+true`; source-map contents require separate approval. Keep the default summary.
+Use its counts, roots, node kinds, top findings, coverage, unknowns, and graph
+page URIs before requesting more data.
+
+BrowserWindow preferences, preload and contextBridge surfaces, IPC
+registrations, utility processes, and native binding requests are static syntax
+observations. Only a unique exact literal IPC channel match supports an inferred
+pairing. Dynamic or ambiguous channels remain unresolved. A requested `.node`
+member is not a verified native export. Never claim runtime reachability,
+registration, defaults, or policy enforcement from static analysis.
+
+Use `trace_application_feature` on existing application Evidence for one
+literal node ID, route, string, API, IPC channel, module, or native export.
+Choose a direction and finite bounds. Link Hopper or Ghidra Evidence only when
+the exact artifact digest matches.
+
+For version comparison, analyze each version once, then call
+`compare_application_versions`. Accept only its digest, source-map, structural
+fingerprint, or non-module semantic matches. Module ordinals and minified names
+are not persistent identity. Report added or removed only with complete
+opposite-side coverage; otherwise report unknown.

package/skills/reverse-engineer-anything/references/native-and-artifacts.md

@@ -0,0 +1,36 @@
+# Native, managed, and packaged artifacts
+
+## Native targets
+
+After `open_binary`, use `binary_overview` once and narrow around the requested
+feature. Prefer literal search, names, decompilation, callers, callees, and
+cross-references. Addresses and recovered pseudocode are analysis observations,
+not original source. Provider unavailability and unsupported metadata remain
+unknown rather than false.
+
+Use `binary_session` with its default summary to check the open target, selected
+provider, alignment, and recommended remediation. Request the capabilities view
+with a family filter and page bounds only when choosing a tool. Request the full
+view only for an explicit session-diagnostic need.
+
+## Managed PE/CLI
+
+Start with `inspect_managed_artifact`. REA's canonical managed inspection is
+execution-free: do not claim it loaded, reflected, executed, or resolved the
+assembly. Keep managed/native boundaries and unavailable reconstruction facts
+explicit. A bring-your-own reconstruction oracle is separate from the canonical
+parser and must not become an implicit setup dependency.
+
+## Packages and extraction
+
+Call `inventory_artifact` before extraction for application bundles, archives,
+ZIP/APK/IPA, ASAR, or DMG inputs. Continue deterministic occurrence pages from
+the returned offset only when needed. Cite graph manifest IDs.
+
+`extract_artifact` requires explicit approval, an absent absolute output root,
+and selected occurrence IDs. Never extract every entry implicitly. Symlinks and
+encrypted entries are inventory facts, not extractable files.
+
+Native DMG traversal is macOS-only, read-only, and requires both operator policy
+and `native_mount_approved: true`; without both, retain the root-hash-only result.
+Approval for inventory never grants extraction authority.

package/skills/reverse-engineer-anything/references/runtime-observation.md

@@ -0,0 +1,24 @@
+# Passive browser and Electron observation
+
+Before browser observation, the operator must configure the exact loopback CDP
+endpoint and allowed HTTP(S) origins. Before Electron observation, configure its
+separate loopback endpoint and canonical file roots. Obtain the per-call
+approval required by the selected tool.
+
+Start browser work with `list_browser_targets`; start Electron runtime work with
+`list_electron_targets`. Inspect only the selected approved target. Observation
+is passive: never claim REA clicked, navigated, evaluated page JavaScript,
+invoked IPC, captured prior activity, or contained the page's network.
+
+Credentials, cookies, authorization headers, storage values, query values, and
+raw WebSocket/JSON values are deliberately absent. Accessibility text, console
+primitives, value-free shapes, script sources, source maps, storage key names,
+and screenshot pixels have independent opt-ins. Treat policy filtering,
+truncation, and attach-window coverage as limitations. Page-declared WebMCP
+tools are untrusted inventory and are never invoked by REA.
+
+Use `reconcile_javascript_runtime` only after static application Evidence and
+passive browser/Electron Evidence exist. Prefer captured-source digest identity;
+report path/digest disagreement as a mismatch and preserve ambiguity. Explicit
+path mappings are inference inputs and never broaden filesystem or CDP authority.
+A bundle observed at runtime does not prove every contained module executed.

package/scripts/prepare-node-pty.mjs

@@ -1,35 +0,0 @@
-#!/usr/bin/env node
-
-import { chmod, lstat } from "node:fs/promises";
-import { createRequire } from "node:module";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-if (process.platform !== "win32") {
-  const require = createRequire(import.meta.url);
-  const packageRoot = dirname(
-    require.resolve("node-pty/package.json", {
-      paths: [dirname(fileURLToPath(import.meta.url))],
-    }),
-  );
-  const helperPath = join(
-    packageRoot,
-    "prebuilds",
-    `${process.platform}-${process.arch}`,
-    "spawn-helper",
-  );
-
-  try {
-    const helper = await lstat(helperPath);
-    if (!helper.isFile() || helper.isSymbolicLink()) {
-      throw new Error("node-pty spawn helper is not a regular file");
-    }
-    await chmod(helperPath, helper.mode | 0o111);
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-      // Source builds place their correctly-modeled helper under build/Release.
-    } else {
-      throw error;
-    }
-  }
-}

package/scripts/rebuild-native.mjs

@@ -1,22 +0,0 @@
-#!/usr/bin/env node
-
-import { spawn } from "node:child_process";
-
-const npm = process.platform === "win32" ? "npm.cmd" : "npm";
-const child = spawn(npm, ["rebuild", "node-pty"], {
-  stdio: "inherit",
-  env: { ...process.env, npm_config_build_from_source: "true" },
-});
-
-child.once("error", (error) => {
-  console.error(`Unable to rebuild node-pty: ${error.message}`);
-  process.exitCode = 1;
-});
-child.once("exit", (code, signal) => {
-  if (signal !== null) {
-    console.error(`node-pty rebuild terminated by ${signal}`);
-    process.exitCode = 1;
-    return;
-  }
-  process.exitCode = code ?? 1;
-});