rea-agents 3.0.0 → 3.1.0

package/dist/server/registerSessionTools.js

@@ -1,33 +1,30 @@
 import { z } from "zod";
-import { addressContextInputSchema, navigationContextInputSchema, SESSION_TOOL_CONTRACTS, } from "../contracts/toolContracts.js";
-import { toCallToolResult } from "./toolResult.js";
-import { logToolExecution } from "./toolLogging.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 { isInputRequiredResult } from "@modelcontextprotocol/server";
+import { getNavigationContext, inspectAddressContext, } from "../application/AnalysisContextQueries.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 { processCapturePermissionRequest } from "../application/ProcessCapturePermission.js";
 import { createProcessCaptureEvidence } from "../application/ProcessEvidence.js";
-import { registerProcessComparisonTool } from "./registerProcessComparisonTool.js";
+import { captureProcessScenario } from "../application/ProcessHarness.js";
+import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
+import { UnknownRegistryError } from "../domain/errors.js";
+import { ok } from "../domain/result.js";
+import { mcpProgressReporter } from "./mcpProgress.js";
+import { permissionFailure } from "./permissionFailure.js";
+import { authorizeProcessCaptureWithElicitation, } from "./ProcessCaptureElicitation.js";
 import { registerArtifactComparisonTool } from "./registerArtifactComparisonTool.js";
-import { registerFunctionComparisonTool } from "./registerFunctionComparisonTool.js";
-import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { safeParseToolInput } from "./toolInputValidation.js";
 import { registerBundleComparisonTool } from "./registerBundleComparisonTool.js";
+import { registerCloseLifecycleTool } from "./registerCloseLifecycleTool.js";
+import { registerFunctionComparisonTool } from "./registerFunctionComparisonTool.js";
 import { registerInvestigationTools } from "./registerInvestigationTools.js";
