diff --git a/client/dive-common/apispec.ts b/client/dive-common/apispec.ts
index 55fca437c..78c40b8ec 100644
--- a/client/dive-common/apispec.ts
+++ b/client/dive-common/apispec.ts
@@ -418,6 +418,81 @@ 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 (or video file for video datasets) */
+  imagePath: string;
+  /** Frame time in seconds, required when imagePath is a video so the service
+   * extracts the correct frame. Omitted for image-sequence datasets. */
+  frameTime?: number;
+  /** 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..8073bcd46 100644
--- a/client/dive-common/components/EditorMenu.vue
+++ b/client/dive-common/components/EditorMenu.vue
@@ -23,11 +23,15 @@ interface ButtonData {
   type?: VisibleAnnotationTypes;
   active: boolean;
   loading?: boolean;
+  unavailable?: boolean;
+  unavailableTooltip?: string;
   mousetrap?: Mousetrap[];
   description: string;
   click: () => void;
 }
 
+const SAM3_ADDON_WIKI_URL = 'https://github.com/VIAME/VIAME/wiki/Model-Zoo-and-Add-Ons';
+
 export default defineComponent({
   name: 'EditorMenu',
   components: {
@@ -80,11 +84,23 @@ export default defineComponent({
       type: Boolean,
       default: true,
     },
+    textQueryEnabled: {
+      type: Boolean,
+      default: false,
+    },
+    textQueryAvailable: {
+      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',
+    'open-external-link',
   ],
   setup(props, { emit }) {
     const toolTimeTimeout = ref<number | null>(null);
@@ -103,6 +119,87 @@ 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);
+    // When on, existing annotations are removed before the query results are
+    // applied. On by default so a query replaces rather than accumulates.
+    const textQueryReplaceExisting = ref(true);
+    const sam3InfoDialogOpen = ref(false);
+
+    const openSam3InfoDialog = () => {
+      sam3InfoDialogOpen.value = true;
+    };
+
+    const closeSam3InfoDialog = () => {
+      sam3InfoDialogOpen.value = false;
+    };
+
+    const openSam3AddonWiki = () => {
+      emit('open-external-link', SAM3_ADDON_WIKI_URL);
+    };
+
+    const handleTextQueryClick = () => {
+      if (!props.textQueryAvailable) {
+        openSam3InfoDialog();
+        return;
+      }
+      openTextQueryDialog();
+    };
+
+    const openTextQueryDialog = () => {
+      textQueryDialogOpen.value = true;
+      textQueryInput.value = '';
+      textQueryServiceError.value = '';
+      textQueryAllFrames.value = false;
+      textQueryReplaceExisting.value = true;
+      textQueryInitializing.value = true;
+      emit('text-query-init');
+    };
+
+    const closeTextQueryDialog = () => {
+      textQueryDialogOpen.value = false;
+      textQueryInput.value = '';
+      textQueryServiceError.value = '';
+      textQueryInitializing.value = false;
+      textQueryAllFrames.value = false;
+      textQueryReplaceExisting.value = true;
+    };
+
+    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,
+          replaceExisting: textQueryReplaceExisting.value,
+        });
+      } else {
+        emit('text-query', {
+          text: textQueryInput.value.trim(),
+          boxThreshold: textQueryThreshold.value,
+          replaceExisting: textQueryReplaceExisting.value,
+        });
+      }
+      closeTextQueryDialog();
+      textQueryLoading.value = false;
+    };
+
     const modeToolTips = {
       Creating: {
         rectangle: 'Drag to draw rectangle. Press ESC to exit.',
@@ -151,6 +248,20 @@ 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,
+          unavailable: !props.textQueryAvailable,
+          unavailableTooltip: 'SAM3 add-on not installed. Click for more information.',
+          description: 'Text Query',
+          mousetrap: [{
+            bind: 'q',
+            handler: () => handleTextQueryClick(),
+          }],
+          click: () => handleTextQueryClick(),
+        }] : []),
       ];
     });
 
@@ -253,6 +364,22 @@ export default defineComponent({
       segmentationPredicting,
       segmentationLoading,
       segmentationTooltip,
+      // Text query
+      textQueryDialogOpen,
+      textQueryInput,
+      textQueryLoading,
+      textQueryThreshold,
+      textQueryInitializing,
+      textQueryServiceError,
+      textQueryAllFrames,
+      textQueryReplaceExisting,
+      openTextQueryDialog,
+      closeTextQueryDialog,
+      onTextQueryServiceReady,
+      submitTextQuery,
+      sam3InfoDialogOpen,
+      closeSam3InfoDialog,
+      openSam3AddonWiki,
     };
   },
 });
@@ -342,19 +469,33 @@ export default defineComponent({
               :key="`${button.id}-menu`"
             >
               <v-list-item-icon>
-                <v-btn
-                  :disabled="!editingMode || button.loading"
-                  :outlined="!button.active"
-                  :color="button.active ? editingHeader.color : ''"
-                  class="mx-1"
-                  small
-                  @click="button.click"
+                <v-tooltip
+                  bottom
+                  :disabled="!button.unavailable"
                 >
-                  <pre v-if="button.mousetrap">{{ button.mousetrap[0].bind }}:</pre>
-                  <v-icon :class="{ 'mdi-spin': button.loading }">
-                    {{ button.icon }}
-                  </v-icon>
-                </v-btn>
+                  <template #activator="{ on: tooltipOn, attrs: tooltipAttrs }">
+                    <span
+                      v-bind="button.unavailable ? tooltipAttrs : {}"
+                      v-on="button.unavailable ? tooltipOn : {}"
+                    >
+                      <v-btn
+                        :disabled="button.unavailable ? !!button.loading : (!editingMode || !!button.loading)"
+                        :outlined="!button.active"
+                        :color="button.active ? editingHeader.color : ''"
+                        :class="{ 'edit-btn-unavailable': button.unavailable && !button.loading }"
+                        class="mx-1"
+                        small
+                        @click="button.click"
+                      >
+                        <pre v-if="button.mousetrap">{{ button.mousetrap[0].bind }}:</pre>
+                        <v-icon :class="{ 'mdi-spin': button.loading }">
+                          {{ button.icon }}
+                        </v-icon>
+                      </v-btn>
+                    </span>
+                  </template>
+                  <span>{{ button.unavailableTooltip }}</span>
+                </v-tooltip>
               </v-list-item-icon>
               <v-list-item-content>
                 <v-list-item-title>{{ button.id }}</v-list-item-title>
@@ -380,21 +521,36 @@ export default defineComponent({
               />
             </span>
           </template>
-          <v-btn
+          <v-tooltip
             v-for="button in editButtons"
             :key="button.id + 'view'"
-            :disabled="!editingMode || button.loading"
-            :outlined="!button.active"
-            :color="button.active ? editingHeader.color : ''"
-            class="mx-1"
-            small
-            @click="button.click"
+            bottom
+            :disabled="!button.unavailable"
           >
-            <pre v-if="button.mousetrap">{{ button.mousetrap[0].bind }}:</pre>
-            <v-icon :class="{ 'mdi-spin': button.loading }">
-              {{ button.icon }}
-            </v-icon>
-          </v-btn>
+            <template #activator="{ on: tooltipOn, attrs: tooltipAttrs }">
+              <span
+                v-bind="button.unavailable ? tooltipAttrs : {}"
+                class="d-inline-block"
+                v-on="button.unavailable ? tooltipOn : {}"
+              >
+                <v-btn
+                  :disabled="button.unavailable ? !!button.loading : (!editingMode || !!button.loading)"
+                  :outlined="!button.active"
+                  :color="button.active ? editingHeader.color : ''"
+                  :class="{ 'edit-btn-unavailable': button.unavailable && !button.loading }"
+                  class="mx-1"
+                  small
+                  @click="button.click"
+                >
+                  <pre v-if="button.mousetrap">{{ button.mousetrap[0].bind }}:</pre>
+                  <v-icon :class="{ 'mdi-spin': button.loading }">
+                    {{ button.icon }}
+                  </v-icon>
+                </v-btn>
+              </span>
+            </template>
+            <span>{{ button.unavailableTooltip }}</span>
+          </v-tooltip>
         </outlined-labeled-group>
       </span>
       <!-- Segmentation Reset button -->
@@ -434,6 +590,163 @@ 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: ${Number(textQueryThreshold).toFixed(2)}`"
+              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"
+            />
+            <v-checkbox
+              v-model="textQueryReplaceExisting"
+              label="Replace existing annotations"
+              hint="Remove annotations already present before adding query results (off = keep them)"
+              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>
+
+    <!-- SAM3 Add-On Info Dialog -->
+    <v-dialog
+      v-if="textQueryEnabled"
+      v-model="sam3InfoDialogOpen"
+      max-width="500"
+    >
+      <v-card>
+        <v-card-title class="text-h6">
+          <v-icon left>
+            mdi-package-down
+          </v-icon>
+          SAM3 Add-On Required
+        </v-card-title>
+        <v-card-text>
+          <p class="text-body-2 mb-3">
+            Text query requires the SAM3 Text Query Segmentation and Tracking Models
+            add-on to be installed in your VIAME directory.
+          </p>
+          <p class="text-body-2 mb-0">
+            You can download the add-on from the
+            <span
+              class="sam3-wiki-link"
+              @click="openSam3AddonWiki"
+            >
+              VIAME Model Zoo and Add-Ons
+            </span>
+            page. Extract the package and merge its folders into your existing VIAME
+            installation.
+          </p>
+        </v-card-text>
+        <v-card-actions>
+          <v-spacer />
+          <v-btn
+            text
+            @click="closeSam3InfoDialog"
+          >
+            Close
+          </v-btn>
+          <v-btn
+            color="primary"
+            @click="openSam3AddonWiki"
+          >
+            Open Model Zoo
+          </v-btn>
+        </v-card-actions>
+      </v-card>
+    </v-dialog>
   </v-row>
 </template>
 
@@ -444,8 +757,18 @@ export default defineComponent({
   border-radius: 16px;
   white-space: nowrap;
   border: 1px solid;
-  cursor: default;
 }
+
+.edit-btn-unavailable {
+  opacity: 0.45 !important;
+}
+
+.sam3-wiki-link {
+  color: var(--v-primary-base);
+  cursor: pointer;
+  text-decoration: underline;
+}
+
 .mode-button{
   border: 1px solid grey;
   min-width: 36px;
diff --git a/client/dive-common/components/UserGuideDialog.vue b/client/dive-common/components/UserGuideDialog.vue
index 606cc2939..ba6480db5 100644
--- a/client/dive-common/components/UserGuideDialog.vue
+++ b/client/dive-common/components/UserGuideDialog.vue
@@ -1,8 +1,16 @@
 <script lang="ts">
 import { defineComponent } from 'vue';
+import isDesktopRuntime from 'dive-common/isDesktopRuntime';
 
 export default defineComponent({
   setup() {
+    const desktopShortcuts = isDesktopRuntime() ? [{
+      name: 'Text Query',
+      icon: 'mdi-keyboard',
+      actions: ['Q Key'],
+      description: 'Open the SAM3 text query dialog to find objects by description in the current frame',
+    }] : [];
+
     return {
       categories: [
         {
@@ -104,6 +112,7 @@ export default defineComponent({
             {
               name: 'Add Head/Tail', icon: 'mdi-keyboard', actions: ['H Key - Head', 'T Key - Tail'], description: 'While a track is selected add head/tail annotations',
             },
+            ...desktopShortcuts,
           ],
         },
       ],
diff --git a/client/dive-common/components/Viewer.vue b/client/dive-common/components/Viewer.vue
index ea2580422..5f8784660 100644
--- a/client/dive-common/components/Viewer.vue
+++ b/client/dive-common/components/Viewer.vue
@@ -127,6 +127,14 @@ export default defineComponent({
       type: Array as PropType<string[]>,
       default: () => [],
     },
+    textQueryEnabled: {
+      type: Boolean,
+      default: false,
+    },
+    textQueryAvailable: {
+      type: Boolean,
+      default: false,
+    },
   },
   setup(props, { emit }) {
     const { prompt, visible } = usePrompt();
@@ -170,6 +178,30 @@ 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);
+      }
+    }
+
+    /**
+     * Forward a single-frame text query submission to the platform handler,
+     * injecting the current frame number the query should run against.
+     */
+    function onTextQuerySubmit(
+      payload: { text: string; boxThreshold: number; replaceExisting?: boolean },
+    ) {
+      emit('text-query-submit', {
+        ...payload,
+        frameNum: aggregateController.value.frame.value,
+      });
+    }
 
     const sideBarCollapsed = ref(false);
     // Sidebar mode: 'left', 'bottom', or 'collapsed'
