rea-agents 2.1.0 → 2.3.0

package/dist/server/registerApplicationTools/helpers.js

@@ -9,34 +9,46 @@ export const recordSources = (recordEvidence, sources) => {
     }
     return { ok: true, value: null };
 };
-export const recordResult = (options, contract, evidence, recordUnknown = false) => {
-    const recorded = recordUnknown
-        ? options.recordEvidenceWithUnknown?.(evidence, {
-            approved: true,
-            question: "Which application entities remain unmatched or ambiguous across these versions?",
-            severity: "medium",
-            domain: "application-version-comparison",
-            supporting_evidence_ids: [evidence.evidence_id],
-            contradicting_evidence_ids: [],
-            required_authority: "shipped-artifact",
-            required_confidence: "observed",
-            required_environment: null,
-            recommended_probes: [
-                {
-                    operation: "analyze_javascript_application",
-                    rationale: "Repeat static reconstruction with complete artifacts and source maps when available.",
-                },
-                {
-                    operation: "reconcile_javascript_runtime",
-                    rationale: "Add approved passive runtime Evidence without promoting it to static fact.",
-                },
-            ],
-            relationships: [],
-        })
-        : options.recordEvidence?.(evidence);
+export const recordResult = (options, contract, evidence, unknownKind) => {
+    const recorded = unknownKind === undefined
+        ? options.recordEvidence?.(evidence)
+        : options.recordEvidenceWithUnknown?.(evidence, unknownRegistration(evidence, unknownKind));
     if (recorded !== undefined && !recorded.ok)
         return toCallToolResult(recorded, contract);
     return toCallToolResult({ ok: true, value: evidence }, contract, {
         evidenceResourcesAvailable: recorded !== undefined,
     });
 };
+const unknownRegistration = (evidence, kind) => ({
+    approved: true,
+    question: kind === "application-version-comparison"
+        ? "Which application entities remain unmatched or ambiguous across these versions?"
+        : "Which selected JavaScript export return shapes remain dynamic, incomplete, or ambiguously paired?",
+    severity: "medium",
+    domain: kind,
+    supporting_evidence_ids: [evidence.evidence_id],
+    contradicting_evidence_ids: [],
+    required_authority: "shipped-artifact",
+    required_confidence: "observed",
+    required_environment: null,
+    recommended_probes: [
+        {
+            operation: "analyze_javascript_application",
+            rationale: "Repeat static reconstruction with complete artifacts and source maps when available.",
+        },
+        ...(kind === "application-version-comparison"
+            ? [
+                {
+                    operation: "reconcile_javascript_runtime",
+                    rationale: "Add approved passive runtime Evidence without promoting it to static fact.",
+                },
+            ]
+            : [
+                {
+                    operation: "run_controlled_replay",
+                    rationale: "Validate exact approved module behavior separately when runtime semantics are required.",
+                },
+            ]),
+    ],
+    relationships: [],
+});

package/dist/server/registerApplicationTools/traceFeature.js

@@ -1,19 +1,23 @@
 import { traceApplicationFeatureEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
-import { APPLICATION_TOOL_CONTRACTS } from "../../contracts/applicationToolContracts.js";
-import { traceApplicationFeatureInputSchema } from "../../domain/javascriptFeatureTraceSchemas.js";
+import { resolveTraceApplicationFeatureRequestValidated } from "../../application/ApplicationWorkflowEvidenceResolver.js";
+import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
+import { traceApplicationFeatureRequestSchema } from "../../contracts/applicationWorkflowInputContracts.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toCallToolResult } from "../toolResult.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { safeParseToolInput } from "../toolInputValidation.js";
 import { recordResult, recordSources } from "./helpers.js";
-const traceContract = APPLICATION_TOOL_CONTRACTS[0];
+const traceContract = applicationToolContract("trace_application_feature");
 /** Register the provider-neutral JavaScript feature trace tool. */
 export const registerTraceFeatureTool = (server, options) => {
     server.registerTool(traceContract.name, toolRegistrationOptions(traceContract), async (input) => {
-        const parsedInput = safeParseToolInput(traceApplicationFeatureInputSchema, input, traceContract.name);
+        const parsedInput = safeParseToolInput(traceApplicationFeatureRequestSchema, input, traceContract.name);
         if (!parsedInput.ok)
             return toCallToolResult(parsedInput, traceContract);
-        const parsed = parsedInput.value;
+        const resolved = resolveTraceApplicationFeatureRequestValidated(parsedInput.value, options.evidenceLookup);
+        if (!resolved.ok)
+            return toCallToolResult(resolved, traceContract);
+        const parsed = resolved.value;
         const result = await logToolExecution(options.logger, traceContract.name, () => Promise.resolve(traceApplicationFeatureEvidenceValidated(parsed)));
         if (!result.ok)
             return toCallToolResult(result, traceContract);

package/dist/server/registerApplicationTools/traceSemantics.js

@@ -0,0 +1,30 @@
+import { resolveTraceJavaScriptSemanticsRequestValidated } from "../../application/ApplicationWorkflowEvidenceResolver.js";
+import { traceJavaScriptSemanticsEvidenceValidated } from "../../application/JavaScriptSemanticTraceService.js";
+import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
+import { traceJavaScriptSemanticsRequestSchema } from "../../contracts/applicationWorkflowInputContracts.js";
+import { safeParseToolInput } from "../toolInputValidation.js";
+import { logToolExecution } from "../toolLogging.js";
+import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
+import { toCallToolResult } from "../toolResult.js";
+import { recordResult, recordSources } from "./helpers.js";
+const contract = applicationToolContract("trace_javascript_semantics");
+/** Register the bounded JavaScript semantic relation trace tool. */
+export const registerTraceJavaScriptSemanticsTool = (server, options) => {
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
+        const parsedInput = safeParseToolInput(traceJavaScriptSemanticsRequestSchema, input, contract.name);
+        if (!parsedInput.ok)
+            return toCallToolResult(parsedInput, contract);
+        const resolved = resolveTraceJavaScriptSemanticsRequestValidated(parsedInput.value, options.evidenceLookup);
+        if (!resolved.ok)
+            return toCallToolResult(resolved, contract);
+        const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(traceJavaScriptSemanticsEvidenceValidated(resolved.value)));
+        if (!result.ok)
+            return toCallToolResult(result, contract);
+        const recorded = recordSources(options.recordEvidence, [
+            resolved.value.application,
+        ]);
+        if (!recorded.ok)
+            return toCallToolResult(recorded, contract);
+        return recordResult(options, contract, result.value);
+    });
+};

package/dist/server/registerApplicationTools.js

@@ -1,12 +1,16 @@
 import { registerTraceFeatureTool } from "./registerApplicationTools/traceFeature.js";
+import { registerTraceJavaScriptSemanticsTool } from "./registerApplicationTools/traceSemantics.js";
 import { registerCompareApplicationVersionsTool } from "./registerApplicationTools/compareVersions.js";
+import { registerCompareJavaScriptExportShapesTool } from "./registerApplicationTools/compareExportShapes.js";
 import { registerControlledReplayTool } from "./registerApplicationTools/controlledReplay.js";
 import { registerCharacterizationTools } from "./registerApplicationTools/characterization.js";
 import { registerCoverageTools } from "./registerApplicationTools/coverage.js";
 /** Register provider-neutral JavaScript application graph workflows. */
 export const registerApplicationTools = (server, options) => {
     registerTraceFeatureTool(server, options);
+    registerTraceJavaScriptSemanticsTool(server, options);
     registerCompareApplicationVersionsTool(server, options);
+    registerCompareJavaScriptExportShapesTool(server, options);
     registerControlledReplayTool(server, options);
     registerCharacterizationTools(server, options);
     registerCoverageTools(server, options);

package/dist/server/registerElectronTools.js

@@ -1,15 +1,15 @@
 import { analyzeJavaScriptApplicationValidated } from "../application/JavaScriptApplicationService.js";
 import { reconcileJavaScriptRuntimeEvidenceValidated } from "../application/JavaScriptRuntimeReconciliationService.js";
 import { inspectElectronPage, listElectronTargets, } from "../application/ElectronObservationService.js";
-import { ELECTRON_TOOL_CONTRACTS } from "../contracts/electronToolContracts.js";
+import { analyzeJavaScriptApplicationToolInputSchema, ELECTRON_TOOL_CONTRACTS, } from "../contracts/electronToolContracts.js";
 import { inspectElectronPageInputSchema, listElectronTargetsInputSchema, } from "../domain/electronObservation.js";
-import { analyzeJavaScriptApplicationInputSchema } from "../domain/javascriptApplicationAnalysis.js";
 import { reconcileJavaScriptRuntimeInputSchema } from "../domain/javascriptRuntimeReconciliationSchemas.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toCallToolResult } from "./toolResult.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { safeParseToolInput } from "./toolInputValidation.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
+import { summarizeJavaScriptApplicationEvidence } from "./javascriptApplicationResult.js";
 /** Register Electron tools even when provider or permission policy is absent. */
 export const registerElectronTools = (server, options) => {
     const [listContract, inspectContract, analyzeContract, reconcileContract] = ELECTRON_TOOL_CONTRACTS;
@@ -30,8 +30,14 @@ export const registerElectronTools = (server, options) => {
     });
     registerElectronTool(server, options, {
         contract: analyzeContract,
-        schema: analyzeJavaScriptApplicationInputSchema,
+        schema: analyzeJavaScriptApplicationToolInputSchema,
         execute: (parsed, { signal, progress }) => analyzeJavaScriptApplicationValidated(options.permissionAuthority, parsed, { signal, progress }),
+        projectEvidence: (evidence, parsed) => {
+            const summary = summarizeJavaScriptApplicationEvidence(evidence);
+            return parsed.detail === "full"
+                ? { structured: evidence.normalized_result, text: summary }
+                : { structured: summary };
+        },
     });
     registerElectronTool(server, options, {
         contract: reconcileContract,
@@ -50,14 +56,22 @@ const registerElectronTool = (server, options, spec) => {
         }));
         if (!result.ok)
             return toCallToolResult(result, spec.contract);
-        return evidenceResult(options, spec.contract, result.value);
+        return evidenceResult(options, spec.contract, result.value, spec.projectEvidence?.(result.value, parsedInput.value));
     });
 };