-import { 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 { registerProcessComparisonTool } from "./registerProcessComparisonTool.js";
 import { registerReplayMachineTool } from "./registerReplayMachineTool.js";
+import { registerEvidenceTools, registerUnknownTools, } from "./registerSessionRecordTools.js";
+import { registerSessionStatusTool } from "./registerSessionStatusTool.js";
 import { sessionAvailabilityPolicy, } from "./sessionAvailabilityPolicy.js";
-import { permissionFailure } from "./permissionFailure.js";
-import { registerCloseLifecycleTool } from "./registerCloseLifecycleTool.js";
-import { getNavigationContext, inspectAddressContext, } from "../application/AnalysisContextQueries.js";
+import { DENY_EVIDENCE_FILE_POLICY, DENY_PROCESS_POLICY, } from "./sessionToolPolicies.js";
+import { logToolExecution } from "./toolLogging.js";
+import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+import { toCallToolResult } from "./toolResult.js";
 const recordProcessResidualUnknowns = (session, scenario, evidence, residuals) => {
     if (scenario.unknown_registry_approved !== true)
         return ok(null);
@@ -59,10 +56,7 @@ const recordProcessResidualUnknowns = (session, scenario, evidence, residuals) =
 };
 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;
+        const scenario = input;
         if (permissionAuthority !== undefined) {
             const request = processCapturePermissionRequest(scenario);
             const authorized = processCaptureElicitation === undefined
@@ -80,7 +74,7 @@ const registerProcessTools = ({ server, session, logger, processPolicy, captureC
             total: 1,
             message: "started",
         });
-        const captured = await logToolExecution(logger, captureContract.name, () => captureProcessScenario(scenario, processPolicy, context.mcpReq.signal));
+        const captured = await logToolExecution(logger, captureContract.name, () => captureProcessScenario(scenario, processPolicy(), context.mcpReq.signal));
         await progress.report({
             phase: captureContract.name,
             completed: 1,
@@ -114,39 +108,33 @@ const registerLifecycleTools = (registration) => {
 };
 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)
-            return toCallToolResult(parsedInput, openContract);
-        const parsed = parsedInput.value;
         let snapshot;
-        if (parsed.snapshot_path !== undefined) {
+        if (input.snapshot_path !== undefined) {
             if (permissionAuthority !== undefined) {
                 const authorized = await permissionAuthority.authorize({
                     capability: "snapshot_read",
-                    roots: [parsed.snapshot_path],
+                    roots: [input.snapshot_path],
                     executables: [],
                     environment_names: [],
                     network: "none",
                     mount: false,
-                    operation_identity: `open_binary:snapshot:${parsed.snapshot_path}`,
+                    operation_identity: `open_binary:snapshot:${input.snapshot_path}`,
                 }, "read");
                 if (!authorized.ok)
                     return toCallToolResult(permissionFailure(authorized), openContract);
             }
-            const loaded = await readAnalysisSnapshot(parsed.snapshot_path, snapshotFilePolicy);
+            const loaded = await readAnalysisSnapshot(input.snapshot_path, snapshotFilePolicy);
             if (!loaded.ok)
                 return toCallToolResult(loaded, openContract);
             snapshot = loaded.value;
         }
-        const opened = await logToolExecution(logger, openContract.name, () => session.open(parsed.path, {
+        const opened = await logToolExecution(logger, openContract.name, () => session.open(input.path, {
             signal: context.mcpReq.signal,
-            ...(parsed.provider_id === undefined
+            ...(input.provider_id === undefined
                 ? {}
-                : { providerId: parsed.provider_id }),
+                : { providerId: input.provider_id }),
             ...(snapshot === undefined ? {} : { snapshot }),
         }));
-        if (opened.ok)
-            server.sendToolListChanged();
         return opened.ok
             ? toCallToolResult({
                 ok: true,
@@ -173,27 +161,22 @@ const registerRecordAndReplayTools = (server, session, logger) => {
     registerReplayMachineTool(server, logger);
 };
 const registerContextTools = (server, session) => {
-    const navigationContract = SESSION_TOOL_CONTRACTS[20];
-    const addressContract = SESSION_TOOL_CONTRACTS[21];
+    const navigationContract = SESSION_TOOL_CONTRACTS[21];
+    const addressContract = SESSION_TOOL_CONTRACTS[22];
     server.registerTool(navigationContract.name, toolRegistrationOptions(navigationContract), async (input, context) => {
-        const parsed = safeParseToolInput(navigationContextInputSchema, input, navigationContract.name);
-        if (!parsed.ok)
-            return toCallToolResult(parsed, navigationContract);
-        return toCallToolResult(await getNavigationContext(session, parsed.value, context.mcpReq.signal), navigationContract);
+        return toCallToolResult(await getNavigationContext(session, input, context.mcpReq.signal), navigationContract);
     });
     server.registerTool(addressContract.name, toolRegistrationOptions(addressContract), async (input, context) => {
-        const parsed = safeParseToolInput(addressContextInputSchema, input, addressContract.name);
-        if (!parsed.ok)
-            return toCallToolResult(parsed, addressContract);
-        return toCallToolResult(await inspectAddressContext(session, parsed.value, context.mcpReq.signal), addressContract);
+        return toCallToolResult(await inspectAddressContext(session, input, context.mcpReq.signal), addressContract);
     });
 };
 export const registerSessionTools = (server, session, logger, options = {}) => {
-    const processPolicy = options.processPolicy ?? DENY_PROCESS_POLICY;
+    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,] = SESSION_TOOL_CONTRACTS;
     const snapshotContract = SESSION_TOOL_CONTRACTS[19];
+    const releaseContract = SESSION_TOOL_CONTRACTS[20];
     registerLifecycleTools({
         server,
         session,
@@ -202,7 +185,7 @@ export const registerSessionTools = (server, session, logger, options = {}) => {
         snapshotFilePolicy: analysisSnapshotFilePolicy,
         startedAt: options.startedAt ?? new Date().toISOString(),
         availabilityPolicy: sessionAvailabilityPolicy(options.availabilityPolicy, {
-            processPolicy,
+            processPolicy: processPolicy(),
             evidenceFilePolicy,
             investigationInputRoots: options.investigationInputRoots ?? [],
         }),
@@ -216,6 +199,7 @@ export const registerSessionTools = (server, session, logger, options = {}) => {
         exportContract,
         importContract,
         snapshotContract,
+        releaseContract,
         filePolicy: evidenceFilePolicy,
         ...(options.permissionAuthority === undefined
             ? {}

package/dist/server/sessionAvailabilityPolicy.js

@@ -1,12 +1,13 @@
 /** Select configured availability reporting or the target-free defaults. */
 export const sessionAvailabilityPolicy = (configured, defaults) => configured ??
     (() => ({
-        processCaptureEnabled: defaults.processPolicy.enabled,
+        processCaptureEnabled: defaults.processPolicy.status === "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,
+        electronAutomationEnabled: defaults.optionalFeatures?.electronAutomationEnabled ?? false,
         v8InspectorObservationEnabled: defaults.optionalFeatures?.v8InspectorObservationEnabled ?? false,
         javascriptReplayEnabled: defaults.optionalFeatures?.javascriptReplayEnabled ?? false,
         managedRuntimeEnabled: defaults.optionalFeatures?.managedRuntimeEnabled ?? false,

package/dist/server/sessionToolPolicies.js

@@ -1,10 +1,6 @@
 /** Fail-closed process policy used when operator configuration is absent. */
 export const DENY_PROCESS_POLICY = {
-    enabled: false,
-    executableRoots: [],
-    workingRoots: [],
-    allowedEnvironment: [],
-    allowExternalNetwork: false,
+    status: "disabled",
 };
 /** Fail-closed evidence filesystem policy used without approved roots. */
 export const DENY_EVIDENCE_FILE_POLICY = {

package/dist/server/toolRegistrationOptions.js

@@ -1,197 +1,9 @@
-import { z } from "zod";
-const ADVERTISED_INPUT_SCHEMAS = new WeakMap();
-const ADVERTISED_OUTPUT_SCHEMAS = new WeakMap();
-/** Project the public contract fields accepted by MCP tool registration. */
+import { toolInputSchemaWithMetadata } from "../contracts/toolSchemaMetadata.js";
+/** Project the canonical Zod contracts directly into SDK registration. */
 export const toolRegistrationOptions = (contract) => ({
     title: contract.title,
     description: contract.description,
-    inputSchema: advertisedInputSchema(contract),
-    outputSchema: advertisedOutputSchema(contract.outputSchema),
+    inputSchema: toolInputSchemaWithMetadata(contract),
+    outputSchema: contract.outputSchema,
     annotations: contract.annotations,
 });
-/**
- * Advertise the exact Zod contract while leaving validation to REA's adapter.
- * The SDK otherwise converts validation failures to text-only JSON-RPC errors
- * before REA can return its stable structured error envelope.
- */
-const advertisedInputSchema = (contract) => ({
-    "~standard": {
-        version: 1,
-        vendor: "rea",
-        validate: (input) => ({ value: input }),
-        jsonSchema: {
-            input: () => advertisedInputJsonSchema(contract),
-            output: () => advertisedInputJsonSchema(contract),
-        },
-    },
-});
-const advertisedOutputSchema = (schema) => {
-    const standard = schema["~standard"];
-    const converter = standard.jsonSchema?.output;
-    if (converter === undefined)
-        throw new TypeError("Tool output schema does not expose Standard JSON Schema");
-    return {
-        "~standard": {
-            ...standard,
-            jsonSchema: {
-                input: () => advertisedOutputJsonSchema(schema, converter),
-                output: () => advertisedOutputJsonSchema(schema, converter),
-            },
-        },
-    };
-};
-const advertisedInputJsonSchema = (contract) => cachedJsonSchema(ADVERTISED_INPUT_SCHEMAS, contract.inputSchema, () => ({
-    ...describeProperties(closeObjectSchemas(inputJsonSchema(contract.inputSchema))),
-    examples: contract.examples.map(({ input }) => input),
-}));
-const advertisedOutputJsonSchema = (schema, converter) => cachedJsonSchema(ADVERTISED_OUTPUT_SCHEMAS, schema, () => describeRootProperties(closeObjectSchemas(converter({ target: "draft-2020-12" }))));
-const cachedJsonSchema = (cache, schema, create) => {
-    const cached = cache.get(schema);
-    if (cached !== undefined)
-        return cached;
-    const created = create();
-    cache.set(schema, created);
-    return created;
-};
-const inputJsonSchema = (schema) => {
-    const converter = schema["~standard"].jsonSchema?.input;
-    if (converter === undefined)
-        throw new TypeError("Tool input schema does not expose Standard JSON Schema");
-    return converter({ target: "draft-2020-12" });
-};
-/** Close fixed-shape JSON Schema objects while preserving explicit maps. */
-export const closeObjectSchemas = (value) => {
-    const closed = Object.fromEntries(Object.entries(value).map(([key, child]) => [key, closeSchemaValue(child)]));
-    return value.type === "object" &&
-        isObject(value.properties) &&
-        value.additionalProperties === undefined
-        ? { ...closed, additionalProperties: false }
-        : closed;
-};
-const closeSchemaValue = (value) => {
-    if (Array.isArray(value))
-        return value.map(closeSchemaValue);
-    if (!isObject(value))
-        return value;
-    return closeObjectSchemas(value);
-};
-const describeProperties = (value) => Object.fromEntries(Object.entries(value).map(([key, child]) => {
-    if (key !== "properties" || typeof child !== "object" || child === null)
-        return [key, describeValue(child)];
-    return [
-        key,
-        Object.fromEntries(Object.entries(child).map(([property, schema]) => [
-            property,
-            isObject(schema) && typeof schema.description !== "string"
-                ? {
-                    ...describeProperties(schema),
-                    description: fallbackPropertyDescription(property),
-                }
-                : describeValue(schema),
-        ])),
-    ];
-}));
-const describeValue = (value) => {
-    if (Array.isArray(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

@@ -1,4 +1,4 @@
-import { AnalysisOutputError, projectAnalysisError, } from "../domain/errors.js";
+import { projectAnalysisError } from "../domain/errors.js";
 /**
  * Translate an application result into MCP text content.
  * Error tags and safe messages remain visible while underlying causes, process
@@ -24,28 +24,12 @@ const errorResult = (error) => {
 const successResult = (value, contract, options) => {
     const candidate = compactEvidence(value, options.evidenceResultProjection) ??
         (contract.kind === "session" ? { result: value } : value);
-    const parsed = contract.outputSchema.safeParse(candidate);
-    if (!parsed.success) {
-        const structuredContent = {
-            error: projectAnalysisError(new AnalysisOutputError(contract.name, "output does not match the tool contract")),
-        };
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(structuredContent),
-                },
-            ],
-            structuredContent,
-            isError: true,
-        };
-    }
     return {
         content: [
             {
                 type: "text",
                 text: JSON.stringify(options.evidenceTextProjection === undefined
-                    ? parsed.data
+                    ? candidate
                     : (compactEvidence(value, options.evidenceTextProjection) ??
                         options.evidenceTextProjection)),
             },

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "rea-agents",
-  "version": "3.0.0",
+  "mcpName": "io.github.morluto/rea",
+  "version": "3.1.0",
   "description": "Reverse engineer anything from your terminal or agent with one CLI and MCP server.",
   "license": "MIT",
   "repository": {
@@ -43,7 +44,8 @@
     "bridge/hopper_bridge.py",
     "bridge/ghidra/ReaGhidraBridge.java",
     "scripts/rea.mjs",
-    "scripts/package-runner-bootstrap.mjs",
+    "scripts/electron-active-hook.cjs",
+    "scripts/electron-active-hook-boundaries.cjs",
     "scripts/hopper-demo-x11.py",
     "scripts/prepack.mjs",
     "scripts/prepare.mjs",
@@ -55,9 +57,10 @@
     "deps:check": "node scripts/check-dependency-install.mjs",
     "metadata:generate": "node scripts/generate-package-metadata.mjs",
     "metadata:check": "node scripts/generate-package-metadata.mjs --check",
+    "mcp-registry:check": "node scripts/verify-mcp-registry-metadata.mjs",
     "mcp-catalog:generate": "npm run build:cached && node scripts/generate-mcp-tool-catalog.mjs",
     "mcp-catalog:check": "node scripts/generate-mcp-tool-catalog.mjs --check",
-    "prebuild": "npm run deps:check && npm run metadata:check",
+    "prebuild": "npm run deps:check && npm run metadata:check && node scripts/clean-build-output.mjs",
     "build": "tsc -p tsconfig.build.json",
     "precheck": "npm run deps:check",
     "check": "turbo run typecheck lint format:check knip metadata:check",
@@ -68,7 +71,7 @@
     "precheck:test": "npm run deps:check",
     "check:test": "turbo run typecheck lint format:check knip metadata:check test:run",
     "precheck:pr": "npm run deps:check",
-    "check:pr": "turbo run typecheck lint format:check knip metadata:check test:run docs:check:built",
+    "check:pr": "turbo run typecheck lint format:check knip metadata:check test:run && npm run docs:check",
     "precheck:ci": "npm run deps:check",
     "check:ci": "turbo run typecheck lint format:check knip metadata:check jscpd scan:todos",
     "build:cached": "turbo run build",
@@ -81,19 +84,22 @@
     "jscpd": "jscpd src/ tests/",
     "scan:todos": "node scripts/scan-todos.mjs",
     "start": "node scripts/rea.mjs mcp",
-    "pretest": "npm run build:cached",
-    "test": "vitest run",
-    "test:run": "vitest run",
+    "test": "node scripts/run-exclusive.mjs test npm run test:with-build",
+    "test:with-build": "npm run build:cached && vitest run",
+    "test:run": "node scripts/run-exclusive.mjs test vitest run",
+    "test:local": "node scripts/run-exclusive.mjs test vitest run --changed --passWithNoTests --maxWorkers=1",
     "pretest:fast": "npm run build:cached",
-    "test:fast": "vitest run --project domain --project services --project adapters --project composition --project boundary --project conformance",
+    "test:fast": "vitest run --project domain --project services --project adapters --project composition --project boundary --project mcp-boundary --project conformance",
     "pretest:boundary": "npm run build:cached",
-    "test:boundary": "vitest run --project boundary --project process-global",
+    "test:boundary": "vitest run --project boundary --project mcp-boundary --project process-global",
+    "pretest:mcp": "npm run build:cached",
+    "test:mcp": "vitest run --project mcp-boundary",
     "pretest:acceptance": "npm run build:cached",
     "test:acceptance": "vitest run --project acceptance",
     "pretest:changed": "npm run build:cached",
-    "test:changed": "vitest run --project domain --project services --project adapters --project composition --project boundary --project conformance --project evaluation --changed",
+    "test:changed": "vitest run --project domain --project services --project adapters --project composition --project boundary --project mcp-boundary --project conformance --project evaluation --changed",
     "pretest:integration": "npm run build:cached",
-    "test:integration": "vitest run --project boundary --project process-global --project acceptance",
+    "test:integration": "vitest run --project boundary --project mcp-boundary --project process-global --project acceptance",
     "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",
@@ -104,7 +110,7 @@
     "pretest:verbose": "npm run build:cached",
     "test:verbose": "vitest run --reporter=verbose",
     "pretest:watch": "npm run build:cached",
-    "test:watch": "vitest --project domain --project services --project adapters --project composition --project boundary --project conformance --project evaluation --changed",
+    "test:watch": "vitest --project domain --project services --project adapters --project composition --project boundary --project mcp-boundary --project conformance --project evaluation --changed",
     "pretest:watch:all": "npm run build:cached",
     "test:watch:all": "vitest --changed",
     "typecheck": "tsc --noEmit",
@@ -113,6 +119,7 @@
     "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:electron": "npm run build:cached && node scripts/verify-real-electron.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",
@@ -134,8 +141,9 @@
     "evidence:check": "npm run build:cached && node scripts/generate-completion-ledger.mjs --check",
     "docs:api": "typedoc",
     "docs:api:cached": "turbo run docs:api",
-    "docs:generate": "npm run metadata:generate && npm run build:cached && node scripts/generate-mcp-tool-catalog.mjs && node scripts/generate-skill-metadata.mjs && node scripts/generate-product-catalog.mjs && node scripts/generate-completion-ledger.mjs && npm run docs:api:cached && node scripts/generate-error-schema.mjs",
-    "docs:check": "turbo run docs:check:built",
+    "docs:generate": "node scripts/run-exclusive.mjs docs npm run docs:generate:unlocked",
+    "docs:generate:unlocked": "npm run metadata:generate && npm run build:cached && node scripts/generate-mcp-tool-catalog.mjs && node scripts/generate-skill-metadata.mjs && node scripts/generate-product-catalog.mjs && node scripts/generate-completion-ledger.mjs && npm run docs:api:cached && node scripts/generate-error-schema.mjs",
+    "docs:check": "node scripts/run-exclusive.mjs docs turbo run docs:check:built",
     "docs:check:built": "node scripts/generate-package-metadata.mjs --check && node scripts/generate-mcp-tool-catalog.mjs --check && node scripts/generate-skill-metadata.mjs --check && node scripts/generate-product-catalog.mjs --check && node scripts/generate-completion-ledger.mjs --check && node scripts/check-doc-facts.mjs && node scripts/generate-error-schema.mjs --check",
     "docs:error-schema": "npm run build:cached && node scripts/generate-error-schema.mjs",
     "prepack": "node scripts/prepack.mjs",