diff --git a/client/dive-common/apispec.ts b/client/dive-common/apispec.ts
index 55fca437c..763cde7e9 100644
--- a/client/dive-common/apispec.ts
+++ b/client/dive-common/apispec.ts
@@ -418,6 +418,78 @@ export interface SegmentationStatusResponse {
   ready?: boolean;
 }
 
+/**
+ * Text Query Types for open-vocabulary detection/segmentation
+ */
+
+/** A single detection returned from a text query */
+export interface TextQueryDetection {
+  /** Bounding box [x1, y1, x2, y2] */
+  box: [number, number, number, number];
+  /** Polygon coordinates as [x, y] pairs */
+  polygon?: [number, number][];
+  /** Confidence score */
+  score: number;
+  /** Label/class name (often the query text) */
+  label: string;
+  /** Low-res mask for refinement (optional) */
+  lowResMask?: number[][];
+}
+
+export interface TextQueryRequest {
+  /** Path to the image file */
+  imagePath: string;
+  /** Text query describing what to find (e.g., "fish", "person swimming") */
+  text: string;
+  /** Confidence threshold for detections (default: 0.3) */
+  boxThreshold?: number;
+  /** Maximum number of detections to return (default: 10) */
+  maxDetections?: number;
+  /** Optional boxes to refine [x1, y1, x2, y2][] */
+  boxes?: [number, number, number, number][];
+  /** Optional keypoints for refinement [x, y][] */
+  points?: [number, number][];
+  /** Labels for points: 1 for foreground, 0 for background */
+  pointLabels?: number[];
+  /** Optional masks to refine */
+  masks?: number[][][];
+}
+
+export interface TextQueryResponse {
+  /** Whether the query succeeded */
+  success: boolean;
+  /** Error message if failed */
+  error?: string;
+  /** List of detections found */
+  detections?: TextQueryDetection[];
+  /** The original query text */
+  query?: string;
+  /** Whether fallback method was used (no native text support) */
+  fallback?: boolean;
+}
+
+export interface RefineDetectionsRequest {
+  /** Path to the image file */
+  imagePath: string;
+  /** Detections to refine */
+  detections: TextQueryDetection[];
+  /** Optional additional keypoints for refinement [x, y][] */
+  points?: [number, number][];
+  /** Labels for additional points: 1 for foreground, 0 for background */
+  pointLabels?: number[];
+  /** Whether to include refined masks in response */
+  refineMasks?: boolean;
+}
+
+export interface RefineDetectionsResponse {
+  /** Whether the refinement succeeded */
+  success: boolean;
+  /** Error message if failed */
+  error?: string;
+  /** Refined detections */
+  detections?: TextQueryDetection[];
+}
+
 export {
   provideApi,
   useApi,
diff --git a/client/dive-common/components/EditorMenu.vue b/client/dive-common/components/EditorMenu.vue
index 4366737c6..761c189e7 100644
--- a/client/dive-common/components/EditorMenu.vue
+++ b/client/dive-common/components/EditorMenu.vue
@@ -80,11 +80,18 @@ export default defineComponent({
       type: Boolean,
       default: true,
     },
+    textQueryEnabled: {
+      type: Boolean,
+      default: false,
+    },
   },
   emits: [
     'set-annotation-state',
     'update:tail-settings',
     'update:show-user-created-icon',
+    'text-query-init',
+    'text-query',
+    'text-query-all-frames',
   ],
   setup(props, { emit }) {
     const toolTimeTimeout = ref<number | null>(null);
@@ -103,6 +110,59 @@ export default defineComponent({
       localStorage.setItem(STORAGE_KEY, String(value));
     });
 
+    // Text query state
+    const textQueryDialogOpen = ref(false);
+    const textQueryInput = ref('');
+    const textQueryLoading = ref(false);
+    const textQueryThreshold = ref(0.3);
+    const textQueryInitializing = ref(false);
+    const textQueryServiceError = ref('');
+    const textQueryAllFrames = ref(false);
+
+    const openTextQueryDialog = () => {
+      textQueryDialogOpen.value = true;
+      textQueryInput.value = '';
+      textQueryServiceError.value = '';
+      textQueryAllFrames.value = false;
+      textQueryInitializing.value = true;
+      emit('text-query-init');
+    };
+
+    const closeTextQueryDialog = () => {
+      textQueryDialogOpen.value = false;
+      textQueryInput.value = '';
+      textQueryServiceError.value = '';
+      textQueryInitializing.value = false;
+      textQueryAllFrames.value = false;
+    };
+
+    const onTextQueryServiceReady = (success: boolean, error?: string) => {
+      textQueryInitializing.value = false;
+      if (!success) {
+        textQueryServiceError.value = error || 'Text query service is not available';
+      }
+    };
+
+    const submitTextQuery = () => {
+      if (!textQueryInput.value.trim()) {
+        return;
+      }
+      textQueryLoading.value = true;
+      if (textQueryAllFrames.value) {
+        emit('text-query-all-frames', {
+          text: textQueryInput.value.trim(),
+          boxThreshold: textQueryThreshold.value,
+        });
+      } else {
+        emit('text-query', {
+          text: textQueryInput.value.trim(),
+          boxThreshold: textQueryThreshold.value,
+        });
+      }
+      closeTextQueryDialog();
+      textQueryLoading.value = false;
+    };
+
     const modeToolTips = {
       Creating: {
         rectangle: 'Drag to draw rectangle. Press ESC to exit.',
@@ -151,6 +211,18 @@ export default defineComponent({
             ...r.mousetrap(),
           ],
         })),
+        /* Text Query button included alongside other annotation types (desktop only) */
+        ...(props.textQueryEnabled ? [{
+          id: 'Text Query',
+          icon: 'mdi-text-search',
+          active: false,
+          description: 'Text Query',
+          mousetrap: [{
+            bind: 't',
+            handler: () => openTextQueryDialog(),
+          }],
+          click: () => openTextQueryDialog(),
+        }] : []),
       ];
     });
 