-const evidenceResult = (options, contract, evidence) => {
+const evidenceResult = (options, contract, evidence, projection) => {
     const recorded = options.recordEvidence?.(evidence);
     return recorded !== undefined && !recorded.ok
         ? toCallToolResult(recorded, contract)
         : toCallToolResult({ ok: true, value: evidence }, contract, {
             evidenceResourcesAvailable: recorded !== undefined,
+            ...(projection === undefined
+                ? {}
+                : {
+                    evidenceResultProjection: projection.structured,
+                    ...(projection.text === undefined
+                        ? {}
+                        : { evidenceTextProjection: projection.text }),
+                }),
         });
 };

package/dist/server/registerEvidenceResources.js

@@ -1,6 +1,7 @@
 import { ResourceNotFoundError, ResourceTemplate, } from "@modelcontextprotocol/server";
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
+import { registerJavaScriptApplicationGraphResource } from "./registerJavaScriptApplicationGraphResource.js";
 const evidenceUri = (evidenceId) => `rea://evidence/${evidenceId}`;
 /** Expose immutable session-owned Evidence v2 records as MCP resources. */
 export const registerEvidenceResources = (server, session) => {
@@ -12,6 +13,7 @@ export const registerEvidenceResources = (server, session) => {
     registerArtifactPageResource(server, session);
     registerFunctionDossierResource(server, session);
     registerEvidenceSectionResource(server, session);
+    registerJavaScriptApplicationGraphResource(server, session);
     registerResidualUnknownResource(server, session);
 };
 const registerReconstructionCoverageResource = (server, session) => {
@@ -315,7 +317,11 @@ const evidenceSection = (result, section) => {
     if (section === "process")
         return pick(result, ["process_samples", "exit", "settlement", "cleanup"]);
     if (section === "protocol")
-        return pick(result, ["protocol_events", "shim_events"]);
+        return pick(result, [
+            "protocol_events",
+            "replay_transitions",
+            "shim_events",
+        ]);
     const value = result[section];
     return value === undefined ? undefined : value;
 };

package/dist/server/registerJavaScriptApplicationGraphResource.js

@@ -0,0 +1,69 @@
+import { ResourceNotFoundError, ResourceTemplate, } from "@modelcontextprotocol/server";
+import { javascriptApplicationAnalysisResultSchema } from "../domain/javascriptApplicationAnalysis.js";
+/** Register deterministic pages over one authenticated JavaScript graph. */
+export const registerJavaScriptApplicationGraphResource = (server, session) => {
+    server.registerResource("javascript-application-graph-page", new ResourceTemplate("rea://evidence/{evidenceId}/application-graph/{collection}/offset/{offset}/limit/{limit}", {
+        list: undefined,
+        complete: {
+            evidenceId: (prefix) => session
+                .exportEvidenceBundle()
+                .records.map(({ evidence_id }) => evidence_id)
+                .filter((evidenceId) => evidenceId.startsWith(prefix)),
+            collection: (prefix) => ["nodes", "edges"].filter((name) => name.startsWith(prefix)),
+        },
+    }), {
+        title: "JavaScript application graph page",
+        description: "One deterministic bounded node or edge page from authenticated JavaScript application Evidence.",
+        mimeType: "application/json",
+    }, (uri, variables) => {
+        const evidenceId = stringVariable(variables.evidenceId, uri.href);
+        const collection = stringVariable(variables.collection, uri.href);
+        if (collection !== "nodes" && collection !== "edges")
+            throw new ResourceNotFoundError(uri.href);
+        const offset = pageInteger(variables.offset, uri.href, 0, 100_000);
+        const limit = pageInteger(variables.limit, uri.href, 1, 500);
+        const evidence = session.evidenceById(evidenceId);
+        if (evidence === undefined ||
+            evidence.operation !== "analyze_javascript_application")
+            throw new ResourceNotFoundError(uri.href);
+        const analysis = javascriptApplicationAnalysisResultSchema.safeParse(evidence.normalized_result);
+        if (!analysis.success)
+            throw new ResourceNotFoundError(uri.href);
+        const values = analysis.data.graph[collection];
+        const items = values.slice(offset, offset + limit);
+        const nextOffset = offset + items.length;
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify({
+                        evidence_id: evidence.evidence_id,
+                        graph_id: analysis.data.graph.graph_id,
+                        collection,
+                        items,
+                        offset,
+                        limit,
+                        total: values.length,
+                        next_offset: nextOffset < values.length ? nextOffset : null,
+                        has_more: nextOffset < values.length,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+};
+const stringVariable = (value, uri) => {
+    if (typeof value !== "string")
+        throw new ResourceNotFoundError(uri);
+    return value;
+};
+const pageInteger = (value, uri, minimum, maximum) => {
+    const text = stringVariable(value, uri);
+    if (!/^\d+$/u.test(text))
+        throw new ResourceNotFoundError(uri);
+    const parsed = Number(text);
+    if (!Number.isSafeInteger(parsed) || parsed < minimum || parsed > maximum)
+        throw new ResourceNotFoundError(uri);
+    return parsed;
+};

package/dist/server/registerManagedTools.js

@@ -1,6 +1,23 @@
 import { MANAGED_TOOL_CONTRACTS } from "../contracts/managedToolContracts.js";
+import { err } from "../domain/result.js";
 import { registerEvidenceTools } from "./registerEvidenceTools.js";
 /** Register execution-free managed PE/CLI inspection. */
 export const registerManagedTools = (server, analysis, options) => {
-    registerEvidenceTools(server, analysis, MANAGED_TOOL_CONTRACTS, options);
+    const targetAwareAnalysis = {
+        execute: async (operation, parameters, executionOptions) => {
+            const path = operation === "inspect_managed_artifact" &&
+                typeof parameters.path === "string"
+                ? parameters.path
+                : undefined;
+            if (path !== undefined && options.session !== undefined) {
+                const opened = await options.session.open(path, executionOptions?.signal === undefined
+                    ? undefined
+                    : { signal: executionOptions.signal });
+                if (!opened.ok)
+                    return err(opened.error);
+            }
+            return analysis.execute(operation, parameters, executionOptions);
+        },
+    };
+    registerEvidenceTools(server, targetAwareAnalysis, MANAGED_TOOL_CONTRACTS, options);
 };

package/dist/server/registerProcessComparisonTool.js

@@ -11,6 +11,11 @@ import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { runDerivedOperation } from "./runDerivedOperation.js";
 import { safeParseToolInput } from "./toolInputValidation.js";
 import { resolveSessionEvidenceIds } from "./sessionEvidence.js";
+const PROCESS_CAPTURE_EVIDENCE = {
+    operation: "capture_process_scenario",
+    predicate: "rea.process-capture/v4",
+};
+const sourceLocations = (left, right) => [...(left ?? []), ...(right ?? [])];
 /** Register deterministic process-capture comparison and contradiction tracking. */
 export const registerProcessComparisonTool = (server, session, contract, now = Date.now) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
@@ -18,14 +23,10 @@ export const registerProcessComparisonTool = (server, session, contract, now = D
         if (!parsedInput.ok)
             return toCallToolResult(parsedInput, contract);
         const parsed = parsedInput.value;
-        const expected = {
-            operation: "capture_process_scenario",
-            predicate: "rea.process-capture/v4",
-        };
-        const leftRecord = resolveSessionEvidenceIds(session, [parsed.left_evidence_id], expected);
+        const leftRecord = resolveSessionEvidenceIds(session, [parsed.left_evidence_id], PROCESS_CAPTURE_EVIDENCE);
         if (!leftRecord.ok)
             return toCallToolResult(leftRecord, contract);
-        const rightRecord = resolveSessionEvidenceIds(session, [parsed.right_evidence_id], expected);
+        const rightRecord = resolveSessionEvidenceIds(session, [parsed.right_evidence_id], PROCESS_CAPTURE_EVIDENCE);
         if (!rightRecord.ok)
             return toCallToolResult(rightRecord, contract);
         let comparison;
@@ -38,6 +39,9 @@ export const registerProcessComparisonTool = (server, session, contract, now = D
                 ...(parsed.max_capture_age_ms === undefined
                     ? {}
                     : { maxCaptureAgeMs: parsed.max_capture_age_ms }),
+                ...(parsed.trace_spec === undefined
+                    ? {}
+                    : { traceSpecification: parsed.trace_spec }),
                 now,
             }));
             if (!computed.ok)
@@ -50,18 +54,24 @@ export const registerProcessComparisonTool = (server, session, contract, now = D
                 : "Invalid Process Capture v4")), contract);
         }
         const evidence = createEvidence(undefined, PROCESS_PROVIDER, {
-            predicateType: "rea.process-comparison/v3",
+            predicateType: parsed.trace_spec === undefined
+                ? "rea.process-comparison/v3"
+                : "rea.process-comparison/v4",
             operation: contract.name,
             parameters: {
                 left_evidence_id: parsed.left_evidence_id,
                 right_evidence_id: parsed.right_evidence_id,
                 left_normalization: leftCapture.normalization,
                 right_normalization: rightCapture.normalization,
+                ...(parsed.trace_spec === undefined
+                    ? {}
+                    : { trace_spec: jsonValueSchema.parse(parsed.trace_spec) }),
             },
             result: jsonValueSchema.parse(comparison),
             confidence: "derived",
             authority: "analyst-inference",
             limitations: comparison.limitations,
+            locations: sourceLocations(leftRecord.value[0]?.locations, rightRecord.value[0]?.locations),
             evidenceLinks: [parsed.left_evidence_id, parsed.right_evidence_id],
         });
         return toCallToolResult(recordDerivedEvidence(session, evidence, comparisonUnknownInput(parsed, comparison)), contract);

package/dist/server/registerReplayMachineTool.js

@@ -0,0 +1,20 @@
+import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
+import { replayMachineRunInputSchema, runReplayMachine, } from "../domain/replayMachineRun.js";
+import { ok } from "../domain/result.js";
+import { safeParseToolInput } from "./toolInputValidation.js";
+import { logToolExecution } from "./toolLogging.js";
+import { toCallToolResult } from "./toolResult.js";
+import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+const contract = SESSION_TOOL_CONTRACTS.find(({ name }) => name === "run_replay_machine");
+if (contract === undefined)
+    throw new TypeError("Missing run_replay_machine tool contract");
+/** Register direct execution-free finite replay-machine evaluation. */
+export const registerReplayMachineTool = (server, logger) => {
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
+        const parsed = safeParseToolInput(replayMachineRunInputSchema, input, contract.name);
+        if (!parsed.ok)
+            return toCallToolResult(parsed, contract);
+        const result = await logToolExecution(logger, contract.name, () => Promise.resolve(ok(runReplayMachine(parsed.value))));
+        return toCallToolResult(result, contract);
+    });
+};

package/dist/server/registerSessionStatusTool.js

@@ -16,38 +16,108 @@ export const registerSessionStatusTool = (options) => {
         const client = server.server.getClientVersion();
         const clientCapabilities = server.server.getClientCapabilities();
         const status = session.status();
+        const statusObject = jsonObjectSchema.parse(status);
+        const toolAvailability = buildCapabilityInventory(status, availabilityPolicy());
+        const serverIdentity = createServerIdentity({
+            startedAt,
+            expected: {
+                ...(parsed.expected_package_version === undefined
+                    ? {}
+                    : { package_version: parsed.expected_package_version }),
+                ...(parsed.expected_catalog_digest === undefined
+                    ? {}
+                    : { catalog_digest: parsed.expected_catalog_digest }),
+                ...(parsed.expected_server_path === undefined
+                    ? {}
+                    : { server_path: parsed.expected_server_path }),
+            },
+            ...(client === undefined ? {} : { client }),
+            ...(server.server.getNegotiatedProtocolVersion() === undefined
+                ? {}
+                : {
+                    protocolVersion: server.server.getNegotiatedProtocolVersion(),
+                }),
+        });
         return toCallToolResult({
             ok: true,
-            value: {
-                ...jsonObjectSchema.parse(status),
-                tool_availability: buildCapabilityInventory(status, availabilityPolicy()),
-                client_features: {
+            value: projectSessionStatus({
+                input: parsed,
+                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,
                 },
-                server_identity: createServerIdentity({
-                    startedAt,
-                    expected: {
-                        ...(parsed.expected_package_version === undefined
-                            ? {}
-                            : { package_version: parsed.expected_package_version }),
-                        ...(parsed.expected_catalog_digest === undefined
-                            ? {}
-                            : { catalog_digest: parsed.expected_catalog_digest }),
-                        ...(parsed.expected_server_path === undefined
-                            ? {}
-                            : { server_path: parsed.expected_server_path }),
-                    },
-                    ...(client === undefined ? {} : { client }),
-                    ...(server.server.getNegotiatedProtocolVersion() === undefined
-                        ? {}
-                        : {
-                            protocolVersion: server.server.getNegotiatedProtocolVersion(),
-                        }),
-                }),
-            },
+            }),
         }, contract);
     });
 };
