rea-agents 2.4.0 → 2.5.0

package/dist/server/registerEnhancedTools.js

@@ -12,9 +12,8 @@ import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { safeParseToolInput } from "./toolInputValidation.js";
 /** Register composed workflows against the same port as direct bridge tools. */
 export const registerEnhancedTools = (server, analysis, options) => {
-    const services = new EnhancedTools(analysis);
     for (const contract of ENHANCED_TOOL_CONTRACTS) {
-        registerEnhancedTool(server, services, contract, {
+        registerEnhancedTool(server, analysis, contract, {
             logger: options.logger,
             activeTarget: options.activeTarget,
             analysisProfile: options.analysisProfile,
@@ -23,7 +22,7 @@ export const registerEnhancedTools = (server, analysis, options) => {
         });
     }
 };
-const registerEnhancedTool = (server, services, contract, registration) => {
+const registerEnhancedTool = (server, analysis, contract, registration) => {
     const name = enhancedToolNameSchema.parse(contract.name);
     server.registerTool(name, toolRegistrationOptions(contract), async (input, context) => {
         const progress = mcpProgressReporter(context);
@@ -38,6 +37,12 @@ const registerEnhancedTool = (server, services, contract, registration) => {
             return toCallToolResult(validatedCall, contract);
         const parsedInput = validatedCall.value.input;
         const parameters = jsonParameters(parsedInput);
+        const services = new EnhancedTools({
+            execute: (operation, operationParameters, executionOptions) => analysis.execute(operation, operationParameters, {
+                ...executionOptions,
+                progress,
+            }),
+        });
         const result = await logToolExecution(registration.logger, name, () => services.executeValidated(validatedCall.value, context.mcpReq.signal));
         await progress.report({
             phase: name,
@@ -93,6 +98,8 @@ const ENHANCED_INPUT_PARSERS = {
     binary_overview: (input) => safeParseToolInput(enhancedInputSchemas.binary_overview, input, "binary_overview"),
     analyze_function: (input) => safeParseToolInput(enhancedInputSchemas.analyze_function, input, "analyze_function"),
     trace_feature: (input) => safeParseToolInput(enhancedInputSchemas.trace_feature, input, "trace_feature"),
+    find_code_for_string: (input) => safeParseToolInput(enhancedInputSchemas.find_code_for_string, input, "find_code_for_string"),
+    trace_call_path: (input) => safeParseToolInput(enhancedInputSchemas.trace_call_path, input, "trace_call_path"),
 };
 const parseEnhancedCall = (name, input) => {
     switch (name) {
@@ -116,11 +123,15 @@ const parseEnhancedCall = (name, input) => {
             return mapEnhancedCall(ENHANCED_INPUT_PARSERS.analyze_function(input), (value) => ({ name, input: value }));
         case "trace_feature":
             return mapEnhancedCall(ENHANCED_INPUT_PARSERS.trace_feature(input), (value) => ({ name, input: value }));
+        case "find_code_for_string":
+            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.find_code_for_string(input), (value) => ({ name, input: value }));
+        case "trace_call_path":
+            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.trace_call_path(input), (value) => ({ name, input: value }));
     }
 };
 const mapEnhancedCall = (parsed, project) => parsed.ok ? ok(project(parsed.value)) : parsed;
 const recordWorkflowUnknowns = ({ name, input, result, evidenceId, recordUnknown, }) => {
-    if (name !== "trace_feature" ||
+    if (!["trace_feature", "find_code_for_string", "trace_call_path"].includes(name) ||
         input.unknown_registry_approved !== true ||
         recordUnknown === undefined ||
         typeof result !== "object" ||
@@ -143,7 +154,7 @@ const recordWorkflowUnknowns = ({ name, input, result, evidenceId, recordUnknown
             required_environment: null,
             recommended_probes: [
                 {
-                    operation: "trace_feature",
+                    operation: name,
                     rationale: "Continue with a larger bounded budget.",
                 },
             ],

package/dist/server/registerEvidenceResources.js

@@ -2,6 +2,8 @@ import { ResourceNotFoundError, ResourceTemplate, } from "@modelcontextprotocol/
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
 import { registerJavaScriptApplicationGraphResource } from "./registerJavaScriptApplicationGraphResource.js";
+import { registerReconstructionObligationLedgerResource } from "./registerReconstructionObligationLedgerResource.js";
+import { registerReconstructionReadinessResource } from "./registerReconstructionReadinessResource.js";
 const evidenceUri = (evidenceId) => `rea://evidence/${evidenceId}`;
 /** Expose immutable session-owned Evidence v2 records as MCP resources. */
 export const registerEvidenceResources = (server, session) => {
@@ -13,6 +15,8 @@ export const registerEvidenceResources = (server, session) => {
     registerArtifactPageResource(server, session);
     registerFunctionDossierResource(server, session);
     registerEvidenceSectionResource(server, session);
+    registerReconstructionObligationLedgerResource(server, session);
+    registerReconstructionReadinessResource(server, session);
     registerJavaScriptApplicationGraphResource(server, session);
     registerResidualUnknownResource(server, session);
 };

package/dist/server/registerEvidenceTools.js

@@ -47,6 +47,7 @@ export const registerEvidenceTools = (server, analysis, contracts, options) => {
             });
             if (!execution.ok)
                 return toCallToolResult(execution, contract);
+            const sourceEvidence = options.sourceEvidence?.(contract.name, execution.value.result) ?? [];
             const evidence = createEvidence(execution.value.subject ?? options.activeTarget?.(), execution.value.provider, {
                 operation: contract.name,
                 parameters,
@@ -54,7 +55,13 @@ export const registerEvidenceTools = (server, analysis, contracts, options) => {
                 rawResult: execution.value.rawResult,
                 limitations: execution.value.limitations,
                 locations: execution.value.locations,
+                evidenceLinks: sourceEvidence.map(({ evidence_id: id }) => id),
             });
+            for (const source of sourceEvidence) {
+                const sourceRecorded = options.recordEvidence?.(source);
+                if (sourceRecorded !== undefined && !sourceRecorded.ok)
+                    return toCallToolResult(sourceRecorded, contract);
+            }
             const recorded = options.recordEvidence?.(evidence);
             return recorded !== undefined && !recorded.ok
                 ? toCallToolResult(recorded, contract)
@@ -76,7 +83,7 @@ const permissionRequest = (operation, parameters) => {
             mount: false,
             operation_identity: `extract_artifact:${parameters.output_root}`,
         };
-    if (operation === "inventory_artifact" &&
+    if (["inventory_artifact", "inspect_artifact"].includes(operation) &&
         parameters.native_mount_approved === true)
         return {
             capability: "native_mount",
@@ -85,7 +92,7 @@ const permissionRequest = (operation, parameters) => {
             environment_names: [],
             network: "none",
             mount: true,
-            operation_identity: "inventory_artifact:native_mount",
+            operation_identity: `${operation}:native_mount`,
         };
     return undefined;
 };

package/dist/server/registerJavaScriptRuntimeObservationTools.js

@@ -0,0 +1,37 @@
+import { listJavaScriptRuntimeTargets, observeJavaScriptRuntime, } from "../application/JavaScriptRuntimeObservationService.js";
+import { JAVASCRIPT_RUNTIME_OBSERVATION_TOOL_CONTRACTS } from "../contracts/javascriptRuntimeObservationToolContracts.js";
+import { listJavaScriptRuntimeTargetsInputSchema, observeJavaScriptRuntimeInputSchema, } from "../domain/javascriptRuntimeObservation.js";
+import { logToolExecution } from "./toolLogging.js";
+import { safeParseToolInput } from "./toolInputValidation.js";
+import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+import { toCallToolResult } from "./toolResult.js";
+/** Register passive Inspector tools even when policy keeps them unavailable. */
+export const registerJavaScriptRuntimeObservationTools = (server, options) => {
+    const [listContract, observeContract] = JAVASCRIPT_RUNTIME_OBSERVATION_TOOL_CONTRACTS;
+    registerRuntimeTool(server, options, {
+        contract: listContract,
+        schema: listJavaScriptRuntimeTargetsInputSchema,
+        execute: (parsed, signal) => listJavaScriptRuntimeTargets(options.runtime, options.permissionAuthority, parsed, { signal }),
+    });
+    registerRuntimeTool(server, options, {
+        contract: observeContract,
+        schema: observeJavaScriptRuntimeInputSchema,
+        execute: (parsed, signal) => observeJavaScriptRuntime(options.runtime, options.permissionAuthority, parsed, { signal }),
+    });
+};
+const registerRuntimeTool = (server, options, spec) => {
+    server.registerTool(spec.contract.name, toolRegistrationOptions(spec.contract), async (input, context) => {
+        const parsed = safeParseToolInput(spec.schema, input, spec.contract.name);
+        if (!parsed.ok)
+            return toCallToolResult(parsed, spec.contract);
+        const result = await logToolExecution(options.logger, spec.contract.name, () => spec.execute(parsed.value, context.mcpReq.signal));
+        if (!result.ok)
+            return toCallToolResult(result, spec.contract);
+        const recorded = options.recordEvidence?.(result.value);
+        return recorded !== undefined && !recorded.ok
+            ? toCallToolResult(recorded, spec.contract)
+            : toCallToolResult({ ok: true, value: result.value }, spec.contract, {
+                evidenceResourcesAvailable: recorded !== undefined,
+            });
+    });
+};

package/dist/server/registerReconstructionObligationLedgerResource.js

@@ -0,0 +1,39 @@
+import { ResourceNotFoundError, ResourceTemplate, } from "@modelcontextprotocol/server";
+import { reconstructionObligationLedgerPageSchema } from "../domain/reconstructionObligationLedgerSchemas.js";
+/** Expose retained obligation-ledger pages as typed Evidence resources. */
+export const registerReconstructionObligationLedgerResource = (server, session) => {
+    server.registerResource("reconstruction-obligation-ledger-page", new ResourceTemplate("rea://evidence/{evidenceId}/reconstruction-obligation-ledger", {
+        list: undefined,
+        complete: {
+            evidenceId: (prefix) => session
+                .exportEvidenceBundle()
+                .records.filter(({ predicate_type: predicateType }) => predicateType === "rea.reconstruction-obligation-ledger/v1")
+                .map(({ evidence_id: evidenceId }) => evidenceId)
+                .filter((evidenceId) => evidenceId.startsWith(prefix)),
+        },
+    }), {
+        title: "Reconstruction obligation ledger page",
+        description: "One deterministic Evidence v2-backed obligation page with full-ledger closure digest and summaries.",
+        mimeType: "application/json",
+    }, (uri, variables) => {
+        const evidenceId = variables.evidenceId;
+        if (typeof evidenceId !== "string")
+            throw new ResourceNotFoundError(uri.href);
+        const evidence = session.evidenceById(evidenceId);
+        if (evidence === undefined ||
+            evidence.predicate_type !== "rea.reconstruction-obligation-ledger/v1")
+            throw new ResourceNotFoundError(uri.href);
+        const page = reconstructionObligationLedgerPageSchema.safeParse(evidence.normalized_result);
+        if (!page.success)
+            throw new ResourceNotFoundError(uri.href);
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify({ evidence_id: evidence.evidence_id, page: page.data }, null, 2),
+                },
+            ],
+        };
+    });
+};

package/dist/server/registerReconstructionReadinessResource.js

@@ -0,0 +1,39 @@
+import { ResourceNotFoundError, ResourceTemplate, } from "@modelcontextprotocol/server";
+import { reconstructionReadinessReportSchema } from "../domain/reconstructionReadinessSchemas.js";
+/** Expose retained full readiness reports outside compact tool responses. */
+export const registerReconstructionReadinessResource = (server, session) => {
+    server.registerResource("reconstruction-readiness-report", new ResourceTemplate("rea://evidence/{evidenceId}/reconstruction-readiness-report", {
+        list: undefined,
+        complete: {
+            evidenceId: (prefix) => session
+                .exportEvidenceBundle()
+                .records.filter(({ predicate_type: predicateType }) => predicateType === "rea.reconstruction-readiness-report/v1")
+                .map(({ evidence_id: evidenceId }) => evidenceId)
+                .filter((evidenceId) => evidenceId.startsWith(prefix)),
+        },
+    }), {
+        title: "Reconstruction readiness report",
+        description: "Full deterministic nine-stage conformance report and replay identity.",
+        mimeType: "application/json",
+    }, (uri, variables) => {
+        const evidenceId = variables.evidenceId;
+        if (typeof evidenceId !== "string")
+            throw new ResourceNotFoundError(uri.href);
+        const evidence = session.evidenceById(evidenceId);
+        if (evidence === undefined ||
+            evidence.predicate_type !== "rea.reconstruction-readiness-report/v1")
+            throw new ResourceNotFoundError(uri.href);
+        const report = reconstructionReadinessReportSchema.safeParse(evidence.normalized_result);
+        if (!report.success)
+            throw new ResourceNotFoundError(uri.href);
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify({ evidence_id: evidence.evidence_id, report: report.data }, null, 2),
+                },
+            ],
+        };
+    });
+};

package/dist/server/registerSessionStatusTool.js

@@ -15,9 +15,15 @@ export const registerSessionStatusTool = (options) => {
         const parsed = parsedInput.value;
         const client = server.server.getClientVersion();
         const clientCapabilities = server.server.getClientCapabilities();
+        const clientFeatures = {
+            elicitation_form: clientCapabilities?.elicitation?.form !== undefined,
+            elicitation_url: clientCapabilities?.elicitation?.url !== undefined,
+            roots: clientCapabilities?.roots !== undefined,
+            sampling: clientCapabilities?.sampling !== undefined,
+        };
         const status = session.status();
         const statusObject = jsonObjectSchema.parse(status);
-        const toolAvailability = buildCapabilityInventory(status, availabilityPolicy());
+        const toolAvailability = buildCapabilityInventory(status, availabilityPolicy(), clientFeatures);
         const serverIdentity = createServerIdentity({
             startedAt,
             expected: {
@@ -45,12 +51,7 @@ export const registerSessionStatusTool = (options) => {
                 status: statusObject,
                 toolAvailability,
                 serverIdentity,
-                clientFeatures: {
-                    elicitation_form: clientCapabilities?.elicitation?.form !== undefined,
-                    elicitation_url: clientCapabilities?.elicitation?.url !== undefined,
-                    roots: clientCapabilities?.roots !== undefined,
-                    sampling: clientCapabilities?.sampling !== undefined,
-                },
+                clientFeatures,
             }),
         }, contract);
     });
@@ -86,6 +87,7 @@ const projectSessionStatus = (options) => {
                 next_cursor: nextCursor < filtered.length ? nextCursor : null,
                 has_more: nextCursor < filtered.length,
             },
+            client_features: options.clientFeatures,
         });
     }
     return jsonObjectSchema.parse({
@@ -95,6 +97,7 @@ const projectSessionStatus = (options) => {
         active_provider: activeProvider,
         target: open ? targetFrom(options.status) : null,
         alignment: options.serverIdentity.alignment,
+        analysis_activity: options.status.analysis_activity,
         recommended_actions: recommendedActions(open, options.serverIdentity.alignment.state),
     });
 };
@@ -115,7 +118,7 @@ const recommendedActions = (open, alignment) => [
         : []),
     ...(!open
         ? [
-            "Route the supplied target directly: ASAR/JavaScript to analyze_javascript_application, packages to inventory_artifact, managed PE/CLI to inspect_managed_artifact, browser/Electron runtimes to their list-target tools, and native binaries to open_binary.",
+            "Route the supplied target directly: ASAR/JavaScript to analyze_javascript_application, unfamiliar packages to inspect_artifact, managed PE/CLI to inspect_managed_artifact, browser/Electron runtimes to their list-target tools, and native binaries to open_binary.",
         ]
         : [
             "Continue from the active target with binary_overview or a bounded target-specific query.",

package/dist/server/registerSessionTools.js

@@ -2,12 +2,12 @@ import { z } from "zod";
 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 { ok } from "../domain/result.js";
 import { processScenarioSchema } from "../domain/processCapture.js";
 import { captureProcessScenario } from "../application/ProcessHarness.js";
 import { processCapturePermissionRequest } from "../application/ProcessCapturePermission.js";
-import { readAnalysisSnapshot, writeAnalysisSnapshot, } from "../application/AnalysisSnapshotFiles.js";
-import { AnalysisProtocolError, PermissionRequiredError, UnknownRegistryError, } from "../domain/errors.js";
+import { readAnalysisSnapshot } from "../application/AnalysisSnapshotFiles.js";
+import { UnknownRegistryError } from "../domain/errors.js";
 import { DENY_EVIDENCE_FILE_POLICY, DENY_PROCESS_POLICY, } from "./sessionToolPolicies.js";
 import { createProcessCaptureEvidence } from "../application/ProcessEvidence.js";
 import { registerProcessComparisonTool } from "./registerProcessComparisonTool.js";
@@ -17,7 +17,7 @@ import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { safeParseToolInput } from "./toolInputValidation.js";
 import { registerBundleComparisonTool } from "./registerBundleComparisonTool.js";
 import { registerInvestigationTools } from "./registerInvestigationTools.js";
-import { closeBinaryInputSchema, openBinaryInputSchema, } from "../contracts/sessionLifecycleInputs.js";
+import { openBinaryInputSchema } from "../contracts/sessionLifecycleInputs.js";
 import { registerSessionStatusTool } from "./registerSessionStatusTool.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
 import { authorizeProcessCaptureWithElicitation, } from "./ProcessCaptureElicitation.js";
@@ -25,15 +25,8 @@ import { isInputRequiredResult } from "@modelcontextprotocol/server";
 import { registerEvidenceTools, registerUnknownTools, } from "./registerSessionRecordTools.js";
 import { registerReplayMachineTool } from "./registerReplayMachineTool.js";
 import { sessionAvailabilityPolicy, } from "./sessionAvailabilityPolicy.js";
-const permissionFailure = (failure) => {
-    if (failure.ok)
-        return err(new AnalysisProtocolError("Expected a denied permission"));
-    return err(failure.error instanceof PermissionRequiredError
-        ? failure.error
-        : new AnalysisProtocolError(failure.error.message, {
-            cause: failure.error,
-        }));
-};
+import { permissionFailure } from "./permissionFailure.js";
+import { registerCloseLifecycleTool } from "./registerCloseLifecycleTool.js";
 const recordProcessResidualUnknowns = (session, scenario, evidence, residuals) => {
     if (scenario.unknown_registry_approved !== true)
         return ok(null);
@@ -170,49 +163,6 @@ const registerOpenLifecycleTool = ({ server, session, logger, contracts: [openCo
             : 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) {
-            const closed = await logToolExecution(logger, closeContract.name, () => session.close());
-            if (closed.ok)
-                server.sendToolListChanged();
-            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 closed.ok
-            ? toCallToolResult(ok({
-                path: written.value.path,
-                bytes: written.value.bytes,
-                entries: snapshot.value.entries.length,
-            }), closeContract)
-            : toCallToolResult(closed, closeContract);
-    });
-};
 const registerRecordAndReplayTools = (server, session, logger) => {
     registerUnknownTools({
         server,
@@ -233,7 +183,11 @@ export const registerSessionTools = (server, session, logger, options = {}) => {
         contracts: [openContract, closeContract, statusContract],
         snapshotFilePolicy: analysisSnapshotFilePolicy,
         startedAt: options.startedAt ?? new Date().toISOString(),
-        availabilityPolicy: sessionAvailabilityPolicy(options.availabilityPolicy, processPolicy, evidenceFilePolicy, options.investigationInputRoots ?? []),
+        availabilityPolicy: sessionAvailabilityPolicy(options.availabilityPolicy, {
+            processPolicy,
+            evidenceFilePolicy,
+            investigationInputRoots: options.investigationInputRoots ?? [],
+        }),
         ...(options.permissionAuthority === undefined
             ? {}
             : { permissionAuthority: options.permissionAuthority }),

package/dist/server/sessionAvailabilityPolicy.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rea-agents",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "description": "Reverse engineer anything from your terminal or agent with one CLI and MCP server.",
   "license": "MIT",
   "repository": {
@@ -80,25 +80,29 @@
     "test": "vitest run",
     "test:run": "vitest run",
     "pretest:fast": "npm run build:cached",
-    "test:fast": "vitest run --project parallel",
+    "test:fast": "vitest run --project parallel --project subprocess",
+    "pretest:changed": "npm run build:cached",
+    "test:changed": "vitest run --project parallel --project subprocess --changed",
     "pretest:integration": "npm run build:cached",
     "test:integration": "vitest run --project serial-integration",
     "pretest:coverage": "npm run build:cached",
     "test:coverage": "vitest run --coverage.enabled --coverage.provider=v8",
     "test:ci": "npm run test:coverage -- --reporter=default --reporter=junit --outputFile.junit=test-results.xml",
     "pretest:ci:shard": "npm run build:cached",
-    "test:ci:shard": "vitest run --coverage.enabled --coverage.provider=v8 --coverage.thresholds.lines=0 --coverage.thresholds.functions=0 --coverage.thresholds.branches=0 --coverage.thresholds.statements=0 --reporter=default --reporter=blob",
+    "test:ci:shard": "npm run test:ci:shard:run",
+    "test:ci:shard:run": "vitest run --coverage.enabled --coverage.provider=v8 --coverage.thresholds.lines=0 --coverage.thresholds.functions=0 --coverage.thresholds.branches=0 --coverage.thresholds.statements=0 --reporter=default --reporter=blob",
     "test:ci:merge": "vitest --merge-reports --coverage.enabled --coverage.provider=v8 --reporter=default --reporter=junit --outputFile.junit=test-results.xml",
     "pretest:verbose": "npm run build:cached",
     "test:verbose": "vitest run --reporter=verbose",
     "pretest:watch": "npm run build:cached",
-    "test:watch": "vitest --project parallel --changed",
+    "test:watch": "vitest --project parallel --project subprocess --changed",
     "typecheck": "tsc --noEmit",
     "verify:test-temp-hygiene": "npm run build:cached && node scripts/verify-test-temp-hygiene.mjs",
     "verify:hopper": "npm run verify:fixtures && npm run build:cached && node scripts/verify-real-hopper.mjs",
     "verify:ghidra": "npm run build:cached && node scripts/verify-real-ghidra.mjs",
     "verify:ghidra:windows": "npm run build:cached && npm run build:ghidra-windows-fixture && node scripts/verify-real-ghidra-windows.mjs",
     "verify:browser": "npm run build:cached && node scripts/verify-real-browser.mjs",
+    "verify:inspector": "npm run build:cached && node scripts/verify-real-javascript-runtime-observation.mjs",
     "verify:javascript-runtime": "npm run build:cached && node scripts/verify-local-javascript-runtime.mjs",
     "verify:application-workflows": "npm run build:cached && node scripts/verify-local-application-workflows.mjs",
     "verify:managed": "npm run build:cached && node scripts/verify-managed-conformance.mjs",
@@ -109,6 +113,7 @@
     "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:readiness": "npm run build:cached && npm run verify:fixtures && node scripts/verify-reconstruction-readiness.mjs",
     "verify:package": "npm run build:cached && node scripts/verify-package.mjs",
     "verify:package:windows": "npm run build:cached && node scripts/verify-windows-package.mjs",
     "probe:windows-capabilities": "npm run build:cached && node scripts/windows-capabilities.mjs",
@@ -139,8 +144,8 @@
     "@electron/asar": "4.2.0",
     "@jridgewell/trace-mapping": "0.3.31",
     "@lydell/node-pty": "1.1.0",
-    "@modelcontextprotocol/server": "2.0.0-beta.4",
     "@modelcontextprotocol/client": "2.0.0-beta.4",
+    "@modelcontextprotocol/server": "2.0.0-beta.4",
     "@xterm/addon-serialize": "0.14.0",
     "@xterm/headless": "6.0.0",
     "@zip.js/zip.js": "2.8.26",
@@ -152,6 +157,7 @@
     "incur": "0.4.13",
     "isomorphic-git": "1.38.7",
     "pino": "9.14.0",
+    "playwright-core": "1.58.2",
     "plist": "5.0.0",
     "semver": "7.8.5",
     "smol-toml": "^1.7.0",
@@ -172,8 +178,8 @@
     "lint-staged": "16.4.0",
     "oxlint": "1.73.0",
     "prettier": "3.6.2",
-    "typedoc": "0.28.20",
     "turbo": "2.10.5",
+    "typedoc": "0.28.20",
     "typescript": "5.9.3",
     "vitest": "4.1.10"
   }

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

@@ -3,8 +3,8 @@ 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: 98
-  catalog_digest: "aa413204625f3aeb62732d0f732b9b8b24832eea4520214b1e6bd204e599bcd6"
+  tool_count: 110
+  catalog_digest: "e8cac51f2f17a5b9a088c3ff773473c4897823401481fc0875a28fe7daf8eee0"
 ---
 
 # REA