You have brightestX and brightestY. Use get() with these coordinates to have the color of this pixel, before the start of the second loop. Then use it in stroke() to set the color of the line.

Alright, I've tried to do what you suggested but clearly my lack of experience is starting to show. Everything I have tried to use has come back with an unexpected token error. What am I doing wrong or where should I be putting the get(brightestX,brightestY), or is it simply get(x,y)? Thanks again for your help

" unexpected token error"
So you have a base syntax error.
Show what you tried, we will point out where the error is.

Alright, so I fixed my initial problem (I had the get() command in the wrong spot). However, now that it is working, I have come across a new issue.

Every time the stroke identifies a new color, it erases the old line and starts drawing a new one. So I can only ever get a few short snippets of any particular color.

Here is the code. The get() command was added on Line 43 (not entirely sure that is what you originally meant with your comment, but it is working alright at the moment).

1. int oldX = 0;
2. int oldY = 0;
3. import processing.video.*;
4. Capture video;
5. void setup() {
6.   size(320, 240); // Change size to 320 x 240 if too slow at 640 x 480
7.   // Uses the default video input, see the reference if this causes an error
8.   //background (0);
9.   video = new Capture(this, width, height, 30);
10.   noStroke();
11.   smooth();
12. }
13. void draw() {
14.   if (video.available()) {
15.     video.read();
16.    
17.     image (video, 0, 0, width, height); // Draw the webcam video onto the screen
18.     int brightestX = 0; // X-coordinate of the brightest video pixel
19.     int brightestY = 0; // Y-coordinate of the brightest video pixel
20.     float brightestValue = 0; // Brightness of the brightest video pixel
21.    
22.     // Search for the brightest pixel: For each row of pixels in the video image and
23.     // for each pixel in the yth row, compute each pixel's index in the video
24.     video.loadPixels();
25.     int index = 0;
26.     for (int y = 0; y < video.height; y++) {
27.       for (int x = 0; x < video.width; x++) {
28.         // Get the color stored in the pixel
29.         int pixelValue = video.pixels[index];
30.         // Determine the brightness of the pixel
31.         float pixelBrightness = brightness(pixelValue);
32.         // If that value is brighter than any previous, then store the
33.         // brightness of that pixel, as well as its (x,y) location
34.         if (pixelBrightness > brightestValue) {
35.           brightestValue = pixelBrightness;
36.           brightestY = y;
37.           brightestX = x;
38.         }
39.         index++;
40.       }
41.     }
42.    
43.     color p = get(brightestX,brightestY);
44.     stroke (p);
45.     background (0);
46.     noFill();
47.     float r,g,b;
48.     int x,y,x2,y2;
49.     color c;
50.     float bright;
51.     for (y = 0; y<video.height; y++)
52.     {
53.       for (x=0; x<video.width; x++)
54.       {
55.          c = video.get(x,y);
56.          bright = brightness(c);
57.          if (bright > 110)
58.          {
59.              strokeWeight (3);
60.              line(oldX, oldY, brightestX, brightestY);
61.              oldX = brightestX;
62.              oldY = brightestY;
63.          }
64.       }
65.     } 
66.   }
67. }

I essentially need to create a "line history" that will maintain 40 - 50 lines as it goes through its color changes so it will create a continuous, multicolored line. Honestly, I have absolutely no idea on how to develop that or even where to start.

As always, thank you for your help.

The sketch http://bazaar.launchpad.net/~philho/+junk/Processing/view/head:/_QuickExperiments/_Interactive/LineQueue/LineQueue.pde shows something similar.
It shows how to store locations with a PVector, and to keep only the n last ones.