+const projectSessionStatus = (options) => {
+    if (options.input.detail === "full")
+        return jsonObjectSchema.parse({
+            view: "full",
+            ...options.status,
+            tool_availability: options.toolAvailability,
+            client_features: options.clientFeatures,
+            server_identity: options.serverIdentity,
+        });
+    const open = options.status.open === true;
+    const activeProvider = activeProviderFrom(options.status);
+    if (options.input.detail === "capabilities") {
+        const filtered = options.input.capability_family === undefined
+            ? options.toolAvailability
+            : options.toolAvailability.filter(({ surface }) => surface === options.input.capability_family);
+        const items = filtered.slice(options.input.cursor, options.input.cursor + options.input.limit);
+        const nextCursor = options.input.cursor + items.length;
+        return jsonObjectSchema.parse({
+            view: "capabilities",
+            open,
+            provider: options.status.provider,
+            active_provider: activeProvider,
+            capability_family: options.input.capability_family ?? null,
+            capabilities: {
+                items,
+                cursor: options.input.cursor,
+                limit: options.input.limit,
+                total: filtered.length,
+                next_cursor: nextCursor < filtered.length ? nextCursor : null,
+                has_more: nextCursor < filtered.length,
+            },
+        });
+    }
+    return jsonObjectSchema.parse({
+        view: "summary",
+        open,
+        provider: options.status.provider,
+        active_provider: activeProvider,
+        target: open ? targetFrom(options.status) : null,
+        alignment: options.serverIdentity.alignment,
+        recommended_actions: recommendedActions(open, options.serverIdentity.alignment.state),
+    });
+};
+const activeProviderFrom = (status) => {
+    const binding = jsonObjectSchema.safeParse(status.analysis_provider_binding);
+    return binding.success ? (binding.data.provider ?? null) : null;
+};
+const targetFrom = (status) => ({
+    path: status.path,
+    format: status.format,
+    kind: status.kind,
+    sha256: status.sha256,
+    architecture: status.architecture ?? null,
+});
+const recommendedActions = (open, alignment) => [
+    ...(alignment === "mcp_server_restart_required"
+        ? ["Restart the registered MCP server or client before continuing."]
+        : []),
+    ...(!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.",
+        ]
+        : [
+            "Continue from the active target with binary_overview or a bounded target-specific query.",
+        ]),
+];

