rea-agents 2.0.0 → 2.1.0

package/dist/server/registerSessionTools.js

@@ -1,12 +1,11 @@
 import { z } from "zod";
-import { exportEvidenceBundleInputSchema, importEvidenceBundleInputSchema, listUnknownsInputSchema, SESSION_TOOL_CONTRACTS, verifyUnknownResolutionInputSchema, } from "../contracts/toolContracts.js";
+import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
 import { toCallToolResult } from "./toolResult.js";
 import { logToolExecution } from "./toolLogging.js";
 import { err, ok } from "../domain/result.js";
 import { processScenarioSchema } from "../domain/processCapture.js";
 import { captureProcessScenario } from "../application/ProcessHarness.js";
-import { recordUnknownInputSchema, updateUnknownInputSchema, } from "../domain/residualUnknown.js";
-import { readEvidenceBundle, writeEvidenceBundle, } from "../application/EvidenceBundleFiles.js";
+import { processCapturePermissionRequest } from "../application/ProcessCapturePermission.js";
 import { readAnalysisSnapshot, writeAnalysisSnapshot, } from "../application/AnalysisSnapshotFiles.js";
 import { AnalysisProtocolError, PermissionRequiredError, UnknownRegistryError, } from "../domain/errors.js";
 import { DENY_EVIDENCE_FILE_POLICY, DENY_PROCESS_POLICY, } from "./sessionToolPolicies.js";
@@ -21,6 +20,10 @@ import { registerInvestigationTools } from "./registerInvestigationTools.js";
 import { closeBinaryInputSchema, openBinaryInputSchema, } from "../contracts/sessionLifecycleInputs.js";
 import { registerSessionStatusTool } from "./registerSessionStatusTool.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
+import { authorizeProcessCaptureWithElicitation, } from "./ProcessCaptureElicitation.js";
+import { isInputRequiredResult } from "@modelcontextprotocol/server";
+import { registerEvidenceTools, registerUnknownTools, } from "./registerSessionRecordTools.js";
+import { sessionAvailabilityPolicy } from "./sessionAvailabilityPolicy.js";
 const permissionFailure = (failure) => {
     if (failure.ok)
         return err(new AnalysisProtocolError("Expected a denied permission"));
@@ -59,25 +62,19 @@ const recordProcessResidualUnknowns = (session, scenario, evidence, residuals) =
     }
     return ok(null);
 };
