rea-agents 2.2.0 → 2.3.0

package/dist/server/javascriptApplicationResult.js

@@ -46,7 +46,7 @@ export const summarizeJavaScriptApplicationEvidence = (evidence) => {
             location: observation.evidence.location,
         };
     });
-    const { graph: _graph, ...summary } = result;
+    const summary = result.schema_version === 1 ? omitGraph(result) : omitGraphs(result);
     const unknowns = new Set([
         ...result.limitations,
         ...result.graph.limitations,
@@ -59,6 +59,19 @@ export const summarizeJavaScriptApplicationEvidence = (evidence) => {
         unknowns.add(`Application graph coverage is ${result.graph.coverage.status}; omitted facts remain unknown.`);
     return javascriptApplicationAnalysisSummarySchema.parse({
         ...summary,
+        ...(result.schema_version === 1
+            ? {}
+            : {
+                semantic_graph: {
+                    graph_id: result.semantic_graph.graph_id,
+                    nodes: result.semantic_graph.nodes.length,
+                    relations: result.semantic_graph.relations.length,
+                    unknown_frontiers: result.semantic_graph.unknowns.length,
+                    fingerprints: result.semantic_graph.fingerprints.length,
+                    coverage: result.semantic_graph.coverage.status,
+                    query_tool: "trace_javascript_semantics",
+                },
+            }),
         unknowns: [...unknowns],
         graph: {
             graph_id: result.graph.graph_id,
@@ -83,3 +96,11 @@ export const summarizeJavaScriptApplicationEvidence = (evidence) => {
         },
     });
 };
+const omitGraph = (result) => {
+    const { graph: _graph, ...summary } = result;
+    return summary;
+};
+const omitGraphs = (result) => {
+    const { graph: _graph, semantic_graph: _semanticGraph, ...summary } = result;
+    return summary;
+};

package/dist/server/registerApplicationTools/characterization.js

@@ -1,5 +1,5 @@
 import { executeNodeCharacterization, prepareNodeCharacterization, } from "../../application/NodeRuntimeCharacterizationService.js";
-import { APPLICATION_TOOL_CONTRACTS } from "../../contracts/applicationToolContracts.js";
+import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
 import { nodeCharacterizationExecutionInputSchema, nodeCharacterizationExecutionOutputSchema, nodeCharacterizationPreparationInputSchema, nodeCharacterizationPreparationOutputSchema, } from "../../domain/nodeRuntimeCharacterization.js";
 import { parseEvidence } from "../../domain/evidence.js";
 import { logToolExecution } from "../toolLogging.js";
@@ -8,8 +8,8 @@ import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { safeParseToolInput } from "../toolInputValidation.js";
 import { mcpProgressReporter } from "../mcpProgress.js";
 import { recordSources } from "./helpers.js";
-const prepareContract = APPLICATION_TOOL_CONTRACTS[3];
-const executeContract = APPLICATION_TOOL_CONTRACTS[4];
+const prepareContract = applicationToolContract("prepare_node_characterization");
+const executeContract = applicationToolContract("execute_node_characterization");
 /** Register node runtime characterization prepare and execute tools. */
 export const registerCharacterizationTools = (server, options) => {
     server.registerTool(prepareContract.name, toolRegistrationOptions(prepareContract), async (input, context) => {

package/dist/server/registerApplicationTools/compareExportShapes.js

@@ -0,0 +1,37 @@
+import { resolveCompareJavaScriptExportShapesRequestValidated } from "../../application/ApplicationWorkflowEvidenceResolver.js";
+import { compareJavaScriptExportShapesEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
+import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
+import { compareJavaScriptExportShapesRequestSchema } from "../../contracts/applicationWorkflowInputContracts.js";
+import { javaScriptExportShapeComparisonResultSchema } from "../../domain/javascriptExportShapeComparisonSchemas.js";
+import { safeParseToolInput } from "../toolInputValidation.js";
+import { logToolExecution } from "../toolLogging.js";
+import { toCallToolResult } from "../toolResult.js";
+import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
+import { recordResult, recordSources } from "./helpers.js";
+const contract = applicationToolContract("compare_javascript_export_shapes");
+/** Register the execution-free exact JavaScript export-shape comparison. */
+export const registerCompareJavaScriptExportShapesTool = (server, options) => {
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
+        const parsedInput = safeParseToolInput(compareJavaScriptExportShapesRequestSchema, input, contract.name);
+        if (!parsedInput.ok)
+            return toCallToolResult(parsedInput, contract);
+        const resolved = resolveCompareJavaScriptExportShapesRequestValidated(parsedInput.value, options.evidenceLookup);
+        if (!resolved.ok)
+            return toCallToolResult(resolved, contract);
+        const parsed = resolved.value;
+        const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(compareJavaScriptExportShapesEvidenceValidated(parsed)));
+        if (!result.ok)
+            return toCallToolResult(result, contract);
+        const recorded = recordSources(options.recordEvidence, [
+            parsed.left,
+            parsed.right,
+        ]);
+        if (!recorded.ok)
+            return toCallToolResult(recorded, contract);
+        const comparison = javaScriptExportShapeComparisonResultSchema.parse(result.value.normalized_result);
+        const unknown = comparison.summary.unknown > 0;
+        return recordResult(options, contract, result.value, parsed.unknown_registry_approved === true && unknown
+            ? "javascript-export-shape"
+            : undefined);
+    });
+};

package/dist/server/registerApplicationTools/compareVersions.js

@@ -1,20 +1,24 @@
 import { compareApplicationVersionsEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
-import { APPLICATION_TOOL_CONTRACTS } from "../../contracts/applicationToolContracts.js";
-import { compareApplicationVersionsInputSchema } from "../../domain/javascriptApplicationVersionComparisonSchemas.js";
+import { resolveCompareApplicationVersionsRequestValidated } from "../../application/ApplicationWorkflowEvidenceResolver.js";
+import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
+import { compareApplicationVersionsRequestSchema } from "../../contracts/applicationWorkflowInputContracts.js";
 import { applicationVersionComparisonResultSchema } from "../../domain/javascriptApplicationVersionComparisonSchemas.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 compareContract = APPLICATION_TOOL_CONTRACTS[1];
+const compareContract = applicationToolContract("compare_application_versions");
 /** Register the provider-neutral JavaScript version comparison tool. */
 export const registerCompareApplicationVersionsTool = (server, options) => {
     server.registerTool(compareContract.name, toolRegistrationOptions(compareContract), async (input) => {
-        const parsedInput = safeParseToolInput(compareApplicationVersionsInputSchema, input, compareContract.name);
+        const parsedInput = safeParseToolInput(compareApplicationVersionsRequestSchema, input, compareContract.name);
         if (!parsedInput.ok)
             return toCallToolResult(parsedInput, compareContract);
-        const parsed = parsedInput.value;
+        const resolved = resolveCompareApplicationVersionsRequestValidated(parsedInput.value, options.evidenceLookup);
+        if (!resolved.ok)
+            return toCallToolResult(resolved, compareContract);
+        const parsed = resolved.value;
         const result = await logToolExecution(options.logger, compareContract.name, () => Promise.resolve(compareApplicationVersionsEvidenceValidated(parsed)));
         if (!result.ok)
             return toCallToolResult(result, compareContract);
@@ -29,6 +33,8 @@ export const registerCompareApplicationVersionsTool = (server, options) => {
             return toCallToolResult(recorded, compareContract);
         const comparison = applicationVersionComparisonResultSchema.parse(result.value.normalized_result);
         const unknown = comparison.summary.unknown > 0;
-        return recordResult(options, compareContract, result.value, parsed.unknown_registry_approved === true && unknown);
+        return recordResult(options, compareContract, result.value, parsed.unknown_registry_approved === true && unknown
+            ? "application-version-comparison"
+            : undefined);
     });
 };

package/dist/server/registerApplicationTools/controlledReplay.js

@@ -1,5 +1,5 @@
 import { runControlledReplayValidated } from "../../application/JavaScriptReplayService.js";
-import { APPLICATION_TOOL_CONTRACTS } from "../../contracts/applicationToolContracts.js";
+import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
 import { controlledReplayInputSchema, controlledReplayOutputSchema, } from "../../domain/javascriptReplay.js";
 import { parseEvidence } from "../../domain/evidence.js";
 import { logToolExecution } from "../toolLogging.js";
@@ -8,7 +8,7 @@ import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { safeParseToolInput } from "../toolInputValidation.js";
 import { mcpProgressReporter } from "../mcpProgress.js";
 import { recordSources } from "./helpers.js";
-const replayContract = APPLICATION_TOOL_CONTRACTS[2];
+const replayContract = applicationToolContract("run_controlled_replay");
 /** Register the controlled JavaScript replay tool. */
 export const registerControlledReplayTool = (server, options) => {
     server.registerTool(replayContract.name, toolRegistrationOptions(replayContract), async (input, context) => {

package/dist/server/registerApplicationTools/coverage.js

@@ -1,7 +1,7 @@
 import { commitReconstructionCoverage, queryReconstructionCoverage, } from "../../application/ReconstructionCoverageService.js";
 import { readReconstructionCoverageWorkspace } from "../../application/ReconstructionCoverageWorkspaceStore.js";
 import { authorizeFileReadWithDeferredWrite, authorizeRootPermission, } from "../../application/DeferredFileAuthorization.js";
-import { APPLICATION_TOOL_CONTRACTS } from "../../contracts/applicationToolContracts.js";
+import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
 import { reconstructionCoverageCommitInputSchema, reconstructionCoverageQueryInputSchema, } from "../../application/ReconstructionCoverageService.js";
 import { reconstructionClosureResultSchema } from "../../domain/reconstructionCoverage.js";
 import { AnalysisCapabilityUnavailableError, EvidenceIntegrityError, } from "../../domain/errors.js";
@@ -11,8 +11,8 @@ import { toCallToolResult } from "../toolResult.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { safeParseToolInput } from "../toolInputValidation.js";
 import { coverageWorkspaceUri } from "./helpers.js";
-const commitContract = APPLICATION_TOOL_CONTRACTS[5];
-const queryContract = APPLICATION_TOOL_CONTRACTS[6];
+const commitContract = applicationToolContract("commit_reconstruction_coverage");
+const queryContract = applicationToolContract("query_reconstruction_coverage");
 /** Register reconstruction coverage commit and query tools. */
 export const registerCoverageTools = (server, options) => {
     registerCommitTool(server, options);

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/registerEvidenceResources.js

@@ -317,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/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/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/serverIdentity.js

@@ -68,3 +68,22 @@ export const createServerIdentity = (input) => {
         },
     };
 };
+/** Compact identity projection for CLI summaries; MCP retains full identity. */
+export const createServerIdentitySummary = (input) => {
+    const identity = createServerIdentity(input);
+    return {
+        package: {
+            name: identity.package.name,
+            version: identity.package.version,
+        },
+        server: {
+            name: identity.server.name,
+            version: identity.server.version,
+        },
+        catalog: {
+            counts: identity.catalog.counts,
+            digests: identity.catalog.digests,
+        },
+        alignment: identity.alignment,
+    };
+};