package/dist/server/registerSessionTools.js

@@ -23,7 +23,8 @@ 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";
+import { registerReplayMachineTool } from "./registerReplayMachineTool.js";
+import { sessionAvailabilityPolicy, } from "./sessionAvailabilityPolicy.js";
 const permissionFailure = (failure) => {
     if (failure.ok)
         return err(new AnalysisProtocolError("Expected a denied permission"));
@@ -212,6 +213,14 @@ const registerCloseLifecycleTool = ({ server, session, logger, contracts: [, clo
             : toCallToolResult(closed, closeContract);
     });
 };
+const registerRecordAndReplayTools = (server, session, logger) => {
+    registerUnknownTools({
+        server,
+        session,
+        contracts: SESSION_TOOL_CONTRACTS,
+    });
+    registerReplayMachineTool(server, logger);
+};
 export const registerSessionTools = (server, session, logger, options = {}) => {
     const processPolicy = options.processPolicy ?? DENY_PROCESS_POLICY;
     const evidenceFilePolicy = options.evidenceFilePolicy ?? DENY_EVIDENCE_FILE_POLICY;
@@ -224,7 +233,7 @@ 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),
+        availabilityPolicy: sessionAvailabilityPolicy(options.availabilityPolicy, processPolicy, evidenceFilePolicy, options.investigationInputRoots ?? []),
         ...(options.permissionAuthority === undefined
             ? {}
             : { permissionAuthority: options.permissionAuthority }),
@@ -274,9 +283,5 @@ export const registerSessionTools = (server, session, logger, options = {}) => {
             ? {}
             : { permissionAuthority: options.permissionAuthority }),
     });
-    registerUnknownTools({
-        server,
-        session,
-        contracts: SESSION_TOOL_CONTRACTS,
-    });
+    registerRecordAndReplayTools(server, session, logger);
 };

package/dist/server/sessionAvailabilityPolicy.js

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

package/dist/server/toolResult.js

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