-const registerProcessTools = ({ server, session, logger, processPolicy, captureContract, permissionAuthority, }) => {
+const registerProcessTools = ({ server, session, logger, processPolicy, captureContract, permissionAuthority, processCaptureElicitation, }) => {
     server.registerTool(captureContract.name, toolRegistrationOptions(captureContract), async (input, context) => {
         const parsedInput = safeParseToolInput(processScenarioSchema, input, captureContract.name);
         if (!parsedInput.ok)
             return toCallToolResult(parsedInput, captureContract);
         const scenario = parsedInput.value;
         if (permissionAuthority !== undefined) {
-            const authorized = await permissionAuthority.authorize({
-                capability: "process_capture",
-                roots: [scenario.working_directory, ...scenario.filesystem_roots],
-                executables: [scenario.executable],
-                environment_names: [
-                    ...Object.keys(scenario.environment),
-                    ...scenario.inherit_environment,
-                ],
-                network: scenario.network_access === "host" ? "external" : "none",
-                mount: false,
-                operation_identity: `capture_process_scenario:${scenario.executable}`,
-            }, "read");
+            const request = processCapturePermissionRequest(scenario);
+            const authorized = processCaptureElicitation === undefined
+                ? await permissionAuthority.authorize(request, "read")
+                : await authorizeProcessCaptureWithElicitation(permissionAuthority, request, context, processCaptureElicitation);
+            if (isInputRequiredResult(authorized))
+                return authorized;
             if (!authorized.ok)
                 return toCallToolResult(permissionFailure(authorized), captureContract);
         }
@@ -108,111 +105,19 @@ const registerProcessTools = ({ server, session, logger, processPolicy, captureC
         return toCallToolResult(ok(evidence), captureContract);
     });
 };
-const registerEvidenceTools = ({ server, session, exportContract, importContract, filePolicy, permissionAuthority, }) => {
-    server.registerTool(exportContract.name, toolRegistrationOptions(exportContract), async (input) => {
-        const parsedInput = safeParseToolInput(exportEvidenceBundleInputSchema, input, exportContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, exportContract);
-        const parsed = parsedInput.value;
-        const bundle = session.exportEvidenceBundle();
-        if (parsed.path === undefined)
-            return toCallToolResult(ok(bundle), exportContract);
-        if (permissionAuthority !== undefined) {
-            const authorized = await permissionAuthority.authorize({
-                capability: "evidence_write",
-                roots: [parsed.path],
-                executables: [],
-                environment_names: [],
-                network: "none",
-                mount: false,
-                operation_identity: `export_evidence:${parsed.path}`,
-            }, "write");
-            if (!authorized.ok)
-                return toCallToolResult(permissionFailure(authorized), exportContract);
-        }
-        const written = await writeEvidenceBundle(bundle, parsed.path, parsed.overwrite, filePolicy);
-        return written.ok
-            ? toCallToolResult(ok({
-                path: written.value.path,
-                bytes: written.value.bytes,
-                records: bundle.records.length,
-            }), exportContract)
-            : toCallToolResult(written, exportContract);
-    });
-    server.registerTool(importContract.name, toolRegistrationOptions(importContract), async (input) => {
-        const parsedInput = safeParseToolInput(importEvidenceBundleInputSchema, input, importContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, importContract);
-        const path = parsedInput.value.path;
-        if (permissionAuthority !== undefined) {
-            const authorized = await permissionAuthority.authorize({
-                capability: "evidence_read",
-                roots: [path],
-                executables: [],
-                environment_names: [],
-                network: "none",
-                mount: false,
-                operation_identity: `import_evidence:${path}`,
-            }, "read");
-            if (!authorized.ok)
-                return toCallToolResult(permissionFailure(authorized), importContract);
-        }
-        const loaded = await readEvidenceBundle(path, filePolicy);
-        if (!loaded.ok)
-            return toCallToolResult(loaded, importContract);
-        const imported = session.importEvidenceBundle(loaded.value);
-        if (imported.ok && imported.value > 0)
-            server.sendResourceListChanged();
-        return imported.ok
-            ? toCallToolResult(ok({
-                imported: imported.value,
-                total: session.exportEvidenceBundle().records.length,
-            }), importContract)
-            : toCallToolResult(imported, importContract);
-    });
-};
-const registerUnknownTools = ({ server, session, contracts: [listContract, recordContract, updateContract, verifyContract], }) => {
-    server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input) => {
-        const parsedInput = safeParseToolInput(listUnknownsInputSchema, input, listContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, listContract);
-        const filters = parsedInput.value;
-        return toCallToolResult(ok(session.listUnknowns({
-            ...(filters.status === undefined ? {} : { status: filters.status }),
-            ...(filters.severity === undefined
-                ? {}
-                : { severity: filters.severity }),
-            ...(filters.domain === undefined ? {} : { domain: filters.domain }),
-        })), listContract);
-    });
-    server.registerTool(recordContract.name, toolRegistrationOptions(recordContract), (input) => {
-        const parsedInput = safeParseToolInput(recordUnknownInputSchema, input, recordContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, recordContract);
-        const recorded = session.recordUnknown(parsedInput.value);
-        if (recorded.ok)
-            server.sendResourceListChanged();
-        return toCallToolResult(recorded, recordContract);
-    });
-    server.registerTool(updateContract.name, toolRegistrationOptions(updateContract), (input) => {
-        const parsedInput = safeParseToolInput(updateUnknownInputSchema, input, updateContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, updateContract);
-        const updated = session.updateUnknown(parsedInput.value);
-        if (updated.ok)
-            server.sendResourceListChanged();
-        return toCallToolResult(updated, updateContract);
-    });
-    server.registerTool(verifyContract.name, toolRegistrationOptions(verifyContract), (input) => {
-        const parsedInput = safeParseToolInput(verifyUnknownResolutionInputSchema, input, verifyContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, verifyContract);
-        const unknownId = parsedInput.value.unknown_id;
-        return toCallToolResult(session.verifyUnknownResolution(unknownId), verifyContract);
+const registerLifecycleTools = (registration) => {
+    const { server, session, contracts, startedAt, availabilityPolicy } = registration;
+    registerOpenLifecycleTool(registration);
+    registerCloseLifecycleTool(registration);
+    registerSessionStatusTool({
+        server,
+        session,
+        contract: contracts[2],
+        startedAt,
+        availabilityPolicy,
     });
 };
-const registerLifecycleTools = ({ server, session, logger, contracts, snapshotFilePolicy, startedAt, availabilityPolicy, permissionAuthority, }) => {
-    const [openContract, closeContract, statusContract] = contracts;
+const registerOpenLifecycleTool = ({ server, session, logger, contracts: [openContract], snapshotFilePolicy, permissionAuthority, }) => {
     server.registerTool(openContract.name, toolRegistrationOptions(openContract), async (input, context) => {
         const parsedInput = safeParseToolInput(openBinaryInputSchema, input, openContract.name);
         if (!parsedInput.ok)
@@ -263,54 +168,55 @@ const registerLifecycleTools = ({ server, session, logger, contracts, snapshotFi
             }, openContract)
             : toCallToolResult(opened, openContract);
     });
+};
+const registerCloseLifecycleTool = ({ server, session, logger, contracts: [, closeContract], snapshotFilePolicy, permissionAuthority, }) => {
     server.registerTool(closeContract.name, toolRegistrationOptions(closeContract), async (input) => {
         const parsedInput = safeParseToolInput(closeBinaryInputSchema, input, closeContract.name);
         if (!parsedInput.ok)
             return toCallToolResult(parsedInput, closeContract);
         const parsed = parsedInput.value;
-        if (parsed.snapshot_path !== undefined) {
-            if (permissionAuthority !== undefined) {
-                const authorized = await permissionAuthority.authorize({
-                    capability: "snapshot_write",
-                    roots: [parsed.snapshot_path],
-                    executables: [],
-                    environment_names: [],
-                    network: "none",
-                    mount: false,
-                    operation_identity: `close_binary:snapshot:${parsed.snapshot_path}`,
-                }, "write");
-                if (!authorized.ok)
-                    return toCallToolResult(permissionFailure(authorized), closeContract);
-            }
-            const snapshot = session.exportAnalysisSnapshot();
-            if (!snapshot.ok)
-                return toCallToolResult(snapshot, closeContract);
-            const written = await writeAnalysisSnapshot(snapshot.value, parsed.snapshot_path, parsed.overwrite, snapshotFilePolicy);
-            if (!written.ok)
-                return toCallToolResult(written, closeContract);
+        if (parsed.snapshot_path === undefined) {
             const closed = await logToolExecution(logger, closeContract.name, () => session.close());
             if (closed.ok)
                 server.sendToolListChanged();
-            return closed.ok
-                ? toCallToolResult(ok({
-                    path: written.value.path,
-                    bytes: written.value.bytes,
-                    entries: snapshot.value.entries.length,
-                }), closeContract)
-                : toCallToolResult(closed, closeContract);
+            return toCallToolResult(closed, closeContract);
         }
+        if (permissionAuthority !== undefined) {
+            const authorized = await permissionAuthority.authorize({
+                capability: "snapshot_write",
+                roots: [parsed.snapshot_path],
+                executables: [],
+                environment_names: [],
+                network: "none",
+                mount: false,
+                operation_identity: `close_binary:snapshot:${parsed.snapshot_path}`,
+            }, "write");
+            if (!authorized.ok)
+                return toCallToolResult(permissionFailure(authorized), closeContract);
+        }
+        const snapshot = session.exportAnalysisSnapshot();
+        if (!snapshot.ok)
+            return toCallToolResult(snapshot, closeContract);
+        const written = await writeAnalysisSnapshot(snapshot.value, parsed.snapshot_path, parsed.overwrite, snapshotFilePolicy);
+        if (!written.ok)
+            return toCallToolResult(written, closeContract);
         const closed = await logToolExecution(logger, closeContract.name, () => session.close());
         if (closed.ok)
             server.sendToolListChanged();
-        return toCallToolResult(closed, closeContract);
+        return closed.ok
+            ? toCallToolResult(ok({
+                path: written.value.path,
+                bytes: written.value.bytes,
+                entries: snapshot.value.entries.length,
+            }), closeContract)
+            : toCallToolResult(closed, closeContract);
     });
-    registerSessionStatusTool(server, session, statusContract, startedAt, availabilityPolicy);
 };
 export const registerSessionTools = (server, session, logger, options = {}) => {
     const processPolicy = options.processPolicy ?? DENY_PROCESS_POLICY;
     const evidenceFilePolicy = options.evidenceFilePolicy ?? DENY_EVIDENCE_FILE_POLICY;
     const analysisSnapshotFilePolicy = options.analysisSnapshotFilePolicy ?? DENY_EVIDENCE_FILE_POLICY;
-    const [openContract, closeContract, statusContract, exportContract, importContract, captureContract, compareContract, compareArtifactsContract, compareFunctionsContract, compareBundlesContract, changedBehaviorContract, callPathContract, staticRuntimeContract, reconstructionContract, listUnknownContract, recordUnknownContract, updateUnknownContract, verifyUnknownContract,] = SESSION_TOOL_CONTRACTS;
+    const [openContract, closeContract, statusContract, exportContract, importContract, captureContract, compareContract, compareArtifactsContract, compareFunctionsContract, compareBundlesContract, changedBehaviorContract, callPathContract, staticRuntimeContract, reconstructionContract,] = SESSION_TOOL_CONTRACTS;
     registerLifecycleTools({
         server,
         session,
@@ -318,15 +224,7 @@ export const registerSessionTools = (server, session, logger, options = {}) => {
         contracts: [openContract, closeContract, statusContract],
         snapshotFilePolicy: analysisSnapshotFilePolicy,
         startedAt: options.startedAt ?? new Date().toISOString(),
-        availabilityPolicy: options.availabilityPolicy ??
-            (() => ({
-                processCaptureEnabled: processPolicy.enabled,
-                evidenceFileRoots: evidenceFilePolicy.roots.length,
-                browserObservationEnabled: false,
-                electronObservationEnabled: false,
-                javascriptReplayEnabled: false,
-                managedRuntimeEnabled: false,
-            })),
+        availabilityPolicy: sessionAvailabilityPolicy(options.availabilityPolicy, processPolicy, evidenceFilePolicy),
         ...(options.permissionAuthority === undefined
             ? {}
             : { permissionAuthority: options.permissionAuthority }),
@@ -350,6 +248,9 @@ export const registerSessionTools = (server, session, logger, options = {}) => {
         ...(options.permissionAuthority === undefined
             ? {}
             : { permissionAuthority: options.permissionAuthority }),
+        ...(options.processCaptureElicitation === undefined
+            ? {}
+            : { processCaptureElicitation: options.processCaptureElicitation }),
     });
     registerProcessComparisonTool(server, session, compareContract);
     registerArtifactComparisonTool(server, session, compareArtifactsContract);
@@ -376,11 +277,6 @@ export const registerSessionTools = (server, session, logger, options = {}) => {
     registerUnknownTools({
         server,
         session,
-        contracts: [
-            listUnknownContract,
-            recordUnknownContract,
-            updateUnknownContract,
-            verifyUnknownContract,
-        ],
+        contracts: SESSION_TOOL_CONTRACTS,
     });
 };

package/dist/server/sessionAvailabilityPolicy.js

@@ -0,0 +1,10 @@
+/** Select configured availability reporting or the target-free defaults. */
+export const sessionAvailabilityPolicy = (configured, processPolicy, evidenceFilePolicy) => configured ??
+    (() => ({
+        processCaptureEnabled: processPolicy.enabled,
+        evidenceFileRoots: evidenceFilePolicy.roots.length,
+        browserObservationEnabled: false,
+        electronObservationEnabled: false,
+        javascriptReplayEnabled: false,
+        managedRuntimeEnabled: false,
+    }));

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

@@ -45,6 +45,11 @@ const successResult = (value, contract, options) => {
             { type: "text", text: JSON.stringify(parsed.data) },
             ...evidenceResourceLinks(value, contract.kind === "session" ||
                 options.evidenceResourcesAvailable === true),
+            ...(options.resourceLinks ?? []).map((resource) => ({
+                type: "resource_link",
+                ...resource,
+                mimeType: "application/json",
+            })),
         ],
         structuredContent: candidate,
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rea-agents",
-  "version": "2.0.0",
+  "version": "2.1.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,6 +73,7 @@
     "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",
@@ -83,8 +82,11 @@
     "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 +94,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 +103,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 +118,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 +143,5 @@
     "typedoc": "0.28.20",
     "typescript": "5.9.3",
     "vitest": "4.1.10"
-  },
-  "allowScripts": {
-    "node-pty@1.1.0": true
   }
 }

package/skills/{rea-analysis → reverse-engineer-anything}/SKILL.md

@@ -1,10 +1,10 @@
 ---
-name: rea-analysis
-description: Reverse engineer native, Electron/JavaScript, and web applications with REA. Connect static artifacts to passive runtime evidence, explain how features work, and build a version tailored to the user's project.
+name: reverse-engineer-anything
+description: Reverse engineer native, Electron/JavaScript, and web application artifacts or runtimes with REA. Connect static artifacts to passive runtime evidence, explain how features work, and build a version tailored to the user's project. Skip REA setup for ordinary source-repository architecture analysis.
 metadata:
-  version: "20"
-  tool_count: 91
-  catalog_digest: "bdf382596e1a00ffc9d59de287b2ad647eeebe629c48a8f8cf158b300363ce53"
+  version: "22"
+  tool_count: 95
+  catalog_digest: "e0c341749f488a869b62ab9b48c9236c60c91317ac60c8427f12a830cb900ae0"
 ---
 
 # REA
@@ -95,15 +95,28 @@ literal approval and `evidence_write` authority after sandbox cleanup.
 
 Identify the app and what the user wants to understand or build. Do not ask for information they already provided.
 
+First decide whether REA evidence is needed. When the complete source repository
+is available and the request is ordinary source-level architecture, code-flow,
+or implementation analysis, use normal repository tools and skip REA readiness,
+setup, and binary-provider commands. Use REA only when the request needs evidence
+from a binary, package, built artifact, decompilation, passive application
+runtime, controlled replay, or comparison against behavior not established by
+the available source. If the source is available but the requested claim still
+depends on built or runtime behavior, explain that distinction and continue with
+the relevant REA workflow.
+
 If the app is missing, ask which app they want to reverse engineer. If the app is known but the goal is unclear, ask what they want to understand or build, and offer to start with an overview. Never require the user to supply a program path, address, architecture, or reverse-engineering terminology.
 
 Notes is only a documentation example. Never select an app unless the user names it or confirms it.
 
 ## Ensure REA is ready
 
-1. Run `npx -y rea-agents doctor`.
+Run this section only after the request-routing decision establishes that REA
+evidence is needed.
+
+1. Run `npx -y rea-agents@latest doctor`.
 2. If setup is needed, tell the user REA needs to install its local binary-analysis tools. Do not lead with implementation details or assume the user knows reverse-engineering products.
-3. Before installing external software, obtain approval and identify what will be installed. If deeper analysis needs Hopper, describe it as REA's local analysis engine and note that it is a separate Mac app with its own license. Then run `npx -y rea-agents setup --yes`.
+3. Before installing external software, obtain approval and identify what will be installed. If deeper analysis needs Hopper, describe it as REA's local analysis engine and note that it is a separate Mac app with its own license. Then run `npx -y rea-agents@latest setup --yes`.
 4. If macOS or an installer requests human input, tell the user exactly what needs attention. After they finish, rerun setup and doctor.
 5. If setup registers a new MCP server, tell the user to restart their agent to load all REA tools. Direct CLI commands remain available before restart.
 

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;
-});