@@ -253,6 +325,18 @@ export default defineComponent({
       segmentationPredicting,
       segmentationLoading,
       segmentationTooltip,
+      // Text query
+      textQueryDialogOpen,
+      textQueryInput,
+      textQueryLoading,
+      textQueryThreshold,
+      textQueryInitializing,
+      textQueryServiceError,
+      textQueryAllFrames,
+      openTextQueryDialog,
+      closeTextQueryDialog,
+      onTextQueryServiceReady,
+      submitTextQuery,
     };
   },
 });
@@ -434,6 +518,108 @@ export default defineComponent({
         @update:show-user-created-icon="$emit('update:show-user-created-icon', $event)"
       />
     </div>
+
+    <!-- Text Query Dialog -->
+    <v-dialog
+      v-if="textQueryEnabled"
+      v-model="textQueryDialogOpen"
+      max-width="500"
+      :persistent="textQueryInitializing || textQueryLoading"
+    >
+      <v-card>
+        <v-card-title class="text-h6">
+          <v-icon left>
+            mdi-text-search
+          </v-icon>
+          Text Query
+        </v-card-title>
+        <v-card-text>
+          <!-- Loading state while initializing service -->
+          <div
+            v-if="textQueryInitializing"
+            class="text-center py-4"
+          >
+            <v-progress-circular
+              indeterminate
+              color="primary"
+              size="48"
+            />
+            <p class="text-body-2 mt-3">
+              Loading text query model...
+            </p>
+          </div>
+          <!-- Error state if service failed to initialize -->
+          <div
+            v-else-if="textQueryServiceError"
+            class="text-center py-4"
+          >
+            <v-icon
+              color="error"
+              size="48"
+            >
+              mdi-alert-circle
+            </v-icon>
+            <p class="text-body-2 mt-3 error--text">
+              {{ textQueryServiceError }}
+            </p>
+          </div>
+          <!-- Normal input form when service is ready -->
+          <template v-else>
+            <p class="text-body-2 mb-3">
+              Enter a description of objects to find in the current frame.
+            </p>
+            <v-text-field
+              v-model="textQueryInput"
+              label="Object description"
+              placeholder="e.g., fish swimming near coral"
+              outlined
+              dense
+              autofocus
+              :disabled="textQueryLoading"
+              @keyup.enter="submitTextQuery"
+            />
+            <v-slider
+              v-model="textQueryThreshold"
+              label="Confidence threshold"
+              min="0.1"
+              max="0.9"
+              step="0.05"
+              thumb-label
+              :disabled="textQueryLoading"
+            />
+            <v-checkbox
+              v-model="textQueryAllFrames"
+              label="Apply to all frames"
+              hint="Run across all frames instead of only the current (this will run as a job)"
+              persistent-hint
+              :disabled="textQueryLoading"
+            />
+          </template>
+          <p class="text-caption mt-3 mb-0 text--secondary">
+            Textual query support uses architectures derived from Meta's SAM3 project
+          </p>
+        </v-card-text>
+        <v-card-actions>
+          <v-spacer />
+          <v-btn
+            text
+            :disabled="textQueryLoading"
+            @click="closeTextQueryDialog"
+          >
+            {{ textQueryServiceError ? 'Close' : 'Cancel' }}
+          </v-btn>
+          <v-btn
+            v-if="!textQueryInitializing && !textQueryServiceError"
+            color="primary"
+            :loading="textQueryLoading"
+            :disabled="!textQueryInput.trim() || textQueryLoading"
+            @click="submitTextQuery"
+          >
+            Search
+          </v-btn>
+        </v-card-actions>
+      </v-card>
+    </v-dialog>
   </v-row>
 </template>
 
diff --git a/client/dive-common/components/Viewer.vue b/client/dive-common/components/Viewer.vue
index ea2580422..7bd5d57bd 100644
--- a/client/dive-common/components/Viewer.vue
+++ b/client/dive-common/components/Viewer.vue
@@ -127,6 +127,10 @@ export default defineComponent({
       type: Array as PropType<string[]>,
       default: () => [],
     },
+    textQueryEnabled: {
+      type: Boolean,
+      default: false,
+    },
   },
   setup(props, { emit }) {
     const { prompt, visible } = usePrompt();
@@ -170,6 +174,17 @@ export default defineComponent({
     const controlsRef = ref();
     const controlsHeight = ref(0);
     const controlsCollapsed = ref(false);
+    const editorMenuRef = ref();
+
+    /**
+     * Forward text query service ready status to EditorMenu
+     * Called by ViewerLoader when text query service initialization completes
+     */
+    function onTextQueryServiceReady(success: boolean, error?: string) {
+      if (editorMenuRef.value?.onTextQueryServiceReady) {
+        editorMenuRef.value.onTextQueryServiceReady(success, error);
+      }
+    }
 
     const sideBarCollapsed = ref(false);
     // Sidebar mode: 'left', 'bottom', or 'collapsed'
@@ -1233,6 +1248,8 @@ export default defineComponent({
       controlsHeight,
       controlsCollapsed,
       sideBarCollapsed,
+      editorMenuRef,
+      onTextQueryServiceReady,
       sidebarMode,
       cycleSidebarMode,
       sidebarModeIcon,
@@ -1417,6 +1434,7 @@ export default defineComponent({
         </v-tooltip>
 
         <EditorMenu
+          ref="editorMenuRef"
           v-bind="{
             editingMode,
             visibleModes,
@@ -1427,11 +1445,15 @@ export default defineComponent({
             groupEditActive: editingGroupId !== null,
             lassoModeActive: !readonlyState && lassoModeActive,
             lassoDrawing: !readonlyState && lassoDrawing,
+            textQueryEnabled,
           }"
           :tail-settings.sync="clientSettings.annotatorPreferences.trackTails"
           :show-user-created-icon.sync="clientSettings.annotatorPreferences.showUserCreatedIcon"
           @set-annotation-state="handler.setAnnotationState"
           @exit-edit="handler.trackAbort"
+          @text-query-init="$emit('text-query-init')"
+          @text-query="$emit('text-query', $event)"
+          @text-query-all-frames="$emit('text-query-all-frames', $event)"
         >
           <template slot="delete-controls">
             <delete-controls
diff --git a/client/platform/desktop/backend/ipcService.ts b/client/platform/desktop/backend/ipcService.ts
index 91a5664d1..1857c9e93 100644
--- a/client/platform/desktop/backend/ipcService.ts
+++ b/client/platform/desktop/backend/ipcService.ts
@@ -375,6 +375,49 @@ export default function register() {
     return { ready: segService.isSegmentationReady() };
   });
 
+  ipcMain.handle('segmentation-text-query', async (_, args: {
+    imagePath: string;
+    text: string;
+    boxThreshold?: number;
+    maxDetections?: number;
+    boxes?: [number, number, number, number][];
+    points?: [number, number][];
+    pointLabels?: number[];
+  }) => {
+    const segService = getInteractiveServiceManager();
+
+    // Auto-initialize if not ready
+    if (!segService.isSegmentationReady()) {
+      await segService.initialize(settings.get());
+    }
+
+    const response = await segService.textQuery(args);
+    return response;
+  });
+
+  ipcMain.handle('segmentation-refine', async (_, args: {
+    imagePath: string;
+    detections: {
+      box: [number, number, number, number];
+      polygon?: [number, number][];
+      score: number;
+      label: string;
+    }[];
+    points?: [number, number][];
+    pointLabels?: number[];
+    refineMasks?: boolean;
+  }) => {
+    const segService = getInteractiveServiceManager();
+
+    // Auto-initialize if not ready
+    if (!segService.isSegmentationReady()) {
+      await segService.initialize(settings.get());
+    }
+
+    const response = await segService.refineDetections(args);
+    return response;
+  });
+
   /**
    * Interactive Stereo Service
    */
diff --git a/client/platform/desktop/backend/native/interactive.ts b/client/platform/desktop/backend/native/interactive.ts
index 3df410405..75b4d089b 100644
--- a/client/platform/desktop/backend/native/interactive.ts
+++ b/client/platform/desktop/backend/native/interactive.ts
@@ -450,6 +450,53 @@ export class InteractiveServiceManager extends EventEmitter {
     return { success: true };
   }
 
+  async textQuery(request: {
+    imagePath: string;
+    text: string;
+    boxThreshold?: number;
+    maxDetections?: number;
+    boxes?: [number, number, number, number][];
+    points?: [number, number][];
+    pointLabels?: number[];
+    frameTime?: number;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  }): Promise<any> {
+    return this.sendRequest({
+      command: 'text_query',
+      image_path: request.imagePath,
+      text: request.text,
+      box_threshold: request.boxThreshold ?? 0.3,
+      max_detections: request.maxDetections ?? 10,
+      boxes: request.boxes,
+      points: request.points,
+      point_labels: request.pointLabels,
+      frame_time: request.frameTime,
+    }, 'Text query');
+  }
+
+  async refineDetections(request: {
+    imagePath: string;
+    detections: {
+      box: [number, number, number, number];
+      polygon?: [number, number][];
+      score: number;
+      label: string;
+    }[];
+    points?: [number, number][];
+    pointLabels?: number[];
+    refineMasks?: boolean;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  }): Promise<any> {
+    return this.sendRequest({
+      command: 'refine',
+      image_path: request.imagePath,
+      detections: request.detections,
+      points: request.points,
+      point_labels: request.pointLabels,
+      refine_masks: request.refineMasks ?? true,
+    }, 'Refine');
+  }
+
   // ----------------------------------------------------------- stereo API
 
   async enable(
diff --git a/client/platform/desktop/frontend/api.ts b/client/platform/desktop/frontend/api.ts
index 7d6acd865..731b75c35 100644
--- a/client/platform/desktop/frontend/api.ts
+++ b/client/platform/desktop/frontend/api.ts
@@ -7,6 +7,7 @@ import type {
   DatasetCalibrationResult,
   SegmentationPredictRequest, SegmentationPredictResponse, SegmentationStatusResponse,
   SegmentationStereoSegmentRequest, SegmentationStereoSegmentResponse,
+  TextQueryRequest, TextQueryResponse, RefineDetectionsRequest, RefineDetectionsResponse,
 } from 'dive-common/apispec';
 
 import {
@@ -334,6 +335,50 @@ async function segmentationIsReady(): Promise<SegmentationStatusResponse> {
   return window.diveDesktop.invoke('segmentation-is-ready');
 }
 
+/**
+ * Text Query API
+ * Allows open-vocabulary detection and segmentation using text prompts
+ */
+
+async function textQuery(request: TextQueryRequest): Promise<TextQueryResponse> {
+  return window.diveDesktop.invoke('segmentation-text-query', request);
+}
+
+async function refineDetections(request: RefineDetectionsRequest): Promise<RefineDetectionsResponse> {
+  return window.diveDesktop.invoke('segmentation-refine', request);
+}
+
+/**
+ * Run text query pipeline on all frames
+ */
+async function runTextQueryPipeline(
+  datasetId: string,
+  queryText: string,
+  threshold?: number,
+): Promise<void> {
+  const pipeline: Pipe = {
+    name: 'Text Query',
+    pipe: 'utility_text_query.pipe',
+    type: 'utility',
+  };
+
+  const pipelineParams: Record<string, string> = {
+    'track_refiner:refiner:text_query': queryText,
+  };
+
+  if (threshold !== undefined) {
+    pipelineParams['track_refiner:refiner:detection_threshold'] = threshold.toString();
+  }
+
+  const args: RunPipeline = {
+    type: JobType.RunPipeline,
+    pipeline,
+    datasetId,
+    pipelineParams,
+  };
+  gpuJobQueue.enqueue(args);
+}
+
 /**
  * Interactive Stereo API
  */
@@ -656,6 +701,10 @@ export {
   segmentationClearImage,
   segmentationShutdown,
   segmentationIsReady,
+  /* Text Query APIs */
+  textQuery,
+  refineDetections,
+  runTextQueryPipeline,
   /* Stereo APIs */
   stereoEnable,
   stereoDisable,
diff --git a/client/platform/desktop/frontend/components/ViewerLoader.vue b/client/platform/desktop/frontend/components/ViewerLoader.vue
index a56d6f900..6471a65b7 100644
--- a/client/platform/desktop/frontend/components/ViewerLoader.vue
+++ b/client/platform/desktop/frontend/components/ViewerLoader.vue
@@ -24,7 +24,8 @@ import {
 import type { RectBounds } from 'vue-media-annotator/utils';
 import {
   segmentationPredict, segmentationStereoSegment, segmentationInitialize, segmentationIsReady,
-  loadMetadata,
+  loadMetadata, textQuery,
+  runTextQueryPipeline,
   stereoEnable, stereoDisable, stereoSetFrame, stereoTransferLine, stereoTransferPoints,
   stereoMeasureLine, stereoAggregateLengths,
   onStereoDisparityReady, onStereoDisparityError,
@@ -277,7 +278,7 @@ export default defineComponent({
       }
     }
 
-    // Store metadata for video frame-time / image path resolution
+    // Store metadata for text query image path resolution
     let cachedMeta: {
       originalBasePath: string;
       originalImageFiles: string[];
@@ -285,11 +286,225 @@ export default defineComponent({
       originalVideoFile?: string;
     } | null = null;
 
+    /**
+     * Get image path for a given frame number
+     */
+    function getImagePathForFrame(frameNum: number): string {
+      if (!cachedMeta) {
+        return '';
+      }
+      const { originalBasePath, originalImageFiles, type } = cachedMeta;
+      if (type === 'video') {
+        // Video datasets require frame extraction - not yet supported
+        return npath.join(originalBasePath, cachedMeta.originalVideoFile || '');
+      }
+      if (originalImageFiles && originalImageFiles[frameNum]) {
+        const imagePath = originalImageFiles[frameNum];
+        if (npath.isAbsolute(imagePath)) {
+          return imagePath;
+        }
+        return npath.join(originalBasePath, imagePath);
+      }
+      return '';
+    }
+
+    /**
+     * Handle text query submission from Viewer
+     */
+    async function handleTextQuerySubmit(params: {
+      text: string;
+      boxThreshold: number;
+      frameNum: number;
+    }) {
+      const { text, boxThreshold, frameNum } = params;
+
+      // Ensure metadata is loaded
+      if (!cachedMeta) {
+        try {
+          const meta = await loadMetadata(props.id);
+          cachedMeta = {
+            originalBasePath: meta.originalBasePath,
+            originalImageFiles: meta.originalImageFiles,
+            type: meta.type,
+            originalVideoFile: meta.originalVideoFile,
+          };
+        } catch {
+          await prompt({
+            title: 'Text Query Error',
+            text: ['Failed to load dataset metadata for text query.'],
+          });
+          return;
+        }
+      }
+
+      const imagePath = getImagePathForFrame(frameNum);
+      if (!imagePath) {
+        await prompt({
+          title: 'Text Query Error',
+          text: ['Could not determine image path for current frame.'],
+        });
+        return;
+      }
+
+      try {
+        const response = await textQuery({
+          imagePath,
+          text,
+          boxThreshold,
+          maxDetections: 10,
+        });
+
+        if (!response.success) {
+          throw new Error(response.error || 'Text query failed');
+        }
+
+        const detections = response.detections || [];
+
+        if (detections.length === 0) {
+          await prompt({
+            title: 'Text Query Results',
+            text: [`No objects matching "${text}" were found in the current frame.`],
+          });
+          return;
+        }
+
+        // Create tracks from detections
+        if (viewerRef.value) {
+          const { cameraStore } = viewerRef.value;
+          const selectedCamera = viewerRef.value.selectedCamera || 'singleCam';
+          const trackStore = cameraStore.camMap.value.get(selectedCamera)?.trackStore;
+
+          if (!trackStore) {
+            await prompt({
+              title: 'Text Query Error',
+              text: ['Could not create tracks - trackStore not found.'],
+            });
+            return;
+          }
+
+          detections.forEach((det) => {
+            // Get a new unique track ID
+            const newTrackId = cameraStore.getNewTrackId();
+
+            // Create a new track with the detection label as its type
+            const newTrack = trackStore.add(
+              frameNum,
+              det.label, // Use the detection label as the track type
+              undefined, // No parent track
+              newTrackId, // Use the new track ID
+            );
+
+            // Calculate bounds from box [x1, y1, x2, y2]
+            const [x1, y1, x2, y2] = det.box;
+            const bounds = [x1, y1, x2, y2] as [number, number, number, number];
+
+            // Create GeoJSON features array for polygon if available
+            const geoJsonFeatures: GeoJSON.Feature[] = [];
+            if (det.polygon && det.polygon.length >= 3) {
+              // Ensure polygon is closed (first point = last point for GeoJSON)
+              const closedPolygon = [...det.polygon];
+              const first = closedPolygon[0];
+              const last = closedPolygon[closedPolygon.length - 1];
+              if (first[0] !== last[0] || first[1] !== last[1]) {
+                closedPolygon.push([...first] as [number, number]);
+              }
+
+              const polygonFeature: GeoJSON.Feature = {
+                type: 'Feature',
+                geometry: {
+                  type: 'Polygon',
+                  coordinates: [closedPolygon],
+                },
+                properties: { key: '' },
+              };
+              geoJsonFeatures.push(polygonFeature);
+            }
+
+            // Set the feature with bounds and optional polygon
+            newTrack.setFeature({
+              frame: frameNum,
+              flick: 0,
+              keyframe: true,
+              bounds,
+              interpolate: false, // Single detection, no interpolation
+            }, geoJsonFeatures.length > 0 ? geoJsonFeatures : undefined);
+          });
+
+          await prompt({
+            title: 'Text Query Results',
+            text: [`Created ${detections.length} tracks for objects matching "${text}".`],
+          });
+        }
+      } catch (error) {
+        await prompt({
+          title: 'Text Query Error',
+          text: [`Failed to execute text query: ${error}`],
+        });
+      } finally {
+        // Exit edit/draw mode after text query completes (success or failure)
+        if (viewerRef.value?.handler) {
+          viewerRef.value.handler.trackAbort();
+        }
+      }
+    }
+
     // Initialize segmentation when component is mounted
     onMounted(() => {
       initializeSegmentation();
     });
 
+    /**
+     * Handle text query service initialization request
+     * Called when user opens the text query dialog
+     */
+    async function handleTextQueryInit() {
+      try {
+        // Check if the service is already ready
+        const status = await segmentationIsReady();
+        if (status.ready) {
+          viewerRef.value?.onTextQueryServiceReady(true);
+          return;
+        }
+
+        // Try to initialize the service
+        await segmentationInitialize();
+        viewerRef.value?.onTextQueryServiceReady(true);
+      } catch (error) {
+        // Provide text-query specific error message instead of generic segmentation error
+        const rawMessage = error instanceof Error ? error.message : '';
+        const errorMessage = rawMessage.toLowerCase().includes('segmentation')
+          ? 'Unable to load text query model. Please ensure the service is properly configured.'
+          : (rawMessage || 'Text query model is not available. Please ensure the service is properly configured.');
+        viewerRef.value?.onTextQueryServiceReady(false, errorMessage);
+      }
+    }
+
+    /**
+     * Handle text query on all frames - runs as a pipeline job
+     */
+    async function handleTextQueryAllFrames(params: {
+      text: string;
+      boxThreshold: number;
+    }) {
+      const { text, boxThreshold } = params;
+
+      try {
+        await runTextQueryPipeline(props.id, text, boxThreshold);
+        await prompt({
+          title: 'Text Query Pipeline Started',
+          text: [
+            `A pipeline job has been started to search for "${text}" in all frames.`,
+            'You will be notified when the job completes.',
+          ],
+        });
+      } catch (error) {
+        await prompt({
+          title: 'Text Query Pipeline Error',
+          text: [`Failed to start text query pipeline: ${error}`],
+        });
+      }
+    }
+
     /**
      * Interactive Stereo Service
      */
@@ -1334,6 +1549,9 @@ export default defineComponent({
       runningPipelines,
       largeImageWarning,
       timeFilter,
+      handleTextQuerySubmit,
+      handleTextQueryInit,
+      handleTextQueryAllFrames,
       /* Stereo */
       stereoLoadingDialog,
       stereoLoadingMessage,
@@ -1358,8 +1576,12 @@ export default defineComponent({
       :id.sync="id"
       ref="viewerRef"
       :read-only-mode="readOnlyMode || runningPipelines.length > 0"
+      :text-query-enabled="true"
       @change-camera="changeCamera"
       @large-image-warning="largeImageWarning()"
+      @text-query-submit="handleTextQuerySubmit"
+      @text-query-init="handleTextQueryInit"
+      @text-query-all-frames="handleTextQueryAllFrames"
       @stereo-annotation-complete="handleStereoAnnotationComplete"
       @stereo-annotation-reset="handleStereoAnnotationReset"
       @stereo-segmentation-finalize="handleStereoSegmentationFinalize"