@@ -1233,6 +1265,9 @@ export default defineComponent({
       controlsHeight,
       controlsCollapsed,
       sideBarCollapsed,
+      editorMenuRef,
+      onTextQueryServiceReady,
+      onTextQuerySubmit,
       sidebarMode,
       cycleSidebarMode,
       sidebarModeIcon,
@@ -1417,6 +1452,7 @@ export default defineComponent({
         </v-tooltip>
 
         <EditorMenu
+          ref="editorMenuRef"
           v-bind="{
             editingMode,
             visibleModes,
@@ -1427,11 +1463,17 @@ export default defineComponent({
             groupEditActive: editingGroupId !== null,
             lassoModeActive: !readonlyState && lassoModeActive,
             lassoDrawing: !readonlyState && lassoDrawing,
+            textQueryEnabled,
+            textQueryAvailable,
           }"
           :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="onTextQuerySubmit"
+          @text-query-all-frames="$emit('text-query-all-frames', $event)"
+          @open-external-link="$emit('open-external-link', $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..c8b01ab7b 100644
--- a/client/platform/desktop/backend/ipcService.ts
+++ b/client/platform/desktop/backend/ipcService.ts
@@ -44,6 +44,18 @@ import {
 // defaults to linux if win32 doesn't exist
 const currentPlatform = OS.platform() === 'win32' ? win32 : linux;
 let samWarningShown = false;
+
+const SAM3_PIPELINE_CONFIGS = [
+  'interactive_segmenter_sam3.conf',
+  'interactive_sam3_segmenter.conf',
+];
+
+function isSam3Installed(viamePath: string): boolean {
+  const pipelinesDir = path.join(viamePath, 'configs', 'pipelines');
+  return SAM3_PIPELINE_CONFIGS.some((configName) => fs.existsSync(
+    path.join(pipelinesDir, configName),
+  ));
+}
 if (OS.platform() === 'win32') {
   win32.initialize();
 }
@@ -306,7 +318,7 @@ export default function register() {
     const currentSettings = settings.get();
     const pipelinesDir = path.join(currentSettings.viamePath, 'configs', 'pipelines');
     const hasSam2 = fs.existsSync(path.join(pipelinesDir, 'interactive_segmenter_sam2.conf'));
-    const hasSam3 = fs.existsSync(path.join(pipelinesDir, 'interactive_segmenter_sam3.conf'));
+    const hasSam3 = isSam3Installed(currentSettings.viamePath);
     const noSamInstalled = !hasSam2 && !hasSam3;
 
     // Show a one-time warning if neither SAM pack is installed,
@@ -321,6 +333,16 @@ export default function register() {
     return { success: true, noSamInstalled: showWarning };
   });
 
+  // Start the interactive service process WITHOUT warming the point-
+  // segmentation model. Used by the text-query dialog: text query loads its
+  // own (often different/heavier) model lazily and must not force a
+  // segmentation-model load.
+  ipcMain.handle('segmentation-ensure-started', async () => {
+    const segService = getInteractiveServiceManager();
+    await segService.ensureStarted(settings.get());
+    return { success: true };
+  });
+
   ipcMain.handle('segmentation-predict', async (_, args: SegmentationPredictRequest) => {
     const segService = getInteractiveServiceManager();
 
@@ -375,6 +397,55 @@ export default function register() {
     return { ready: segService.isSegmentationReady() };
   });
 
+  ipcMain.handle('segmentation-sam3-installed', () => {
+    const currentSettings = settings.get();
+    return { installed: isSam3Installed(currentSettings.viamePath) };
+  });
+
+  ipcMain.handle('segmentation-text-query', async (_, args: {
+    imagePath: string;
+    frameTime?: number;
+    text: string;
+    boxThreshold?: number;
+    maxDetections?: number;
+    boxes?: [number, number, number, number][];
+    points?: [number, number][];
+    pointLabels?: number[];
+  }) => {
+    const segService = getInteractiveServiceManager();
+
+    // Text query only needs the service process running -- not the (possibly
+    // different) point-segmentation model warmed. Start it without warming;
+    // the text-query model loads lazily inside the text_query request.
+    await segService.ensureStarted(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 ab1a8ac74..5ea1ac74e 100644
--- a/client/platform/desktop/backend/native/interactive.ts
+++ b/client/platform/desktop/backend/native/interactive.ts
@@ -453,6 +453,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 4f1fb1c71..942f2d7d9 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 {
@@ -308,6 +309,12 @@ async function segmentationInitialize(): Promise<{ success: boolean; noSamInstal
   return window.diveDesktop.invoke('segmentation-initialize');
 }
 
+// Start the interactive service process without warming the point-segmentation
+// model (used by text query, which loads its own model lazily).
+async function segmentationEnsureStarted(): Promise<{ success: boolean }> {
+  return window.diveDesktop.invoke('segmentation-ensure-started');
+}
+
 async function segmentationPredict(request: SegmentationPredictRequest): Promise<SegmentationPredictResponse> {
   return window.diveDesktop.invoke('segmentation-predict', request);
 }
@@ -334,6 +341,60 @@ async function segmentationIsReady(): Promise<SegmentationStatusResponse> {
   return window.diveDesktop.invoke('segmentation-is-ready');
 }
 
+async function segmentationSam3Installed(): Promise<{ installed: boolean }> {
+  return window.diveDesktop.invoke('segmentation-sam3-installed');
+}
+
+/**
+ * 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,
+  replaceExisting = false,
+): Promise<void> {
+  const pipeline: Pipe = {
+    name: 'Text Query',
+    pipe: 'utility_text_query_default.pipe',
+    type: 'utility',
+  };
+
+  // Config keys must address the refiner's sam3 sub-block
+  // (process track_refiner -> :refiner:type sam3 -> block refiner:sam3), and
+  // must go under kwiverParams -- that is the only place runPipeline() threads
+  // into "-s key=value" flags on the viame runner command.
+  const kwiverParams: Record<string, string> = {
+    'track_refiner:refiner:sam3:text_query': queryText,
+    'track_refiner:refiner:sam3:replace_existing': replaceExisting ? 'true' : 'false',
+  };
+
+  if (threshold !== undefined) {
+    kwiverParams['track_refiner:refiner:sam3:detection_threshold'] = threshold.toString();
+  }
+
+  const args: RunPipeline = {
+    type: JobType.RunPipeline,
+    pipeline,
+    datasetId,
+    pipelineParams: { kwiverParams },
+  };
+  gpuJobQueue.enqueue(args);
+}
+
 /**
  * Interactive Stereo API
  */
@@ -650,12 +711,18 @@ export {
   deleteCalibration,
   /* Segmentation APIs */
   segmentationInitialize,
+  segmentationEnsureStarted,
   segmentationPredict,
   segmentationStereoSegment,
   segmentationSetImage,
   segmentationClearImage,
   segmentationShutdown,
   segmentationIsReady,
+  segmentationSam3Installed,
+  /* 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 541947c1d..0131561c3 100644
--- a/client/platform/desktop/frontend/components/ViewerLoader.vue
+++ b/client/platform/desktop/frontend/components/ViewerLoader.vue
@@ -24,10 +24,14 @@ import {
 import type { RectBounds } from 'vue-media-annotator/utils';
 import {
   segmentationPredict, segmentationStereoSegment, segmentationInitialize, segmentationIsReady,
-  loadMetadata,
+  segmentationEnsureStarted,
+  segmentationSam3Installed,
+  loadMetadata, textQuery,
+  runTextQueryPipeline,
   stereoEnable, stereoDisable, stereoSetFrame, stereoTransferLine, stereoTransferPoints,
   stereoMeasureLine, stereoAggregateLengths,
   onStereoDisparityReady, onStereoDisparityError,
+  openLink,
 } from 'platform/desktop/frontend/api';
 import Export from './Export.vue';
 import JobTab from './JobTab.vue';
@@ -130,6 +134,20 @@ export default defineComponent({
     });
     const readOnlyMode = computed(() => settings.value?.readonlyMode || false);
     const timeFilter: Ref<[number, number] | null> = ref(null);
+    const textQueryAvailable = ref(false);
+
+    async function refreshTextQueryAvailability() {
+      try {
+        const result = await segmentationSam3Installed();
+        textQueryAvailable.value = result.installed;
+      } catch {
+        textQueryAvailable.value = false;
+      }
+    }
+
+    watch(() => settings.value?.viamePath, () => {
+      refreshTextQueryAvailability();
+    });
 
     watch(
       () => viewerRef.value?.trackFilters?.timeFilters?.value,
@@ -254,6 +272,10 @@ export default defineComponent({
             : undefined;
         }
 
+        // Share the resolvers with text query (handles video + multicam).
+        segmentationGetImagePath = getImagePath;
+        segmentationGetFrameTime = getFrameTime;
+
         // Initialize the recipe
         // Desktop uses imagePath from the request, so we ignore the frameNum parameter
         viewerRef.value.segmentationRecipe.initialize({
@@ -286,7 +308,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[];
@@ -294,11 +316,277 @@ export default defineComponent({
       originalVideoFile?: string;
     } | null = null;
 
+    // Frame -> media-path / frame-time resolvers built by initializeSegmentation.
+    // Shared with text query so it resolves video and multicam media the same way
+    // segmentation does (selected-camera aware, video frame-time aware).
+    let segmentationGetImagePath: ((frameNum: number) => string) | null = null;
+    let segmentationGetFrameTime: ((frameNum: number) => number | undefined) | undefined;
+
+    /**
+     * 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
+     */
+    // Loading state for the single-frame (interactive) text query. The
+    // all-frames path runs as a pipeline job with its own progress UI, so it
+    // does not use this.
+    const textQueryRunning = ref(false);
+
+    async function handleTextQuerySubmit(params: {
+      text: string;
+      boxThreshold: number;
+      frameNum: number;
+      replaceExisting?: boolean;
+    }) {
+      const {
+        text, boxThreshold, frameNum, replaceExisting = false,
+      } = 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;
+        }
+      }
+
+      // Prefer the segmentation resolvers (selected-camera + video aware); fall
+      // back to the single-cam image-sequence getter if segmentation never
+      // initialized.
+      const imagePath = segmentationGetImagePath?.(frameNum) || getImagePathForFrame(frameNum);
+      const frameTime = segmentationGetFrameTime?.(frameNum);
+      if (!imagePath) {
+        await prompt({
+          title: 'Text Query Error',
+          text: ['Could not determine image path for current frame.'],
+        });
+        return;
+      }
+
+      textQueryRunning.value = true;
+      try {
+        const response = await textQuery({
+          imagePath,
+          frameTime,
+          text,
+          boxThreshold,
+          maxDetections: 10,
+        });
+        // Query finished; drop the loading bar before any result/error prompts.
+        textQueryRunning.value = false;
+
+        if (!response.success) {
+          throw new Error(response.error || 'Text query failed');
+        }
+
+        const detections = response.detections || [];
+
+        // Resolve the target camera/track store up front so that "replace"
+        // can clear the current frame even when the query returns nothing.
+        const cameraStore = viewerRef.value?.cameraStore;
+        const selectedCamera = viewerRef.value?.selectedCamera || 'singleCam';
+        const trackStore = cameraStore?.camMap.value.get(selectedCamera)?.trackStore;
+
+        // When replacing, remove annotations already present on this frame
+        // before adding the query results. Tracks that exist only on this
+        // frame are removed entirely; tracks spanning other frames lose just
+        // this frame's feature (and are removed if that empties them). Other
+        // frames' annotations are left untouched.
+        if (replaceExisting && cameraStore && trackStore) {
+          const removeIds: number[] = [];
+          trackStore.annotationMap.forEach((track) => {
+            if (frameNum < track.begin || frameNum > track.end) {
+              return;
+            }
+            if (track.begin === frameNum && track.end === frameNum) {
+              removeIds.push(track.id);
+            } else {
+              track.deleteFeature(frameNum);
+              if (track.featureIndex.length === 0) {
+                removeIds.push(track.id);
+              }
+            }
+          });
+          removeIds.forEach((id) => cameraStore.remove(id, selectedCamera));
+        }
+
+        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 (cameraStore && trackStore) {
+          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
+            );
+
+            // add() seeds the confidence pair at 1.0; apply the detection's
+            // actual confidence from the text-query model so it isn't shown
+            // as 100%. (setType clamps >=1 to 1.0, which is the correct
+            // behavior for a genuinely-1.0 score.)
+            if (typeof det.score === 'number') {
+              newTrack.setType(det.label, det.score);
+            }
+
+            // 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) {
+        textQueryRunning.value = false;
+        await prompt({
+          title: 'Text Query Error',
+          text: [`Failed to execute text query: ${error}`],
+        });
+      } finally {
+        textQueryRunning.value = false;
+        // 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();
+      refreshTextQueryAvailability();
     });
 
+    /**
+     * 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;
+        }
+
+        // Start the service process only -- do NOT warm the point-segmentation
+        // model. The text-query model loads lazily on the first query.
+        await segmentationEnsureStarted();
+        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;
+      replaceExisting?: boolean;
+    }) {
+      const { text, boxThreshold, replaceExisting = false } = params;
+
+      try {
+        await runTextQueryPipeline(props.id, text, boxThreshold, replaceExisting);
+        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
      */
@@ -1382,9 +1670,15 @@ export default defineComponent({
       runningPipelines,
       largeImageWarning,
       timeFilter,
+      handleTextQuerySubmit,
+      handleTextQueryInit,
+      handleTextQueryAllFrames,
+      textQueryAvailable,
+      openLink,
       /* Stereo */
       stereoLoadingDialog,
       stereoLoadingMessage,
+      textQueryRunning,
       stereoLoadingError,
       stereoLengthSnackbar,
       stereoLengthMessage,
@@ -1406,8 +1700,14 @@ export default defineComponent({
       :id.sync="id"
       ref="viewerRef"
       :read-only-mode="readOnlyMode || runningPipelines.length > 0"
+      :text-query-enabled="true"
+      :text-query-available="textQueryAvailable"
       @change-camera="changeCamera"
       @large-image-warning="largeImageWarning()"
+      @text-query-submit="handleTextQuerySubmit"
+      @text-query-init="handleTextQueryInit"
+      @text-query-all-frames="handleTextQueryAllFrames"
+      @open-external-link="openLink"
       @stereo-annotation-complete="handleStereoAnnotationComplete"
       @stereo-annotation-reset="handleStereoAnnotationReset"
       @stereo-segmentation-finalize="handleStereoSegmentationFinalize"
@@ -1478,6 +1778,26 @@ export default defineComponent({
         </SidebarContext>
       </template>
     </Viewer>
+    <v-dialog
+      :value="textQueryRunning"
+      persistent
+      max-width="420"
+    >
+      <v-card>
+        <v-card-title class="text-h6">
+          Text Query
+        </v-card-title>
+        <v-card-text>
+          <div class="mb-2">
+            Searching the current frame&hellip;
+          </div>
+          <v-progress-linear
+            indeterminate
+            color="primary"
+          />
+        </v-card-text>
+      </v-card>
+    </v-dialog>
     <v-dialog
       :value="stereoLoadingDialog"
       persistent