diff --git a/client/dive-common/apispec.ts b/client/dive-common/apispec.ts
index 1b5dc03a4..2bfc07c5a 100644
--- a/client/dive-common/apispec.ts
+++ b/client/dive-common/apispec.ts
@@ -768,6 +768,96 @@ export interface RefineDetectionsResponse {
   detections?: TextQueryDetection[];
 }
 
+/**
+ * Video Search / IQR (rapid model generation) Types
+ */
+
+export type VideoSearchIndexMethod = 'detections' | 'tracking' | 'existing' | 'frames';
+
+/**
+ * One indexed media stream (video/sequence identifier) in the shared search
+ * database. All database rows key on this identifier, so a dataset can be
+ * added, updated, or removed from the index independently.
+ */
+export interface VideoSearchStreamEntry {
+  datasetId: string;
+  method: VideoSearchIndexMethod;
+  // frame rate the media was indexed at (video only; must match dataset fps)
+  fps?: number;
+  createdAt: string;
+}
+
+/** How a search index stores descriptors: per-stream files or an embedded PostgreSQL database. */
+export type SearchIndexBackend = 'files' | 'postgres';
+
+/** Sidecar metadata describing the shared search index. */
+export interface VideoSearchIndexMeta {
+  version: number;
+  /** Storage backend the index was built with; absent on indexes from before it was recorded (postgres). */
+  backend?: SearchIndexBackend;
+  // stream identifier (as reported in query results) -> source dataset
+  streams: Record<string, VideoSearchStreamEntry>;
+}
+
+export interface VideoSearchIndexStatus {
+  /** The shared index exists and is queryable (ITQ files present). */
+  built: boolean;
+  /** This dataset has been ingested into the index. */
+  indexed: boolean;
+  /** The stream entry for this dataset, when indexed. */
+  stream?: VideoSearchStreamEntry & { streamName: string };
+  /** Total datasets in the shared index. */
+  datasetCount: number;
+  meta?: VideoSearchIndexMeta;
+}
+
+export interface VideoSearchTrackState {
+  frame: number;
+  bbox?: [number, number, number, number];
+}
+
+export interface VideoSearchResultTrack {
+  id: number;
+  states: VideoSearchTrackState[];
+}
+
+/** One ranked similarity result returned by the query service. */
+export interface VideoSearchResult {
+  /** Unique reference for adjudication: "<session>:<instance_id>" */
+  ref: string;
+  /** Federated session index this result came from */
+  session: number;
+  /** Index directory this result came from */
+  index_dir: string;
+  instance_id: number;
+  query_id: string;
+  stream_id: string;
+  relevancy_score: number;
+  start_frame: number | null;
+  end_frame: number | null;
+  tracks: VideoSearchResultTrack[];
+}
+
+/** One dataset present in the shared search index. */
+export interface VideoSearchIndexInfo {
+  /** Stream identifier query results report for this dataset */
+  streamName: string;
+  datasetId: string;
+  /** Dataset display name */
+  name: string;
+  /** How the entry was built. */
+  method: VideoSearchIndexMethod;
+}
+
+export interface VideoSearchQueryResponse {
+  success: boolean;
+  error?: string;
+  descriptor_count?: number;
+  model_available?: boolean;
+  results?: VideoSearchResult[];
+  feedback_requests?: VideoSearchResult[];
+}
+
 export {
   provideApi,
   useApi,
diff --git a/client/dive-common/components/DatasetPicker.vue b/client/dive-common/components/DatasetPicker.vue
index 1750a4afe..a48c9b065 100644
--- a/client/dive-common/components/DatasetPicker.vue
+++ b/client/dive-common/components/DatasetPicker.vue
@@ -182,7 +182,7 @@ export default defineComponent({
       </v-btn>
       <v-btn
         small
-        color="success"
+        color="grey lighten-1"
         outlined
         :disabled="addable.length === 0"
         class="ml-2"
@@ -193,7 +193,7 @@ export default defineComponent({
           small
           left
         >
-          mdi-check-all
+          mdi-select-all
         </v-icon>
         Select all{{ addable.length ? ` (${addable.length})` : '' }}
       </v-btn>
diff --git a/client/dive-common/components/Review/ReviewCell.vue b/client/dive-common/components/Review/ReviewCell.vue
index 17b0e2ac7..567f909c7 100644
--- a/client/dive-common/components/Review/ReviewCell.vue
+++ b/client/dive-common/components/Review/ReviewCell.vue
@@ -141,6 +141,11 @@ export default defineComponent({
       type: String,
       default: '#00e5ff',
     },
+    /** Outline the cell as accepted or rejected (e.g. search adjudication). */
+    highlight: {
+      type: String as PropType<'' | 'positive' | 'negative'>,
+      default: '',
+    },
   },
   setup(props, { emit }) {
     /** Chips currently in edit mode, to outline the whole entry. */
@@ -244,7 +249,12 @@ export default defineComponent({
 <template>
   <div
     class="review-cell"
-    :class="{ 'cell-pending': pending, 'cell-editing': editingCount > 0 }"
+    :class="{
+      'cell-pending': pending,
+      'cell-editing': editingCount > 0,
+      'cell-positive': highlight === 'positive',
+      'cell-negative': highlight === 'negative',
+    }"
     :style="{ '--cell-scale': scale }"
   >
     <div class="cell-views">
@@ -286,9 +296,12 @@ export default defineComponent({
       >
         <template
           v-if="$scopedSlots.actions"
-          #actions
+          #actions="scope"
         >
-          <slot name="actions" />
+          <slot
+            name="actions"
+            v-bind="scope"
+          />
         </template>
       </ReviewChip>
     </div>
@@ -331,6 +344,14 @@ export default defineComponent({
   &.cell-editing {
     border-color: #90caf9;
   }
+
+  &.cell-positive {
+    border-color: #4caf50;
+  }
+
+  &.cell-negative {
+    border-color: #f44336;
+  }
 }
 
 .cell-views {
diff --git a/client/dive-common/components/Review/ReviewChip.vue b/client/dive-common/components/Review/ReviewChip.vue
index 2c58a8462..3c42603c5 100644
--- a/client/dive-common/components/Review/ReviewChip.vue
+++ b/client/dive-common/components/Review/ReviewChip.vue
@@ -8,7 +8,8 @@ import type { ReviewFrameRef, ReviewPolygon } from 'dive-common/review/types';
 
 /** Geometry of one frame while it is being edited, in image coordinates. */
 interface GeometryDraft {
-  bounds: RectBounds;
+  /** Null for entries without a box (whole-frame results). */
+  bounds: RectBounds | null;
   polygons: ReviewPolygon[];
   head: [number, number] | null;
   tail: [number, number] | null;
@@ -26,7 +27,7 @@ export interface ReviewChipGeometryEdit {
   /** Sequence slot edited (0 is the primary frame). */
   slot: number;
   frame: number;
-  bounds: RectBounds;
+  bounds: RectBounds | null;
   polygons: ReviewPolygon[];
   head: [number, number] | null;
   tail: [number, number] | null;
@@ -339,7 +340,7 @@ export default defineComponent({
 
     const boxRect = computed(() => {
       const g = shownGeometry.value;
-      if (!g) return null;
+      if (!g || !g.bounds) return null;
       const [x1, y1, x2, y2] = g.bounds;
       const a = chip([Math.min(x1, x2), Math.min(y1, y2)]);
       const b = chip([Math.max(x1, x2), Math.max(y1, y2)]);
@@ -399,7 +400,7 @@ export default defineComponent({
 
     function cloneDraft(g: GeometryDraft): GeometryDraft {
       return {
-        bounds: [...g.bounds] as RectBounds,
+        bounds: g.bounds ? [...g.bounds] as RectBounds : null,
         polygons: g.polygons.map((polygon) => polygon.map((p) => [p[0], p[1]] as [number, number])),
         head: g.head ? [g.head[0], g.head[1]] : null,
         tail: g.tail ? [g.tail[0], g.tail[1]] : null,
@@ -409,7 +410,7 @@ export default defineComponent({
     /** Turn the interpolated position into a real box the user can then adjust. */
     function addBox() {
       const frame = currentFrame.value;
-      if (!props.editable || !frame || !frame.missing) return;
+      if (!props.editable || !frame || !frame.missing || !frame.bounds) return;
       emit('add-box', { frame: frame.frame, bounds: frame.bounds });
     }
 
@@ -605,7 +606,7 @@ export default defineComponent({
       const dy = current[1] - drag.startImage[1];
       const { target, startDraft } = drag;
       if (target.kind === 'box') {
-        draft.value.bounds = moveBox(target.handle, startDraft.bounds, dx, dy);
+        if (startDraft.bounds) draft.value.bounds = moveBox(target.handle, startDraft.bounds, dx, dy);
       } else if (target.kind === 'vertex') {
         const origin = startDraft.polygons[target.polygon]?.[target.vertex];
         if (origin) {
@@ -967,7 +968,11 @@ export default defineComponent({
       class="cell-actions"
       @click.stop
     >
-      <slot name="actions">
+      <slot
+        name="actions"
+        :begin-edit="beginEdit"
+        :frame="currentFrame ? currentFrame.frame : undefined"
+      >
         <v-tooltip
           bottom
           open-delay="600"
diff --git a/client/dive-common/components/Review/ReviewPage.vue b/client/dive-common/components/Review/ReviewPage.vue
index 254ca905a..ae456a9db 100644
--- a/client/dive-common/components/Review/ReviewPage.vue
+++ b/client/dive-common/components/Review/ReviewPage.vue
@@ -188,7 +188,7 @@ export default defineComponent({
       const item = entry.items[viewIndex];
       if (!item) return;
       review.updateGeometry(item, edit.frame, {
-        bounds: edit.bounds,
+        bounds: edit.bounds ?? undefined,
         polygons: edit.polygons,
         head: edit.head,
         tail: edit.tail,
diff --git a/client/dive-common/review/chipRenderer.spec.ts b/client/dive-common/review/chipRenderer.spec.ts
index 1903cf9f2..b7a77cada 100644
--- a/client/dive-common/review/chipRenderer.spec.ts
+++ b/client/dive-common/review/chipRenderer.spec.ts
@@ -1,5 +1,5 @@
 import {
-  chipRegion, chipScale, chipSizeFor, toChipPoint, toImagePoint,
+  chipRegion, chipScale, chipSizeFor, frameRegion, toChipPoint, toImagePoint,
 } from './chipRenderer';
 
 describe('chipRegion', () => {
@@ -39,6 +39,20 @@ describe('chipSizeFor', () => {
   });
 });
 
+describe('frameRegion', () => {
+  it('covers the whole frame, padding the shorter direction to the aspect', () => {
+    expect(frameRegion(100, 50, 2)).toEqual({
+      x: 0, y: 0, width: 100, height: 50,
+    });
+    expect(frameRegion(100, 50, 1)).toEqual({
+      x: 0, y: -25, width: 100, height: 100,
+    });
+    expect(frameRegion(100, 50, 4)).toEqual({
+      x: -50, y: 0, width: 200, height: 50,
+    });
+  });
+});
+
 describe('chipScale', () => {
   it('fills the requested size, upscaling small crops and downscaling large ones', () => {
     expect(chipScale({
diff --git a/client/dive-common/review/chipRenderer.ts b/client/dive-common/review/chipRenderer.ts
index 33ed44207..a842e82bc 100644
--- a/client/dive-common/review/chipRenderer.ts
+++ b/client/dive-common/review/chipRenderer.ts
@@ -79,6 +79,18 @@ export function chipSizeFor(cellPixels: number): number {
   return CHIP_SIZE_BUCKETS.find((size) => size >= wanted) ?? CHIP_SIZE_BUCKETS[CHIP_SIZE_BUCKETS.length - 1];
 }
 
+/** Crop region covering a whole frame at the requested aspect ratio, centred. */
+export function frameRegion(width: number, height: number, aspect = 1): ChipRegion {
+  const ratio = aspect > 0 && Number.isFinite(aspect) ? aspect : 1;
+  const w = Math.max(1, width);
+  const h = Math.max(1, height);
+  const regionWidth = w / h >= ratio ? w : h * ratio;
+  const regionHeight = w / h >= ratio ? w / ratio : h;
+  return {
+    x: (w - regionWidth) / 2, y: (h - regionHeight) / 2, width: regionWidth, height: regionHeight,
+  };
+}
+
 /**
  * Scale from frame pixels to chip pixels: the crop's longer side fills the
  * requested size. Small crops are upscaled so the chip is rendered once at
@@ -90,8 +102,15 @@ export function chipScale(region: ChipRegion, size: number): number {
   return Math.max(16, size) / longest;
 }
 
-export function renderChip(frame: DecodedFrame, bounds: RectBounds, options: ChipRenderOptions): RenderedChip {
-  const region = chipRegion(bounds, options.padding, options.aspect);
+/** Render a box crop, or the whole frame when no box is given. */
+export function renderChip(
+  frame: DecodedFrame,
+  bounds: RectBounds | null,
+  options: ChipRenderOptions,
+): RenderedChip {
+  const region = bounds
+    ? chipRegion(bounds, options.padding, options.aspect)
+    : frameRegion(frame.width, frame.height, options.aspect);
   const scale = chipScale(region, options.size);
   const canvas = document.createElement('canvas');
   canvas.width = Math.max(1, Math.round(region.width * scale));
@@ -122,7 +141,7 @@ export function renderChip(frame: DecodedFrame, bounds: RectBounds, options: Chi
       sh * scale,
     );
   }
-  if (options.outline) {
+  if (options.outline && bounds) {
     const [x1, y1, x2, y2] = bounds;
     ctx.strokeStyle = options.outline;
     ctx.lineWidth = Math.max(1, Math.round(Math.max(canvas.width, canvas.height) / 160));
diff --git a/client/dive-common/review/chipStore.ts b/client/dive-common/review/chipStore.ts
index 73ee327d3..be19fbba4 100644
--- a/client/dive-common/review/chipStore.ts
+++ b/client/dive-common/review/chipStore.ts
@@ -23,7 +23,7 @@ export interface ChipStoreOptions {
 
 export interface ChipStoreDeps {
   /** Frame access for a dataset; null when the dataset cannot be cropped. */
-  frameSourceFor(datasetId: string): FrameSource | null;
+  frameSourceFor(datasetId: string): FrameSource | null | Promise<FrameSource | null>;
   concurrency?: number;
   /** Retain recent rendered items when paging; visible items are always kept. */
   cacheSize?: number;
@@ -80,7 +80,7 @@ export function createChipStore(deps: ChipStoreDeps, initial: ChipStoreOptions)
   }
 
   async function render(job: ChipJob): Promise<RenderedChip> {
-    const source = deps.frameSourceFor(job.item.datasetId);
+    const source = await deps.frameSourceFor(job.item.datasetId);
     if (!source) throw new Error('Media for this dataset cannot be cropped');
     const frameRef = job.slot === null ? job.item.primary : job.item.frames[job.slot];
     const frame = await source.getFrame(frameRef.frame);
diff --git a/client/dive-common/review/frameSource.ts b/client/dive-common/review/frameSource.ts
index 60cb28014..aec31a2df 100644
--- a/client/dive-common/review/frameSource.ts
+++ b/client/dive-common/review/frameSource.ts
@@ -290,3 +290,45 @@ export function createFrameSource(config: DatasetConfig, options: FrameSourceOpt
     return entry.url;
   }, imageData.length, cacheSize, cacheBytes);
 }
+
+/**
+ * Lazily creates one frame source per dataset from its config, for chip
+ * stores whose items can name any dataset (e.g. cross-dataset search
+ * results). A dataset whose config cannot be loaded or whose media cannot
+ * be cropped resolves to null.
+ */
+export function createFrameSourceRegistry(
+  loadConfig: (datasetId: string) => Promise<DatasetConfig>,
+  options: FrameSourceOptions = {},
+) {
+  const sources = new Map<string, Promise<FrameSource | null>>();
+
+  function frameSourceFor(datasetId: string): Promise<FrameSource | null> {
+    if (!datasetId) return Promise.resolve(null);
+    let pending = sources.get(datasetId);
+    if (!pending) {
+      pending = loadConfig(datasetId)
+        .then((config) => {
+          try {
+            return createFrameSource(config, options);
+          } catch {
+            return null;
+          }
+        })
+        .catch(() => null);
+      sources.set(datasetId, pending);
+    }
+    return pending;
+  }
+
+  function dispose() {
+    sources.forEach((pending) => {
+      pending.then((source) => source?.dispose()).catch(() => undefined);
+    });
+    sources.clear();
+  }
+
+  return { frameSourceFor, dispose };
+}
+
+export type FrameSourceRegistry = ReturnType<typeof createFrameSourceRegistry>;
diff --git a/client/dive-common/review/reviewItems.spec.ts b/client/dive-common/review/reviewItems.spec.ts
index ae6d0d952..559234227 100644
--- a/client/dive-common/review/reviewItems.spec.ts
+++ b/client/dive-common/review/reviewItems.spec.ts
@@ -11,6 +11,7 @@ import {
   matchTypePair,
   sampleFrames,
   sortReviewItems,
+  tracksOverlapping,
 } from './reviewItems';
 import { DEFAULT_REVIEW_QUERY } from './types';
 
@@ -275,3 +276,17 @@ it('groups detection matches from different frames into the same camera track',
   expect(entries).toHaveLength(1);
   expect(entries[0].items).toHaveLength(2);
 });
+
+describe('tracksOverlapping', () => {
+  const box = (id: number, frame: number, bounds: [number, number, number, number]): TrackData => ({
+    id, begin: frame, end: frame, confidencePairs: [['fish', 1]], attributes: {}, features: [{ frame, keyframe: true, bounds }],
+  });
+
+  it('matches only tracks whose box on the same frame overlaps enough', () => {
+    const probe = box(99, 3, [0, 0, 10, 10]);
+    const hits = tracksOverlapping([
+      box(1, 3, [1, 1, 11, 11]), box(2, 4, [0, 0, 10, 10]), box(3, 3, [9, 9, 20, 20]), box(99, 3, [0, 0, 10, 10]),
+    ], probe, 0.5);
+    expect(hits.map((t) => t.id)).toEqual([1]);
+  });
+});
diff --git a/client/dive-common/review/reviewItems.ts b/client/dive-common/review/reviewItems.ts
index 0a99f4bad..6d4ec805e 100644
--- a/client/dive-common/review/reviewItems.ts
+++ b/client/dive-common/review/reviewItems.ts
@@ -261,6 +261,51 @@ export interface CameraMembership {
  * its nearest keyframes with boxes (held at the ends), or null when the
  * track has no boxes there at all.
  */
+/** Intersection over union of two boxes, 0 when either is empty. */
+export function boxIou(a: RectBounds, b: RectBounds): number {
+  const width = Math.min(a[2], b[2]) - Math.max(a[0], b[0]);
+  const height = Math.min(a[3], b[3]) - Math.max(a[1], b[1]);
+  if (width <= 0 || height <= 0) return 0;
+  const intersection = width * height;
+  const union = (a[2] - a[0]) * (a[3] - a[1]) + (b[2] - b[0]) * (b[3] - b[1]) - intersection;
+  return union > 0 ? intersection / union : 0;
+}
+
+/** The track whose keyframe box on `frame` best overlaps `bounds`, at or above `minIou`. */
+export function findTrackAt(
+  tracks: Iterable<TrackData>,
+  frame: number,
+  bounds: RectBounds,
+  minIou: number,
+): TrackData | undefined {
+  let best: { track: TrackData; iou: number } | undefined;
+  Array.from(tracks).forEach((track) => {
+    if (frame < track.begin || frame > track.end) return;
+    const feature = track.features.find((f) => f.frame === frame && f.bounds);
+    if (!feature?.bounds) return;
+    const iou = boxIou(feature.bounds, bounds);
+    if (iou >= minIou && (!best || iou > best.iou)) best = { track, iou };
+  });
+  return best?.track;
+}
+
+/** Tracks among `candidates` with a keyframe box overlapping one of `track`'s by at least `minIou`. */
+export function tracksOverlapping(
+  candidates: Iterable<TrackData>,
+  track: TrackData,
+  minIou: number,
+): TrackData[] {
+  const boxes = new Map<number, RectBounds>();
+  track.features.forEach((f) => { if (f.bounds) boxes.set(f.frame, f.bounds); });
+  return Array.from(candidates).filter((candidate) => (
+    candidate.id !== track.id
+    && candidate.features.some((f) => {
+      const box = boxes.get(f.frame);
+      return !!box && !!f.bounds && boxIou(f.bounds, box) >= minIou;
+    })
+  ));
+}
+
 export function interpolateBounds(track: TrackData, frame: number): RectBounds | null {
   const features = boxedFeatures(track);
   if (features.length === 0) return null;
diff --git a/client/dive-common/review/searchResultItems.spec.ts b/client/dive-common/review/searchResultItems.spec.ts
new file mode 100644
index 000000000..994f291e4
--- /dev/null
+++ b/client/dive-common/review/searchResultItems.spec.ts
@@ -0,0 +1,73 @@
+import type { VideoSearchResult } from 'dive-common/apispec';
+import {
+  sampleSearchStates, searchResultFrame, searchResultItem, searchResultTrack,
+} from './searchResultItems';
+
+function result(states: { frame: number; bbox?: [number, number, number, number] }[], extra: Partial<VideoSearchResult> = {}): VideoSearchResult {
+  return {
+    ref: '0:7',
+    session: 0,
+    index_dir: '',
+    instance_id: 7,
+    query_id: 'q',
+    stream_id: 's',
+    relevancy_score: 0.42,
+    start_frame: states[0]?.frame ?? null,
+    end_frame: states[states.length - 1]?.frame ?? null,
+    tracks: states.length ? [{ id: 3, states }] : [],
+    ...extra,
+  };
+}
+
+describe('searchResultItem', () => {
+  it('maps a track result to an item keyed by ref with sampled frames', () => {
+    const states = Array.from({ length: 20 }, (_, i) => ({ frame: i * 2, bbox: [i, 0, i + 5, 5] as [number, number, number, number] }));
+    const item = searchResultItem(result(states), 'ds', 4);
+    expect(item).toMatchObject({
+      key: '0:7', datasetId: 'ds', trackId: 3, confidence: 0.42, keyframeCount: 20, type: '',
+    });
+    expect(item?.frames.map((f) => f.frame)).toEqual([0, 12, 26, 38]);
+    expect(item?.primary).toEqual({ frame: 0, bounds: [0, 0, 5, 5] });
+  });
+
+  it('shows the whole frame when a state has no box', () => {
+    const item = searchResultItem(result([{ frame: 9 }]), 'ds', 8);
+    expect(item?.frames).toEqual([{ frame: 9, bounds: null }]);
+  });
+
+  it('falls back to start_frame for results without tracks, and drops frameless ones', () => {
+    expect(searchResultItem(result([], { start_frame: 4 }), 'ds', 8)).toMatchObject({
+      trackId: 7, primary: { frame: 4, bounds: null },
+    });
+    expect(searchResultItem(result([], { start_frame: null }), 'ds', 8)).toBeNull();
+    expect(searchResultFrame(result([], { start_frame: null }))).toBeNull();
+  });
+
+  it('never repeats a frame when sampling', () => {
+    expect(sampleSearchStates(result([{ frame: 1 }, { frame: 1 }, { frame: 1 }]), 8)).toHaveLength(1);
+  });
+});
+
+describe('searchResultTrack', () => {
+  it('builds one rounded keyframe per boxed state under the given type', () => {
+    const data = searchResultTrack(result([
+      { frame: 3, bbox: [10.4, 20.6, 5.2, 30.1] },
+      { frame: 3, bbox: [0, 0, 1, 1] },
+      { frame: 1, bbox: [1, 1, 2, 2] },
+      { frame: 5 },
+    ]), 'fish');
+    expect(data).toMatchObject({ begin: 1, end: 3, confidencePairs: [['fish', 1]] });
+    expect(data?.features).toEqual([
+      {
+        frame: 1, keyframe: true, interpolate: false, bounds: [1, 1, 2, 2],
+      },
+      {
+        frame: 3, keyframe: true, interpolate: false, bounds: [5, 21, 10, 30],
+      },
+    ]);
+  });
+
+  it('is null for a result without boxes', () => {
+    expect(searchResultTrack(result([{ frame: 2 }]), 'fish')).toBeNull();
+  });
+});
diff --git a/client/dive-common/review/searchResultItems.ts b/client/dive-common/review/searchResultItems.ts
new file mode 100644
index 000000000..4dbdd85d4
--- /dev/null
+++ b/client/dive-common/review/searchResultItems.ts
@@ -0,0 +1,92 @@
+/**
+ * Video search results as review grid items, so ranked similarity results
+ * can be adjudicated in the same chip grid that reviews annotations.
+ */
+import type { VideoSearchResult, VideoSearchTrackState } from 'dive-common/apispec';
+import type { Feature, TrackData } from 'vue-media-annotator/track';
+import type { ReviewFrameRef, ReviewItem } from './types';
+
+export function searchResultFrame(result: VideoSearchResult): number | null {
+  return result.tracks[0]?.states[0]?.frame ?? result.start_frame ?? null;
+}
+
+function stateRef(state: VideoSearchTrackState): ReviewFrameRef {
+  return { frame: state.frame, bounds: state.bbox ?? null };
+}
+
+/** Up to `max` states evenly sampled along the result's first track. */
+export function sampleSearchStates(result: VideoSearchResult, max: number): ReviewFrameRef[] {
+  const states = result.tracks[0]?.states ?? [];
+  if (states.length === 0) return [];
+  const count = Math.max(1, Math.min(max, states.length));
+  const chosen: ReviewFrameRef[] = [];
+  const seen = new Set<number>();
+  for (let i = 0; i < count; i += 1) {
+    const index = count === 1 ? 0 : Math.round((i * (states.length - 1)) / (count - 1));
+    const state = states[index];
+    if (!seen.has(state.frame)) {
+      seen.add(state.frame);
+      chosen.push(stateRef(state));
+    }
+  }
+  return chosen;
+}
+
+/**
+ * A grid item for one result; null when the result names no frame at all.
+ * `datasetId` is the dataset the result's stream maps to ('' when unknown,
+ * which renders as an un-croppable chip rather than dropping the result).
+ */
+export function searchResultItem(
+  result: VideoSearchResult,
+  datasetId: string,
+  maxSequenceFrames: number,
+): ReviewItem | null {
+  const frames = sampleSearchStates(result, maxSequenceFrames);
+  const frame = searchResultFrame(result);
+  if (frames.length === 0) {
+    if (frame === null) return null;
+    frames.push({ frame, bounds: null });
+  }
+  return {
+    key: result.ref,
+    datasetId,
+    trackId: result.tracks[0]?.id ?? result.instance_id,
+    primary: frames[0],
+    frames,
+    keyframeCount: result.tracks[0]?.states.length ?? 1,
+    type: '',
+    confidence: result.relevancy_score,
+  };
+}
+
+/**
+ * A new annotation track for a result, one keyframe per boxed state, so
+ * the result can join its dataset's annotations with the given type. Null
+ * when the result carries no box at all.
+ */
+export function searchResultTrack(result: VideoSearchResult, type: string): Omit<TrackData, 'id'> | null {
+  const byFrame = new Map<number, Feature>();
+  (result.tracks[0]?.states ?? []).forEach((state) => {
+    if (!state.bbox || byFrame.has(state.frame)) return;
+    const [x1, y1, x2, y2] = state.bbox;
+    byFrame.set(state.frame, {
+      frame: state.frame,
+      keyframe: true,
+      interpolate: false,
+      bounds: [
+        Math.round(Math.min(x1, x2)), Math.round(Math.min(y1, y2)),
+        Math.round(Math.max(x1, x2)), Math.round(Math.max(y1, y2)),
+      ],
+    });
+  });
+  const features = Array.from(byFrame.values()).sort((a, b) => a.frame - b.frame);
+  if (features.length === 0) return null;
+  return {
+    begin: features[0].frame,
+    end: features[features.length - 1].frame,
+    confidencePairs: [[type, 1]],
+    attributes: {},
+    features,
+  };
+}
diff --git a/client/dive-common/review/types.ts b/client/dive-common/review/types.ts
index 1f5a4442e..890c1fbd2 100644
--- a/client/dive-common/review/types.ts
+++ b/client/dive-common/review/types.ts
@@ -40,7 +40,8 @@ export interface ReviewFrameGeometry {
 /** One box of a track shown in a chip, in the dataset's own frame numbers. */
 export interface ReviewFrameRef extends ReviewFrameGeometry {
   frame: number;
-  bounds: RectBounds;
+  /** The box to crop around; null shows the whole frame. */
+  bounds: RectBounds | null;
   /**
    * The track has no detection on this frame in this camera; `bounds` is
    * interpolated from its neighbours so the chip can still be cropped there,
diff --git a/client/dive-common/review/useReviewGrid.ts b/client/dive-common/review/useReviewGrid.ts
index a69105af0..fb238cd36 100644
--- a/client/dive-common/review/useReviewGrid.ts
+++ b/client/dive-common/review/useReviewGrid.ts
@@ -40,6 +40,11 @@ export interface ReviewGridOptions<T> {
   footerPx?: number | Ref<number>;
   /** Box outline burned into the chips; empty draws none (the cell overlays it). */
   outline?: string;
+  /**
+   * Keep the current page (clamped) when the items change instead of
+   * returning to the first one, for lists that shrink as entries are hidden.
+   */
+  retainPage?: boolean;
 }
 
 /** How long paging must be idle before chips load, so skipped pages never render. */
@@ -96,7 +101,7 @@ export function useReviewGrid<T = ReviewItem>(options: ReviewGridOptions<T>) {
   watch(page, onPageChanged);
   watch(active, ensureVisible);
   watch(items, () => {
-    page.value = 0;
+    page.value = options.retainPage ? Math.min(page.value, pageCount.value - 1) : 0;
     ensureVisible();
   });
   watch(perPage, () => {
diff --git a/client/dive-common/use/useReview.spec.ts b/client/dive-common/use/useReview.spec.ts
index 24a21809a..1aac8afcb 100644
--- a/client/dive-common/use/useReview.spec.ts
+++ b/client/dive-common/use/useReview.spec.ts
@@ -234,7 +234,7 @@ describe('createReviewService', () => {
     const right = entry.items[1];
     expect(right.frames.map((f) => f.missing ?? false)).toEqual([true, false]);
 
-    service.addKeyframe(right, 0, right.frames[0].bounds);
+    service.addKeyframe(right, 0, right.frames[0].bounds!);
     expect(service.trackOf('m/right', 3)?.features.map((f) => f.frame)).toEqual([0, 4]);
     expect(service.trackOf('m/right', 3)?.begin).toBe(0);
     expect(service.entries.value[0].items[1].frames.every((f) => !f.missing)).toBe(true);
@@ -472,3 +472,56 @@ it('preserves dirty data instead of replacing it on resume', async () => {
   expect(service.trackOf('a', 1)?.confidencePairs).toEqual([['shark', 1]]);
   service.dispose();
 });
+
+describe('adopting outside tracks', () => {
+  it('finds the overlapping track on a frame, inserts new ones under free ids, and builds items for them', async () => {
+    const service = createReviewService({ api: makeApi({ a: [track(4, [['fish', 0.9]], [0, 1])] }) });
+    expect(await service.ensureLoaded('a')).toBe(true);
+    expect(service.findTrackAt('a', 1, [1, 1, 9, 9])?.id).toBe(4);
+    expect(service.findTrackAt('a', 1, [50, 50, 60, 60])).toBeUndefined();
+    expect(service.findTrackAt('a', 2, [0, 0, 10, 10])).toBeUndefined();
+
+    const inserted = service.insertTrack('a', {
+      begin: 7, end: 7, confidencePairs: [['crab', 1]], attributes: {}, features: [{ frame: 7, keyframe: true, bounds: [2, 2, 8, 8] }],
+    });
+    expect(inserted?.id).toBe(5);
+    expect(service.pendingCount.value).toBe(1);
+    expect(service.itemFor('a', 5, 'result:1')).toMatchObject({
+      key: 'result:1', datasetId: 'a', trackId: 5, type: 'crab', primary: { frame: 7, bounds: [2, 2, 8, 8] },
+    });
+    expect(service.itemFor('a', 99)).toBeNull();
+    service.dispose();
+  });
+
+  it('waits for a load already in flight', async () => {
+    const service = createReviewService({ api: makeApi({ a: [track(1, [['fish', 0.9]], [0])] }) });
+    const adding = service.addDataset('a');
+    expect(await service.ensureLoaded('a')).toBe(true);
+    await adding;
+    expect(service.trackOf('a', 1)).toBeDefined();
+    service.dispose();
+  });
+});
+
+describe('discarding and deleting tracks by id', () => {
+  it('forgets an unsaved insert without deleting anything, and deletes by id', async () => {
+    const api = makeApi({ a: [track(1, [['fish', 0.9]], [0])] });
+    const service = createReviewService({ api });
+    await service.addDataset('a');
+    const inserted = service.insertTrack('a', {
+      begin: 2, end: 2, confidencePairs: [['crab', 1]], attributes: {}, features: [{ frame: 2, keyframe: true, bounds: [0, 0, 5, 5] }],
+    })!;
+    expect(service.tracksOf('a').map((t) => t.id)).toEqual([1, inserted.id]);
+    service.discardTrack('a', inserted.id);
+    expect(service.tracksOf('a').map((t) => t.id)).toEqual([1]);
+    expect(service.pendingCount.value).toBe(0);
+
+    service.deleteTrackById('a', 1);
+    expect(service.tracksOf('a')).toEqual([]);
+    await service.save();
+    expect(api.saveDetections).toHaveBeenCalledWith('a', expect.objectContaining({
+      tracks: { upsert: [], delete: [1] },
+    }));
+    service.dispose();
+  });
+});
diff --git a/client/dive-common/use/useReview.ts b/client/dive-common/use/useReview.ts
index a592bf6e7..a6734adc2 100644
--- a/client/dive-common/use/useReview.ts
+++ b/client/dive-common/use/useReview.ts
@@ -21,8 +21,8 @@ import { createFrameSource, FrameSource } from 'dive-common/review/frameSource';
 import createReviewRequestQueue from 'dive-common/review/requestQueue';
 import { createChipStore, ChipStore } from 'dive-common/review/chipStore';
 import {
-  buildReviewItems, CameraMembership, collectAttributeKeys, collectTypes, frameRefFor, groupReviewItems,
-  sortReviewItems,
+  buildReviewItems, CameraMembership, collectAttributeKeys, collectTypes, findTrackAt as findTrackIn,
+  frameRefFor, groupReviewItems, sortReviewItems,
 } from 'dive-common/review/reviewItems';
 import { usePersistentGridSettings } from 'dive-common/review/gridSettings';
 import {
@@ -105,6 +105,20 @@ export interface ReviewService {
   datasetFps(id: string): number;
   /** The multicamera parent a camera dataset was expanded from, or the id itself. */
   parentOf(id: string): string;
+  /** Load a dataset that is not loaded yet; true once its tracks are in memory. */
+  ensureLoaded(id: string): Promise<boolean>;
+  /** The loaded track whose keyframe box on `frame` overlaps `bounds` by at least `minIou`. */
+  findTrackAt(datasetId: string, frame: number, bounds: RectBounds, minIou?: number): TrackData | undefined;
+  /** Add a track to a loaded dataset under a free id; written on the next save. */
+  insertTrack(datasetId: string, track: Omit<TrackData, 'id'>): TrackData | undefined;
+  /** A grid item for one loaded track, under `key` when given. */
+  itemFor(datasetId: string, trackId: AnnotationId, key?: string): ReviewItem | null;
+  /** Every track of a loaded dataset as currently edited. */
+  tracksOf(datasetId: string): TrackData[];
+  /** Forget an inserted track that was never saved; nothing is written for it. */
+  discardTrack(datasetId: string, trackId: AnnotationId): void;
+  /** Remove a track by id; deleted on the next save. */
+  deleteTrackById(datasetId: string, trackId: AnnotationId): void;
   /** Add a keyframe with a box to a track, e.g. where one camera lacks a detection. */
   addKeyframe(item: ReviewItem, frame: number, bounds: RectBounds): void;
   /** Remove the track behind an item; written on the next save. */
@@ -240,6 +254,7 @@ function createScopedReviewService(deps: ReviewServiceDeps): ReviewService {
   const loaded = new Map<string, LoadedDataset>();
   /** Loads still in flight, so a removal during load is honoured. */
   const loadTokens = new Map<string, symbol>();
+  const loadPromises = new Map<string, Promise<void>>();
   /** Type colours as the annotator assigns them, seeded from each dataset's custom styles. */
   const styles = new StyleManager({ markChangesPending: () => undefined });
   /** Camera datasets expanded from a multicamera parent. */
@@ -333,7 +348,15 @@ function createScopedReviewService(deps: ReviewServiceDeps): ReviewService {
     }
   }
 
-  async function load(id: string) {
+  function load(id: string) {
+    const promise = runLoad(id).finally(() => {
+      if (loadPromises.get(id) === promise) loadPromises.delete(id);
+    });
+    loadPromises.set(id, promise);
+    return promise;
+  }
+
+  async function runLoad(id: string) {
     const token = Symbol(id);
     loadTokens.set(id, token);
     const isCurrent = () => loadTokens.get(id) === token && !!entry(id);
@@ -530,6 +553,47 @@ function createScopedReviewService(deps: ReviewServiceDeps): ReviewService {
     return loaded.get(datasetId)?.tracks.get(trackId);
   }
 
+  async function ensureLoaded(id: string) {
+    const current = entry(id);
+    if (!current) {
+      await addDataset(id);
+    } else if (current.status === 'queued') {
+      patch(id, { status: 'loading' });
+      await load(id);
+    } else {
+      await loadPromises.get(id);
+    }
+    return entry(id)?.status === 'ready';
+  }
+
+  function findTrackAt(datasetId: string, frame: number, bounds: RectBounds, minIou = 0.5) {
+    const dataset = loaded.get(datasetId);
+    return dataset ? findTrackIn(dataset.tracks.values(), frame, bounds, minIou) : undefined;
+  }
+
+  function insertTrack(datasetId: string, track: Omit<TrackData, 'id'>) {
+    const dataset = loaded.get(datasetId);
+    if (!dataset) return undefined;
+    let id = 0;
+    dataset.tracks.forEach((existing) => { id = Math.max(id, existing.id + 1); });
+    dataset.deleted.forEach((deleted) => { id = Math.max(id, deleted + 1); });
+    const inserted: TrackData = { ...track, id };
+    dataset.tracks.set(id, inserted);
+    markPending(dataset, id);
+    dataRevision.value += 1;
+    return inserted;
+  }
+
+  function itemFor(datasetId: string, trackId: AnnotationId, key?: string) {
+    const track = trackOf(datasetId, trackId);
+    if (!track) return null;
+    const [item] = buildReviewItems(datasetId, [track], {
+      ...DEFAULT_REVIEW_QUERY, mode: 'type', type: '', threshold: 0,
+    }, grid.maxSequenceFrames);
+    if (!item) return null;
+    return key ? { ...item, key } : item;
+  }
+
   function parentOf(id: string) {
     return memberships.get(id)?.parent ?? id;
   }
@@ -614,20 +678,36 @@ function createScopedReviewService(deps: ReviewServiceDeps): ReviewService {
     updatePairs(item, (pairs, hierarchy) => acceptPairAsCorrect(hierarchy, pairs, current.type));
   }
 
-  function deleteTrack(item: ReviewItem) {
-    const dataset = loaded.get(item.datasetId);
-    if (!dataset || !dataset.tracks.has(item.trackId)) return;
-    dataset.tracks.delete(item.trackId);
-    dataset.pending.delete(item.trackId);
-    dataset.pendingVersions.delete(item.trackId);
-    dataset.deleted.add(item.trackId);
+  function tracksOf(datasetId: string) {
+    return Array.from(loaded.get(datasetId)?.tracks.values() ?? []);
+  }
+
+  function forgetTrack(datasetId: string, trackId: AnnotationId, markDeleted: boolean) {
+    const dataset = loaded.get(datasetId);
+    if (!dataset || !dataset.tracks.has(trackId)) return;
+    dataset.tracks.delete(trackId);
+    dataset.pending.delete(trackId);
+    dataset.pendingVersions.delete(trackId);
+    if (markDeleted) dataset.deleted.add(trackId);
     // The entry leaves the grid at once; everything else stays put.
     items.value = items.value.filter(
-      (other) => !(other.datasetId === item.datasetId && other.trackId === item.trackId),
+      (other) => !(other.datasetId === datasetId && other.trackId === trackId),
     );
     dataRevision.value += 1;
   }
 
+  function discardTrack(datasetId: string, trackId: AnnotationId) {
+    forgetTrack(datasetId, trackId, false);
+  }
+
+  function deleteTrackById(datasetId: string, trackId: AnnotationId) {
+    forgetTrack(datasetId, trackId, true);
+  }
+
+  function deleteTrack(item: ReviewItem) {
+    deleteTrackById(item.datasetId, item.trackId);
+  }
+
   function addKeyframe(item: ReviewItem, frame: number, bounds: RectBounds) {
     const dataset = loaded.get(item.datasetId);
     const track = dataset?.tracks.get(item.trackId);
@@ -796,6 +876,13 @@ function createScopedReviewService(deps: ReviewServiceDeps): ReviewService {
     colorFor,
     datasetFps,
     parentOf,
+    ensureLoaded,
+    findTrackAt,
+    insertTrack,
+    itemFor,
+    tracksOf,
+    discardTrack,
+    deleteTrackById,
     addKeyframe,
     deleteTrack,
     isPending,
diff --git a/client/dive-common/vue-utilities/prompt-service/index.spec.ts b/client/dive-common/vue-utilities/prompt-service/index.spec.ts
new file mode 100644
index 000000000..736fc70ab
--- /dev/null
+++ b/client/dive-common/vue-utilities/prompt-service/index.spec.ts
@@ -0,0 +1,39 @@
+import Vue from 'vue';
+import Vuetify from 'vuetify';
+import installPrompt, { usePrompt } from './index';
+
+let state: { show: boolean; title: string; text: string; functions: { resolve: (value: boolean) => void } };
+vi.mock('./Prompt.vue', () => ({
+  default: {
+    data() {
+      state = {
+        show: false, title: '', text: '', functions: { resolve: () => {} },
+      };
+      return state;
+    },
+  },
+}));
+
+it('queues failure dialogs behind an open prompt without dropping or replacing them', async () => {
+  installPrompt(new Vuetify())(Vue);
+  const { prompt } = usePrompt();
+  const first = prompt({ title: 'Existing prompt', text: 'First' });
+  const failure = prompt({ title: 'Indexing failed', text: 'No CUDA GPUs are available' });
+  const another = prompt({ title: 'Another indexing failure', text: 'Missing input' });
+  await Promise.resolve();
+  expect(state.title).toBe('Existing prompt');
+  state.show = false;
+  state.functions.resolve(true);
+  await first;
+  await Promise.resolve();
+  expect(state.title).toBe('Indexing failed');
+  expect(state.text).toBe('No CUDA GPUs are available');
+  state.show = false;
+  state.functions.resolve(true);
+  await failure;
+  await Promise.resolve();
+  expect(state.title).toBe('Another indexing failure');
+  state.show = false;
+  state.functions.resolve(true);
+  await another;
+});
diff --git a/client/dive-common/vue-utilities/prompt-service/index.ts b/client/dive-common/vue-utilities/prompt-service/index.ts
index 244529665..61fcb7f09 100644
--- a/client/dive-common/vue-utilities/prompt-service/index.ts
+++ b/client/dive-common/vue-utilities/prompt-service/index.ts
@@ -1,7 +1,7 @@
 /* disabled this rule for Vue.prototype.FOO = */
 /* eslint-disable no-param-reassign,func-names */
 
-import { VueConstructor, watch } from 'vue';
+import { VueConstructor } from 'vue';
 import Vuetify from 'vuetify/lib';
 import Prompt from './Prompt.vue';
 
@@ -14,6 +14,8 @@ interface PromptParams {
 }
 
 class PromptService {
+  private pending: Promise<unknown> = Promise.resolve();
+
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   private component: any;
 
@@ -47,16 +49,12 @@ class PromptService {
     negativeButton = 'Cancel',
     confirm = false,
   }: PromptParams): Promise<boolean> {
-    return new Promise<boolean>((resolve) => {
-      if (!this.component.show) {
-        this.set(title, text, positiveButton, negativeButton, confirm, resolve);
-      } else {
-        const unwatch = watch(this.component.show, () => {
-          unwatch();
-          this.set(title, text, positiveButton, negativeButton, confirm, resolve);
-        });
-      }
-    });
+    const next = this.pending.then(() => new Promise<boolean>((resolve) => {
+      this.set(title, text, positiveButton, negativeButton, confirm, resolve);
+    }));
+    // Job failures can arrive while another prompt is open. Show them in order.
+    this.pending = next.catch(() => undefined);
+    return next;
   }
 
   visible(): boolean {
diff --git a/client/platform/desktop/backend/ipcService.ts b/client/platform/desktop/backend/ipcService.ts
index b2716d862..84aa75e90 100644
--- a/client/platform/desktop/backend/ipcService.ts
+++ b/client/platform/desktop/backend/ipcService.ts
@@ -15,6 +15,7 @@ import {
   ConversionArgs,
   DesktopJob,
   RunScoring,
+  BuildSearchIndex,
 } from 'platform/desktop/constants';
 import { convertMedia } from 'platform/desktop/backend/native/mediaJobs';
 import { closeChildById } from 'platform/desktop/backend/native/processManager';
@@ -33,6 +34,7 @@ import { listen } from './server';
 import {
   getInteractiveServiceManager,
 } from './native/interactive';
+import * as videoSearch from './native/videoSearch';
 import {
   SegmentationPredictRequest,
   SegmentationStereoSegmentRequest,
@@ -232,6 +234,11 @@ export default function register() {
 
   ipcMain.handle('delete-dataset', async (event, { datasetId }: { datasetId: string }) => {
     const ret = await common.deleteDataset(settings.get(), datasetId);
+    // Also drop the dataset's rows from the shared search index (best
+    // effort; the index tolerates stale entries if this fails).
+    videoSearch.removeFromIndex(settings.get(), datasetId).catch((err) => {
+      console.error(`Failed to remove ${datasetId} from the search index:`, err);
+    });
     return ret;
   });
 
@@ -619,4 +626,95 @@ export default function register() {
     const stereoService = getInteractiveServiceManager();
     return { enabled: stereoService.isEnabled() };
   });
+
+  /**
+   * Video Search / IQR Service
+   */
+
+  ipcMain.handle('video-search-installed', async () => (
+    videoSearch.isVideoSearchInstalled(settings.get())
+  ));
+
+  ipcMain.handle('video-search-index-status', async (_, datasetId: string) => (
+    videoSearch.getIndexStatus(settings.get(), datasetId)
+  ));
+
+  ipcMain.handle('video-search-build-index', async (event, args: BuildSearchIndex) => {
+    const updater = (update: DesktopJobUpdate) => {
+      event.sender.send('job-update', update);
+    };
+    // The build job needs the shared database to itself (and re-ingesting
+    // invalidates whatever the open session has cached in memory).
+    const manager = videoSearch.getQueryServiceManager();
+    return videoSearch.buildIndex(settings.get(), args, updater, () => manager.closeIndex());
+  });
+
+  ipcMain.handle('video-search-remove-index', async (_, datasetId: string) => {
+    await videoSearch.removeFromIndex(settings.get(), datasetId);
+    return { success: true };
+  });
+
+  ipcMain.handle('video-search-delete-index', async () => {
+    await videoSearch.deleteEntireIndex(settings.get());
+    return { success: true };
+  });
+
+  ipcMain.handle('video-search-list-indexes', async () => (
+    videoSearch.listIndexedDatasets(settings.get())
+  ));
+
+  ipcMain.handle('video-search-open-index', async () => {
+    const currentSettings = settings.get();
+    const streams = await videoSearch.listIndexedDatasets(currentSettings);
+    if (!streams.length) {
+      throw new Error('The search index is empty; add a dataset to it first');
+    }
+    const manager = videoSearch.getQueryServiceManager();
+    const indexMeta = await videoSearch.readIndexMeta(currentSettings);
+    await manager.openIndexes(
+      currentSettings,
+      [videoSearch.getIndexDir(currentSettings)],
+      indexMeta.backend ?? 'postgres',
+    );
+    return { success: true, streams };
+  });
+
+  ipcMain.handle('video-search-formulate', async (_, args: { imagePath: string; boxes?: number[][] }) => {
+    const manager = videoSearch.getQueryServiceManager();
+    return manager.formulateQuery(args.imagePath, args.boxes);
+  });
+
+  ipcMain.handle('video-search-query', async (
+    _,
+    args: { threshold?: number; iqrModelB64?: string; iqrModelPath?: string },
+  ) => {
+    const manager = videoSearch.getQueryServiceManager();
+    let modelB64 = args.iqrModelB64;
+    if (!modelB64 && args.iqrModelPath) {
+      // Warm-start from a saved .svm file on disk
+      modelB64 = (await fs.promises.readFile(args.iqrModelPath)).toString('base64');
+    }
+    return manager.processQuery(args.threshold, modelB64);
+  });
+
+  ipcMain.handle('video-search-refine', async (_, args: { positiveIds: string[]; negativeIds: string[] }) => {
+    const manager = videoSearch.getQueryServiceManager();
+    return manager.refine(args.positiveIds, args.negativeIds);
+  });
+
+  ipcMain.handle('video-search-export-model', async (_, args: { name: string }) => {
+    const outputDir = await videoSearch.exportSearchModel(settings.get(), args.name);
+    return { success: true, outputDir };
+  });
+
+  ipcMain.handle('video-search-close', async () => {
+    const manager = videoSearch.getQueryServiceManager();
+    await manager.closeIndex();
+    return { success: true };
+  });
+
+  ipcMain.handle('video-search-extract-frame', async (
+    _,
+    args: { videoPath: string; frameNum: number; fps: number },
+  ) => videoSearch.extractVideoFrame(args.videoPath, args.frameNum, args.fps));
 }
diff --git a/client/platform/desktop/backend/native/videoSearch.spec.ts b/client/platform/desktop/backend/native/videoSearch.spec.ts
new file mode 100644
index 000000000..3bcfbc6c3
--- /dev/null
+++ b/client/platform/desktop/backend/native/videoSearch.spec.ts
@@ -0,0 +1,91 @@
+import { EventEmitter } from 'events';
+import { PassThrough } from 'stream';
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import { spawn } from 'child_process';
+import { DesktopJobUpdate, JobType, Settings } from 'platform/desktop/constants';
+import linux from './linux';
+import * as common from './common';
+import { createCustomWorkingDirectory } from './utils';
+import * as videoSearch from './videoSearch';
+
+vi.mock('./linux', () => ({ default: { validateViamePath: vi.fn(), getViameConstants: () => ({ setupScriptAbs: 'setup', shell: '/bin/bash' }), getViamePythonExe: () => 'python3' } }));
+vi.mock('./windows', () => ({ default: {} }));
+vi.mock('./common', () => ({ getValidatedProjectDir: vi.fn(), loadJsonConfig: vi.fn() }));
+vi.mock('./utils', () => ({
+  createCustomWorkingDirectory: vi.fn(), jobFileEchoMiddleware: (job: DesktopJobUpdate, update: (value: DesktopJobUpdate) => void) => (data: Buffer) => update({ ...job, body: [data.toString()] }), getBinaryPath: vi.fn(), spawnResult: vi.fn(),
+}));
+vi.mock('./processManager', () => ({ observeChild: (child: unknown) => child }));
+vi.mock('child_process', () => ({ spawn: vi.fn() }));
+let root: string;
+let settings: Settings;
+let updates: DesktopJobUpdate[];
+beforeEach(async () => {
+  root = await fs.mkdtemp(path.join(os.tmpdir(), 'dive-index-job-'));
+  settings = { viamePath: root, dataPath: root } as Settings;
+  updates = [];
+  vi.mocked(linux.validateViamePath).mockResolvedValue(true);
+  vi.mocked(common.getValidatedProjectDir).mockResolvedValue({ datasetFileAbsPath: 'meta' } as never);
+  vi.mocked(common.loadJsonConfig).mockResolvedValue({
+    type: 'video', originalBasePath: '/video', originalVideoFile: 'fish.mp4', fps: 30,
+  } as never);
+  vi.mocked(createCustomWorkingDirectory).mockResolvedValue(root);
+});
+afterEach(async () => { await fs.remove(root); vi.clearAllMocks(); });
+const args = { type: JobType.BuildSearchIndex as const, datasetId: 'fish', method: 'detections' as const };
+it('registers preparation immediately and keeps startup failures in history', async () => {
+  vi.mocked(linux.validateViamePath).mockResolvedValue('Missing VIAME installation');
+  const pending = videoSearch.buildIndex(settings, args, (update) => updates.push(update));
+  expect(updates[0]).toMatchObject({
+    jobType: 'indexing', pid: -1, datasetIds: ['fish'], exitCode: null,
+  });
+  const job = await pending;
+  expect(job.exitCode).toBe(1);
+  expect(job.endTime).toBeDefined();
+  expect(updates.at(-1)?.body).toEqual(['ERROR: Missing VIAME installation']);
+  expect(updates.at(-1)?.key).toBe(updates[0].key);
+});
+it('updates the same job with its process and finishes only after index metadata is saved', async () => {
+  const child = Object.assign(new EventEmitter(), {
+    pid: 123, exitCode: null, stdout: new PassThrough(), stderr: new PassThrough(),
+  });
+  vi.mocked(spawn).mockReturnValue(child as never);
+  const job = await videoSearch.buildIndex(settings, args, (update) => updates.push(update));
+  expect(updates.at(-1)).toMatchObject({ key: updates[0].key, pid: 123, workingDir: root });
+  child.stdout.write('Extracting descriptors');
+  child.stderr.write('Example diagnostic');
+  expect(updates.flatMap((update) => update.body || [])).toContain('Extracting descriptors');
+  expect(updates.flatMap((update) => update.body || [])).toContain('Example diagnostic');
+  child.emit('close', 0);
+  await vi.waitFor(() => expect(job.endTime).toBeDefined());
+  expect(updates.at(-1)?.exitCode).toBe(0);
+  expect(await fs.pathExists(path.join(root, 'DIVE_SearchIndex/index_meta.json'))).toBe(true);
+});
+
+it('indexes the first configured stereo camera and names it in the job log', async () => {
+  vi.mocked(common.loadJsonConfig).mockResolvedValueOnce({
+    multiCam: {
+      cameras: { right: {}, left: {} }, cameraOrder: ['left', 'right'], defaultDisplay: 'right',
+    },
+  } as never);
+  const child = Object.assign(new EventEmitter(), {
+    pid: 124, exitCode: null, stdout: new PassThrough(), stderr: new PassThrough(),
+  });
+  vi.mocked(spawn).mockReturnValue(child as never);
+  const job = await videoSearch.buildIndex(settings, args, (update) => updates.push(update));
+  expect(common.getValidatedProjectDir).toHaveBeenLastCalledWith(settings, 'fish/left');
+  expect(job.datasetIds).toEqual(['fish', 'fish/left']);
+  expect(updates.flatMap((update) => update.body || [])).toContain('Indexing first camera: left (fish/left)');
+  child.emit('close', 0);
+  await vi.waitFor(() => expect(job.endTime).toBeDefined());
+  const metadata = await fs.readJson(path.join(root, 'DIVE_SearchIndex/index_meta.json'));
+  expect(Object.values(metadata.streams)).toEqual([expect.objectContaining({ datasetId: 'fish/left' })]);
+});
+
+it('registers failures while closing the previous search session for the error pop-up', async () => {
+  const job = await videoSearch.buildIndex(settings, args, (update) => updates.push(update), async () => { throw new Error('Could not close index'); });
+  expect(job.exitCode).toBe(1);
+  expect(updates.at(-1)?.body).toEqual(['ERROR: Could not close index']);
+  expect(updates.at(-1)?.endTime).toBeDefined();
+});
diff --git a/client/platform/desktop/backend/native/videoSearch.ts b/client/platform/desktop/backend/native/videoSearch.ts
new file mode 100644
index 000000000..c47a51cf0
--- /dev/null
+++ b/client/platform/desktop/backend/native/videoSearch.ts
@@ -0,0 +1,924 @@
+/**
+ * Video Search / IQR backend for Desktop
+ *
+ * Manages ONE shared search index covering every indexed dataset, plus a
+ * persistent query service manager (viame.core.query_service) that holds the
+ * KWIVER query/IQR pipeline open so refinement iterations are interactive.
+ *
+ * Every indexed dataset is one stream (video/sequence identifier), so
+ * datasets are added to, updated in, and removed from the shared index
+ * independently; a query searches every indexed dataset in one IQR session.
+ *
+ * Two storage backends exist (SearchIndexBackend). The default keeps one
+ * set of files per stream and needs no server process; the PostgreSQL one
+ * is retained for deployments that prefer the embedded database.
+ *
+ * On-disk layout:
+ *   <dataPath>/DIVE_SearchIndex/
+ *     index_meta.json               - stream -> dataset membership and backend, written by DIVE
+ *     <stream>.txt                  - media list handed to viame index add
+ *     database/
+ *       ITQ/                        - the shared ITQ model (+ legacy global hash files)
+ *       <stream>.index              - files backend: manifest marking an indexed stream
+ *       <stream>_descriptors.csv    - files backend: descriptor uids, track refs, history
+ *       <stream>_descriptors.npy    - files backend: float32 descriptor matrix
+ *       <stream>_uids.txt           - files backend: uid per matrix row
+ *       <stream>_hashes.npy         - files backend: ITQ hash codes per row
+ *       <stream>_tracks.csv         - files backend: object tracks of the stream
+ *       SQL/                        - postgres backend: embedded database data
+ */
+
+import OS from 'os';
+import crypto from 'crypto';
+import { spawn, ChildProcess } from 'child_process';
+import npath from 'path';
+import readline from 'readline';
+import fs from 'fs-extra';
+import { EventEmitter } from 'events';
+
+import {
+  Settings, DesktopJob, DesktopJobUpdater,
+  SearchIndexMeta, BuildSearchIndex, JsonConfig,
+} from 'platform/desktop/constants';
+import { orderedMultiCamCameraNames } from 'dive-common/multicamDisplay';
+import type {
+  VideoSearchIndexStatus, VideoSearchIndexInfo, SearchIndexBackend,
+} from 'dive-common/apispec';
+import { serialize } from 'platform/desktop/backend/serializers/viame';
+import { observeChild } from './processManager';
+import * as common from './common';
+import {
+  jobFileEchoMiddleware, createCustomWorkingDirectory, getBinaryPath, spawnResult,
+} from './utils';
+import linux from './linux';
+import win32 from './windows';
+
+const GlobalIndexFolderName = 'DIVE_SearchIndex';
+
+/**
+ * The backend new indexes are built with. 'files' (per-stream bundles, no
+ * server) is the default; 'postgres' keeps the embedded database path
+ * alive for anyone who wants to switch back. An existing index keeps the
+ * backend it was created with (recorded in index_meta.json).
+ */
+export const DefaultSearchIndexBackend: SearchIndexBackend = 'files';
+
+/** Files that make up one stream of a file-backed index. */
+const StreamBundlePostfixes = [
+  '.index', '_descriptors.csv', '_descriptors.npy', '_uids.txt', '_hashes.npy', '_tracks.csv',
+];
+const IndexMetaFileName = 'index_meta.json';
+const QueryPipelineName = 'query_retrieval_and_iqr.pipe';
+const ExportTemplateName = npath.join('templates', 'detector_generic_svm.pipe');
+
+/** viame index --method for each build method. */
+const IndexMethods: Record<BuildSearchIndex['method'], string> = {
+  detections: 'detections',
+  tracking: 'tracking',
+  existing: 'existing',
+  frames: 'frames',
+};
+
+function getCurrentPlatform() {
+  return OS.platform() === 'win32' ? win32 : linux;
+}
+
+/**
+ * Video search requires the query pipeline and the index build tooling;
+ * the PostgreSQL backend additionally needs the bundled database binaries.
+ */
+async function isVideoSearchInstalled(
+  settings: Settings,
+  backend: SearchIndexBackend = DefaultSearchIndexBackend,
+): Promise<boolean> {
+  const configs = npath.join(settings.viamePath, 'configs');
+  const pipelines = npath.join(configs, 'pipelines');
+  const checks = [
+    fs.pathExists(npath.join(pipelines, QueryPipelineName)),
+    fs.pathExists(npath.join(configs, 'index.py')),
+  ];
+  if (backend === 'postgres') {
+    const initdb = OS.platform() === 'win32' ? 'initdb.exe' : 'initdb';
+    checks.push(
+      fs.pathExists(npath.join(pipelines, 'sql_init_table.sql')),
+      fs.pathExists(npath.join(settings.viamePath, 'bin', initdb)),
+    );
+  }
+  return (await Promise.all(checks)).every((c) => c);
+}
+
+/** Run `viame index <args>` inside the shared index folder and wait for it. */
+async function runIndexTool(settings: Settings, args: string[]): Promise<void> {
+  const platform = getCurrentPlatform();
+  const viameConstants = platform.getViameConstants(settings);
+  const pythonExe = platform.getViamePythonExe(settings);
+  const indexScript = npath.join(settings.viamePath, 'configs', 'index.py');
+  const quoted = args.map((a) => `"${a}"`).join(' ');
+  const command = [
+    viameConstants.setupScriptAbs,
+    `"${pythonExe}" "${indexScript}" ${quoted}`,
+  ].join(' && ');
+  const child = observeChild(spawn(command, { shell: viameConstants.shell, cwd: getIndexDir(settings) }));
+  let stderr = '';
+  child.stderr?.on('data', (chunk) => { stderr += chunk.toString('utf-8'); });
+  const exitCode = await new Promise<number | null>((resolve) => { child.on('exit', resolve); });
+  if (exitCode !== 0) {
+    throw new Error(`viame index ${args[0]} failed (exit ${exitCode}): ${stderr.trim().split('\n').slice(-3).join(' ')}`);
+  }
+}
+
+/** Delete one stream's bundle files (files backend). */
+async function removeStreamFiles(settings: Settings, streamName: string): Promise<void> {
+  const database = npath.join(getIndexDir(settings), 'database');
+  await Promise.all(StreamBundlePostfixes.map(async (postfix) => {
+    await fs.remove(npath.join(database, sanitizeName(streamName) + postfix)).catch(() => undefined);
+  }));
+}
+
+function getIndexDir(settings: Settings): string {
+  return npath.join(settings.dataPath, GlobalIndexFolderName);
+}
+
+/** Filesystem/SQL-safe stream identifier token. */
+function sanitizeName(name: string): string {
+  return name.replace(/[^a-zA-Z0-9_-]/g, '_');
+}
+
+export type SearchIndexStatus = VideoSearchIndexStatus;
+
+async function readIndexMeta(settings: Settings): Promise<SearchIndexMeta> {
+  const metaPath = npath.join(getIndexDir(settings), IndexMetaFileName);
+  if (!(await fs.pathExists(metaPath))) {
+    return { version: 1, streams: {} };
+  }
+  return (await fs.readJson(metaPath)) as SearchIndexMeta;
+}
+
+async function writeIndexMeta(settings: Settings, meta: SearchIndexMeta): Promise<void> {
+  await fs.writeJson(npath.join(getIndexDir(settings), IndexMetaFileName), meta, { spaces: 2 });
+}
+
+/** The stream identifier a dataset's rows key on in the shared database. */
+function streamNameForDataset(datasetId: string, meta: JsonConfig): string {
+  if (meta.type === 'video') {
+    // Videos are attributed by their filename stem (process_video derives
+    // the ingest stream name from the input file's basename)
+    return npath.parse(meta.originalVideoFile).name;
+  }
+  return sanitizeName(datasetId);
+}
+
+/** Whether the shared index is queryable (ITQ/LSH files present). */
+async function indexIsBuilt(settings: Settings): Promise<boolean> {
+  const itqDir = npath.join(getIndexDir(settings), 'database', 'ITQ');
+  return (await fs.pathExists(itqDir))
+    && (await fs.readdir(itqDir)).some((f) => f.startsWith('itq.model'));
+}
+
+async function getIndexStatus(settings: Settings, datasetId: string): Promise<SearchIndexStatus> {
+  const meta = await readIndexMeta(settings);
+  const built = await indexIsBuilt(settings);
+  const streamName = Object.keys(meta.streams)
+    .find((s) => meta.streams[s].datasetId === datasetId);
+  return {
+    built,
+    indexed: built && streamName !== undefined,
+    stream: streamName !== undefined
+      ? { ...meta.streams[streamName], streamName } : undefined,
+    datasetCount: built
+      ? new Set(Object.values(meta.streams).map((s) => s.datasetId)).size : 0,
+    meta,
+  };
+}
+
+/** Every dataset present in the shared search index. */
+async function listIndexedDatasets(settings: Settings): Promise<VideoSearchIndexInfo[]> {
+  const meta = await readIndexMeta(settings);
+  const entries = await Promise.all(
+    Object.entries(meta.streams).map(async ([streamName, stream]) => {
+      let name = stream.datasetId;
+      try {
+        const projectInfo = await common.getValidatedProjectDir(settings, stream.datasetId);
+        const dsMeta = await common.loadJsonConfig(projectInfo.datasetFileAbsPath);
+        name = dsMeta.name || stream.datasetId;
+      } catch {
+        // Dataset may have been deleted; keep the id as the display name.
+      }
+      return {
+        streamName, datasetId: stream.datasetId, name, method: stream.method,
+      };
+    }),
+  );
+  return entries;
+}
+
+/**
+ * Add (or update) one dataset in the shared search index as a DIVE job.
+ *
+ * The job chain: ensure the shared postgres is up (or initialize it on the
+ * first ever build), delete the dataset's previous rows when updating, run
+ * the ingest pipeline via process_video.py, and refresh the ITQ/LSH index
+ * over the full database. The caller must close any open query session
+ * first (the job needs the default postgres port).
+ */
+async function buildIndex(
+  settings: Settings,
+  args: BuildSearchIndex,
+  updater: DesktopJobUpdater,
+  beforeStart?: () => Promise<void>,
+): Promise<DesktopJob> {
+  const jobBase: DesktopJob = {
+    key: `search_index_${crypto.randomBytes(16).toString('hex')}`,
+    command: '',
+    workingDir: '',
+    jobType: 'indexing',
+    pid: -1,
+    args,
+    title: `Add search index (${args.method})`,
+    datasetIds: [args.datasetId],
+    exitCode: null,
+    startTime: new Date(),
+  };
+  updater({ ...jobBase, body: ['Preparing search index…'] });
+  try {
+    await beforeStart?.();
+    return await startIndexBuild(settings, args, updater, jobBase);
+  } catch (error) {
+    jobBase.exitCode = 1;
+    jobBase.endTime = new Date();
+    updater({ ...jobBase, body: [`ERROR: ${error instanceof Error ? error.message : String(error)}`] });
+    return jobBase;
+  }
+}
+
+async function startIndexBuild(settings: Settings, args: BuildSearchIndex, updater: DesktopJobUpdater, registeredJob: DesktopJob): Promise<DesktopJob> {
+  const jobBase = registeredJob;
+  const { method } = args;
+  let { datasetId } = args;
+  const platform = getCurrentPlatform();
+  const isValid = await platform.validateViamePath(settings);
+  if (isValid !== true) {
+    throw new Error(isValid);
+  }
+
+  let projectInfo = await common.getValidatedProjectDir(settings, datasetId);
+  let meta = await common.loadJsonConfig(projectInfo.datasetFileAbsPath);
+  if (meta.multiCam) {
+    const [camera] = orderedMultiCamCameraNames(meta.multiCam);
+    if (!camera) throw new Error('This multicamera dataset has no cameras to index');
+    datasetId = `${datasetId}/${camera}`;
+    jobBase.datasetIds = [args.datasetId, datasetId];
+    updater({ ...jobBase, body: [`Indexing first camera: ${camera} (${datasetId})`] });
+    projectInfo = await common.getValidatedProjectDir(settings, datasetId);
+    meta = await common.loadJsonConfig(projectInfo.datasetFileAbsPath);
+  }
+  updater({ ...jobBase, body: [`Index source: ${datasetId}`] });
+
+  const indexDir = getIndexDir(settings);
+  await fs.ensureDir(indexDir);
+
+  const indexMeta = await readIndexMeta(settings);
+  const streamName = streamNameForDataset(datasetId, meta);
+  const existing = indexMeta.streams[streamName];
+  if (existing && existing.datasetId !== datasetId) {
+    throw new Error(
+      `Stream identifier '${streamName}' already belongs to dataset `
+      + `'${existing.datasetId}'; rename the media file to index both.`,
+    );
+  }
+
+  // Image sequences are handed over as a list of frames named after the
+  // stream, so results attribute back to the dataset; a video is passed as
+  // the video itself (a list would be read as images and fail to decode).
+  const ingestList = npath.join(indexDir, `${sanitizeName(streamName)}.txt`);
+  let inputArg: string;
+  if (meta.type === 'video') {
+    const videoAbsPath = npath.join(meta.originalBasePath, meta.originalVideoFile);
+    inputArg = `-v "${videoAbsPath}"`;
+  } else {
+    const fileData = meta.originalImageFiles
+      .map((f: string) => npath.join(meta.originalBasePath, f))
+      .join('\n');
+    await fs.writeFile(ingestList, `${fileData}\n`);
+    inputArg = `-l "${ingestList}"`;
+  }
+
+  const viameConstants = platform.getViameConstants(settings);
+  const pythonExe = platform.getViamePythonExe(settings);
+  const configsDir = npath.join(settings.viamePath, 'configs');
+  // The backend is fixed when the shared index is first built; every later
+  // build joins the same store. Indexes from before the backend was
+  // recorded were always postgres.
+  const backend: SearchIndexBackend = indexMeta.backend
+    ?? (Object.keys(indexMeta.streams).length > 0 ? 'postgres' : DefaultSearchIndexBackend);
+
+  const command: string[] = [viameConstants.setupScriptAbs];
+  if (backend === 'files' && existing) {
+    // Rebuilding a stream: drop its previous bundle so stale files are not
+    // mistaken for current ones by the bundle builder.
+    await removeStreamFiles(settings, streamName);
+  }
+
+  // viame index add owns the rest: database initialisation and start for
+  // the postgres backend, the ingest pipeline, and the hash refresh.
+  const indexInvocation = [
+    `"${pythonExe}" "${npath.join(configsDir, 'index.py')}" add`,
+    inputArg,
+    `--method ${IndexMethods[method]}`,
+    '--database database',
+    `--backend ${backend}`,
+    '--yes',
+    `-install "${settings.viamePath}"`,
+  ];
+  if (meta.type === 'video') {
+    indexInvocation.push(`-frate ${meta.fps}`);
+  }
+  if (method === 'existing') {
+    const detectionsCsv = npath.join(indexDir, `${sanitizeName(streamName)}_detections.csv`);
+    const csvStream = fs.createWriteStream(detectionsCsv);
+    const inputData = await common.loadAnnotationFile(projectInfo.trackFileAbsPath);
+    await serialize(csvStream, inputData, meta);
+    csvStream.end();
+    indexInvocation.push(`-id "${detectionsCsv}"`);
+  }
+  command.push(indexInvocation.join(' '));
+
+  const fullCommand = command.join(' && ');
+  const jobWorkDir = await createCustomWorkingDirectory(settings, 'search_index', datasetId.replace('/', '_'));
+  const joblog = npath.join(jobWorkDir, 'runlog.txt');
+
+  const job = observeChild(spawn(fullCommand, {
+    shell: viameConstants.shell,
+    cwd: indexDir,
+  }));
+  if (job.pid === undefined) {
+    job.on('error', () => { /* The preparation failure is reported below. */ });
+    throw new Error('Failed to spawn the search index build');
+  }
+
+  Object.assign(jobBase, {
+    command: fullCommand,
+    pid: job.pid,
+    title: `${existing ? 'Update' : 'Add'} search index (${method})`,
+    workingDir: jobWorkDir,
+  });
+
+  fs.writeFile(npath.join(jobWorkDir, 'dive_job_manifest.json'), JSON.stringify(jobBase, null, 2))
+    .catch((error) => updater({ ...jobBase, body: [`Could not save job manifest: ${error}`] }));
+
+  updater({ ...jobBase, body: [`Command: ${fullCommand}`] });
+
+  job.stdout.on('data', jobFileEchoMiddleware(jobBase, updater, joblog));
+  job.stderr.on('data', jobFileEchoMiddleware(jobBase, updater, joblog));
+
+  job.on('error', (error) => {
+    jobBase.exitCode = 1;
+    jobBase.endTime = new Date();
+    updater({ ...jobBase, body: [`ERROR: ${error.message}`] });
+  });
+  job.on('close', async (code) => {
+    if (jobBase.endTime) return;
+    if (code === 0) {
+      try {
+        const latest = await readIndexMeta(settings);
+        latest.backend = backend;
+        latest.streams[streamName] = {
+          datasetId,
+          method,
+          fps: meta.type === 'video' ? meta.fps : undefined,
+          createdAt: (new Date()).toISOString(),
+        };
+        await writeIndexMeta(settings, latest);
+      } catch (err) {
+        jobBase.exitCode = 1;
+        updater({ ...jobBase, body: [`ERROR: Failed to write search index metadata: ${err}`] });
+      }
+    }
+    jobBase.exitCode = jobBase.exitCode ?? code;
+    jobBase.endTime = new Date();
+    updater({ ...jobBase, body: [''] });
+  });
+  return jobBase;
+}
+
+/**
+ * Extract a single video frame as a PNG for use as a query exemplar or a
+ * result thumbnail (the exemplar descriptor pipeline reads image files, not
+ * videos). Extracted frames are cached in tmp, keyed on the source video's
+ * identity (path + size + mtime, so a re-transcoded file invalidates) and
+ * the requested timestamp (frame + fps, since two datasets can reference
+ * the same video at different annotation framerates). Concurrent requests
+ * for the same frame share one extraction.
+ */
+const frameExtractions = new Map<string, Promise<string>>();
+const FrameCacheMaxFiles = 200;
+let framePruneRunning = false;
+
+/** Best-effort cap on cached frames: drop the oldest past the limit. */
+async function pruneFrameCache(outDir: string) {
+  if (framePruneRunning) return;
+  framePruneRunning = true;
+  try {
+    const entries = await fs.readdir(outDir);
+    if (entries.length <= FrameCacheMaxFiles) return;
+    const stats = await Promise.all(entries.map(async (name) => {
+      const filePath = npath.join(outDir, name);
+      const stat = await fs.stat(filePath).catch(() => null);
+      return { filePath, mtimeMs: stat?.mtimeMs ?? 0 };
+    }));
+    stats.sort((a, b) => a.mtimeMs - b.mtimeMs);
+    const excess = stats.slice(0, stats.length - FrameCacheMaxFiles);
+    await Promise.all(excess.map(({ filePath }) => fs.remove(filePath).catch(() => undefined)));
+  } finally {
+    framePruneRunning = false;
+  }
+}
+
+async function extractVideoFrame(videoPath: string, frameNum: number, fps: number): Promise<string> {
+  const outDir = npath.join(OS.tmpdir(), 'dive-video-search');
+  const stat = await fs.stat(videoPath);
+  const videoKey = crypto.createHash('md5')
+    .update(`${videoPath}|${stat.size}|${Math.round(stat.mtimeMs)}|${fps}`)
+    .digest('hex').slice(0, 16);
+  const outPath = npath.join(outDir, `frame_${videoKey}_${frameNum}.png`);
+  const inflight = frameExtractions.get(outPath);
+  if (inflight) {
+    return inflight;
+  }
+  const extraction = (async () => {
+    await fs.ensureDir(outDir);
+    if (await fs.pathExists(outPath)) {
+      return outPath;
+    }
+    // Extract to a temp name and rename so a failed/interrupted ffmpeg run
+    // can never leave a partial file where the cache check would find it.
+    const tmpPath = npath.join(outDir, `tmp_${process.pid}_${videoKey}_${frameNum}.png`);
+    const seconds = frameNum / (fps || 1);
+    const ffmpegPath = getBinaryPath('ffmpeg-ffprobe-static/ffmpeg');
+    const result = await spawnResult(ffmpegPath, [
+      '-y', '-ss', seconds.toString(), '-i', videoPath, '-frames:v', '1', tmpPath,
+    ]);
+    if (result.exitCode !== 0 || !(await fs.pathExists(tmpPath))) {
+      await fs.remove(tmpPath).catch(() => undefined);
+      throw new Error(`Unable to extract video frame ${frameNum}: ${result.error}`);
+    }
+    await fs.move(tmpPath, outPath, { overwrite: true });
+    pruneFrameCache(outDir).catch(() => undefined);
+    return outPath;
+  })();
+  frameExtractions.set(outPath, extraction);
+  try {
+    return await extraction;
+  } finally {
+    frameExtractions.delete(outPath);
+  }
+}
+
+/** Loose shape of a JSON response line from the Python query service. */
+interface ServiceResponse {
+  id: string;
+  success?: boolean;
+  error?: string;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  [key: string]: any;
+}
+
+interface PendingRequest {
+  resolve: (response: ServiceResponse) => void;
+  reject: (error: Error) => void;
+  timeout: NodeJS.Timeout;
+}
+
+/**
+ * Manages ONE persistent viame.core.query_service subprocess speaking
+ * newline-delimited JSON. Modeled on InteractiveServiceManager.
+ */
+export class QueryServiceManager extends EventEmitter {
+  private process: ChildProcess | null = null;
+
+  private readline: readline.Interface | null = null;
+
+  private pendingRequests: Map<string, PendingRequest> = new Map();
+
+  private isStarting = false;
+
+  private startPromise: Promise<void> | null = null;
+
+  private requestCounter = 0;
+
+  /** Index directories currently opened in the service (primary first). */
+  private currentIndexDirs: string[] = [];
+
+  // First open loads the descriptor index + pipeline; queries train SVMs.
+  private readonly requestTimeoutMs = 300000;
+
+  isReady(): boolean {
+    return this.process !== null && this.process.exitCode === null;
+  }
+
+  openIndexDirs(): string[] {
+    return this.isReady() ? this.currentIndexDirs : [];
+  }
+
+  private generateRequestId(): string {
+    this.requestCounter += 1;
+    return `req_${Date.now()}_${this.requestCounter}`;
+  }
+
+  async ensureStarted(settings: Settings): Promise<void> {
+    if (this.isReady()) {
+      return;
+    }
+    if (this.isStarting && this.startPromise) {
+      await this.startPromise;
+      return;
+    }
+    this.isStarting = true;
+    this.startPromise = this.doStart(settings);
+    try {
+      await this.startPromise;
+    } finally {
+      this.isStarting = false;
+    }
+  }
+
+  private async doStart(settings: Settings): Promise<void> {
+    await this.shutdown();
+
+    const platform = getCurrentPlatform();
+    const isValid = await platform.validateViamePath(settings);
+    if (isValid !== true) {
+      throw new Error(isValid);
+    }
+
+    return new Promise((resolve, reject) => {
+      const viameConstants = platform.getViameConstants(settings);
+      const pythonExe = platform.getViamePythonExe(settings);
+      const pyCommand = `"${pythonExe}" -s -m viame.core.query_service`;
+      const command = `${viameConstants.setupScriptAbs} && ${pyCommand}`;
+
+      // eslint-disable-next-line no-console
+      console.log(`[VideoSearch] Starting query service: ${command}`);
+
+      const stderrLines: string[] = [];
+      const maxStderrLines = 20;
+
+      this.process = observeChild(spawn(command, {
+        shell: viameConstants.shell,
+        cwd: settings.viamePath,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      }));
+
+      if (this.process.stdout) {
+        this.readline = readline.createInterface({
+          input: this.process.stdout,
+          crlfDelay: Infinity,
+        });
+        this.readline.on('line', (line) => this.handleResponse(line));
+      }
+
+      let startupTimeout: NodeJS.Timeout | null = null;
+
+      if (this.process.stderr) {
+        this.process.stderr.on('data', (data: Buffer) => {
+          const message = data.toString().trim();
+          if (message) {
+            // eslint-disable-next-line no-console
+            console.log(`[VideoSearch] ${message}`);
+            stderrLines.push(message);
+            if (stderrLines.length > maxStderrLines) {
+              stderrLines.shift();
+            }
+            if (message.includes('Service started, waiting for requests')) {
+              if (startupTimeout) {
+                clearTimeout(startupTimeout);
+                startupTimeout = null;
+              }
+              resolve();
+            }
+          }
+        });
+      }
+
+      const rejectStartup = (reason: string) => {
+        if (!this.isStarting) {
+          return;
+        }
+        this.isStarting = false;
+        if (startupTimeout) {
+          clearTimeout(startupTimeout);
+          startupTimeout = null;
+        }
+        const details = stderrLines.filter((l) => l.trim()).slice(-8).join('\n  ');
+        this.shutdown().finally(() => reject(new Error(
+          `Unable to start the video search service. ${reason}\n`
+          + `VIAME path: ${settings.viamePath}\n  ${details}`,
+        )));
+      };
+
+      this.process.on('exit', (code, signal) => {
+        // eslint-disable-next-line no-console
+        console.log(`[VideoSearch] Process exited with code ${code}, signal ${signal}`);
+        this.cleanup();
+        if (this.isStarting) {
+          rejectStartup(`The service process exited before it became ready (code ${code}, signal ${signal}).`);
+        }
+      });
+
+      this.process.on('error', (err) => {
+        console.error('[VideoSearch] Process error:', err);
+        this.cleanup();
+        if (this.isStarting) {
+          rejectStartup(`Failed to start the service process: ${err.message}`);
+        }
+      });
+
+      startupTimeout = setTimeout(() => {
+        rejectStartup('The service did not become ready within 5 minutes.');
+      }, 300000);
+    });
+  }
+
+  private handleResponse(line: string): void {
+    let response: ServiceResponse;
+    try {
+      response = JSON.parse(line) as ServiceResponse;
+    } catch (err) {
+      console.error('[VideoSearch] Failed to parse response:', line, err);
+      return;
+    }
+    const pending = this.pendingRequests.get(response.id);
+    if (pending) {
+      clearTimeout(pending.timeout);
+      this.pendingRequests.delete(response.id);
+      pending.resolve(response);
+    } else {
+      console.warn(`[VideoSearch] Received response for unknown request: ${response.id}`);
+    }
+  }
+
+  private sendRequest(payload: Record<string, unknown>, timeoutLabel: string): Promise<ServiceResponse> {
+    if (!this.isReady() || !this.process?.stdin) {
+      return Promise.reject(new Error('Video search service is not running'));
+    }
+    const id = this.generateRequestId();
+    const fullRequest = { ...payload, id };
+    return new Promise<ServiceResponse>((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`${timeoutLabel} request timed out after ${this.requestTimeoutMs}ms`));
+      }, this.requestTimeoutMs);
+
+      this.pendingRequests.set(id, { resolve, reject, timeout });
+
+      this.process!.stdin!.write(`${JSON.stringify(fullRequest)}\n`, (err) => {
+        if (err) {
+          clearTimeout(timeout);
+          this.pendingRequests.delete(id);
+          reject(err);
+        }
+      });
+    });
+  }
+
+  private static check(response: ServiceResponse, label: string): ServiceResponse {
+    if (!response.success) {
+      throw new Error(response.error || `${label} failed`);
+    }
+    return response;
+  }
+
+  // -------------------------------------------------------------- commands
+
+  /**
+   * Open one or more indexes for federated search (primary first), closing
+   * any previously open set if it differs. Each index gets its own embedded
+   * postgres instance on an incremented port inside the service.
+   */
+  async openIndexes(
+    settings: Settings,
+    indexDirs: string[],
+    backend: SearchIndexBackend = DefaultSearchIndexBackend,
+  ): Promise<void> {
+    await this.ensureStarted(settings);
+    if (indexDirs.length === this.currentIndexDirs.length
+      && indexDirs.every((dir, i) => this.currentIndexDirs[i] === dir)) {
+      return;
+    }
+    if (this.currentIndexDirs.length) {
+      await this.closeIndex();
+    }
+    const response = await this.sendRequest({
+      command: 'open_index', index_dirs: indexDirs, backend,
+    }, 'Open index');
+    QueryServiceManager.check(response, 'Opening the search indexes');
+    this.currentIndexDirs = indexDirs;
+  }
+
+  async formulateQuery(imagePath: string, boxes?: number[][]): Promise<ServiceResponse> {
+    const response = await this.sendRequest({
+      command: 'formulate_query',
+      image_path: imagePath,
+      boxes,
+    }, 'Query formulation');
+    return QueryServiceManager.check(response, 'Query formulation');
+  }
+
+  async processQuery(threshold?: number, iqrModelB64?: string): Promise<ServiceResponse> {
+    const response = await this.sendRequest({
+      command: 'process_query',
+      threshold: threshold ?? 0.0,
+      iqr_model_b64: iqrModelB64,
+    }, 'Query');
+    return QueryServiceManager.check(response, 'Query');
+  }
+
+  async refine(positiveIds: string[], negativeIds: string[]): Promise<ServiceResponse> {
+    const response = await this.sendRequest({
+      command: 'refine',
+      positive_ids: positiveIds,
+      negative_ids: negativeIds,
+    }, 'Query refinement');
+    return QueryServiceManager.check(response, 'Query refinement');
+  }
+
+  async exportModel(outputPath?: string): Promise<ServiceResponse> {
+    const response = await this.sendRequest({
+      command: 'export_model',
+      output_path: outputPath,
+    }, 'Model export');
+    return QueryServiceManager.check(response, 'Model export');
+  }
+
+  /**
+   * Delete all database rows for the given stream identifiers in an index.
+   * The service adopts or temporarily starts the index's postgres; if the
+   * index was open, the session set is closed for consistency.
+   */
+  async removeStreams(
+    indexDir: string,
+    streams: string[],
+    backend: SearchIndexBackend,
+  ): Promise<void> {
+    const response = await this.sendRequest({
+      command: 'remove_streams', index_dir: indexDir, streams, backend,
+    }, 'Stream removal');
+    QueryServiceManager.check(response, 'Stream removal');
+    if (response.closed_session) {
+      this.currentIndexDirs = [];
+    }
+  }
+
+  async closeIndex(): Promise<void> {
+    if (!this.isReady()) {
+      this.currentIndexDirs = [];
+      return;
+    }
+    try {
+      await this.sendRequest({ command: 'close_index' }, 'Close index');
+    } catch {
+      // best effort - shutting the process down also stops postgres
+    }
+    this.currentIndexDirs = [];
+  }
+
+  // ------------------------------------------------------------- lifecycle
+
+  private cleanup(): void {
+    this.pendingRequests.forEach((pending) => {
+      clearTimeout(pending.timeout);
+      pending.reject(new Error('Video search service terminated'));
+    });
+    this.pendingRequests.clear();
+
+    if (this.readline) {
+      this.readline.close();
+      this.readline = null;
+    }
+
+    this.process = null;
+    this.currentIndexDirs = [];
+    this.emit('shutdown');
+  }
+
+  async shutdown(): Promise<void> {
+    if (!this.process) {
+      return;
+    }
+    // eslint-disable-next-line no-console
+    console.log('[VideoSearch] Shutting down query service...');
+    await new Promise<void>((resolve) => {
+      const request = { id: this.generateRequestId(), command: 'shutdown' };
+      if (this.process?.stdin?.writable) {
+        this.process.stdin.write(`${JSON.stringify(request)}\n`);
+      }
+      const timeoutId = setTimeout(() => {
+        if (this.process) {
+          // eslint-disable-next-line no-console
+          console.log('[VideoSearch] Force killing query service...');
+          this.process.kill('SIGTERM');
+        }
+        this.cleanup();
+        resolve();
+      }, 10000);
+      if (this.process) {
+        this.process.once('exit', () => {
+          clearTimeout(timeoutId);
+          this.cleanup();
+          resolve();
+        });
+      } else {
+        clearTimeout(timeoutId);
+        resolve();
+      }
+    });
+  }
+}
+
+// Singleton instance shared by all IPC handlers.
+let queryServiceManager: QueryServiceManager | null = null;
+
+export function getQueryServiceManager(): QueryServiceManager {
+  if (!queryServiceManager) {
+    queryServiceManager = new QueryServiceManager();
+  }
+  return queryServiceManager;
+}
+
+export async function shutdownQueryService(): Promise<void> {
+  if (queryServiceManager) {
+    await queryServiceManager.shutdown();
+    queryServiceManager = null;
+  }
+}
+
+/**
+ * Remove one dataset from the shared search index: delete its database rows
+ * (via the query service, which owns postgres lifecycle) and drop it from
+ * the membership metadata. Stale ITQ hash entries are tolerated by the
+ * query engine and cleaned up on the next index build.
+ */
+async function removeFromIndex(settings: Settings, datasetId: string): Promise<void> {
+  const meta = await readIndexMeta(settings);
+  const streams = Object.keys(meta.streams)
+    .filter((s) => meta.streams[s].datasetId === datasetId);
+  if (!streams.length) {
+    return;
+  }
+  const backend: SearchIndexBackend = meta.backend ?? 'postgres';
+  const manager = getQueryServiceManager();
+  // Any open query session still holds the removed vectors in memory.
+  await manager.closeIndex();
+  if (backend === 'files') {
+    await Promise.all(streams.map((s) => removeStreamFiles(settings, s)));
+  } else {
+    await runIndexTool(settings, ['remove', '--database', 'database', '--backend', backend, ...streams]);
+  }
+  streams.forEach((s) => { delete meta.streams[s]; });
+  await writeIndexMeta(settings, meta);
+}
+
+/** Delete the entire shared search index from disk. */
+async function deleteEntireIndex(settings: Settings): Promise<void> {
+  const manager = getQueryServiceManager();
+  await manager.closeIndex();
+  await fs.remove(getIndexDir(settings));
+}
+
+/**
+ * Save the current IQR model as a runnable trained pipeline:
+ * DIVE_Pipelines/<name>/ containing <name>.svm plus the generic-detector SVM
+ * template as detector.pipe. Shows up under the "trained" pipeline category.
+ */
+async function exportSearchModel(settings: Settings, name: string): Promise<string> {
+  const safeName = name.replace(/[^a-zA-Z0-9 _-]/g, '').trim();
+  if (!safeName) {
+    throw new Error('A model name is required');
+  }
+  const manager = getQueryServiceManager();
+  if (!manager.isReady() || !manager.openIndexDirs().length) {
+    throw new Error('No active query session to export a model from');
+  }
+  const template = npath.join(settings.viamePath, 'configs', 'pipelines', ExportTemplateName);
+  if (!(await fs.pathExists(template))) {
+    throw new Error(`Missing pipeline template: ${template}`);
+  }
+  const outputDir = npath.join(settings.dataPath, 'DIVE_Pipelines', safeName);
+  await fs.ensureDir(outputDir);
+  await manager.exportModel(npath.join(outputDir, `${safeName}.svm`));
+  await fs.copy(template, npath.join(outputDir, 'detector.pipe'));
+  return outputDir;
+}
+
+export {
+  isVideoSearchInstalled,
+  getIndexDir,
+  readIndexMeta,
+  getIndexStatus,
+  listIndexedDatasets,
+  buildIndex,
+  removeFromIndex,
+  deleteEntireIndex,
+  exportSearchModel,
+  extractVideoFrame,
+};
diff --git a/client/platform/desktop/background.ts b/client/platform/desktop/background.ts
index 4fb8d2a13..baa76c179 100644
--- a/client/platform/desktop/background.ts
+++ b/client/platform/desktop/background.ts
@@ -6,6 +6,7 @@ import os from 'os';
 import path from 'path';
 
 import { closeAll as closeChildren } from './backend/native/processManager';
+import { shutdownQueryService } from './backend/native/videoSearch';
 import { listen, close as closeServer } from './backend/server';
 import ipcListen from './backend/ipcService';
 import {
@@ -189,6 +190,9 @@ protocol.registerSchemesAsPrivileged([
 
 async function cleanup() {
   closeServer();
+  // Graceful first: lets the query service stop its embedded postgres
+  // before closeChildren() kills whatever is left.
+  await shutdownQueryService().catch(() => undefined);
   await closeChildren();
   app.quit();
 }
diff --git a/client/platform/desktop/constants.ts b/client/platform/desktop/constants.ts
index 7652edc97..707c3210f 100644
--- a/client/platform/desktop/constants.ts
+++ b/client/platform/desktop/constants.ts
@@ -1,6 +1,7 @@
 import type {
   DatasetConfig, DatasetConfigMutable, DatasetType,
   Pipe, SubType, MediaImportResponse, PipelineParams,
+  VideoSearchIndexMeta, VideoSearchIndexMethod,
 } from 'dive-common/apispec';
 import { Attribute } from 'vue-media-annotator/use/AttributeTypes';
 import { AttributeTrackFilter } from 'vue-media-annotator/AttributeTrackFilterControls';
@@ -191,6 +192,7 @@ export enum JobType {
   RunPipeline,
   RunTraining,
   RunScoring,
+  BuildSearchIndex,
 }
 
 export interface JobArgs {
@@ -254,7 +256,21 @@ export interface CliTranscodingNotice {
   mediaCount: number;
 }
 
-export type Job = ConversionArgs | RunPipeline | RunTraining | ExportTrainedPipeline | RunScoring;
+/** Build a video search / IQR descriptor index over a dataset. */
+export interface BuildSearchIndex extends JobArgs {
+  type: JobType.BuildSearchIndex;
+  datasetId: string;
+  // detections: index around generic object proposals
+  // tracking: index around tracked proposals
+  // existing: index around this dataset's existing annotations
+  method: VideoSearchIndexMethod;
+}
+
+/** Sidecar metadata written alongside a built search index. */
+export type SearchIndexMeta = VideoSearchIndexMeta;
+
+export type Job = ConversionArgs | RunPipeline | RunTraining
+  | ExportTrainedPipeline | RunScoring | BuildSearchIndex;
 
 export interface DesktopJob {
   // key unique identifier for this job
@@ -262,11 +278,12 @@ export interface DesktopJob {
   // command that was run
   command: string;
   // jobType identify type of job
-  jobType: 'pipeline' | 'training' | 'conversion' | 'export' | 'scoring';
+  jobType: 'pipeline' | 'training' | 'conversion' | 'export' | 'scoring' | 'indexing';
   // title whatever humans should see this job called
   title: string;
   // arguments to creation
-  args: RunPipeline | RunTraining | ExportTrainedPipeline | ConversionArgs | RunScoring;
+  args: RunPipeline | RunTraining | ExportTrainedPipeline | ConversionArgs | RunScoring
+    | BuildSearchIndex;
   // datasetIds of the involved datasets
   datasetIds: string[];
   // pid of the process spawned
diff --git a/client/platform/desktop/frontend/api.ts b/client/platform/desktop/frontend/api.ts
index 2ecbfa7db..bf2a63e4b 100644
--- a/client/platform/desktop/frontend/api.ts
+++ b/client/platform/desktop/frontend/api.ts
@@ -12,6 +12,7 @@ import type {
   TextQueryRequest, TextQueryResponse, RefineDetectionsRequest, RefineDetectionsResponse,
   PipelineJobResult,
   ScoringDatasetSummary, ScoringJobArgs, ScoringResult, ScoringResultSummary, ScoringSourceOptions,
+  VideoSearchIndexStatus, VideoSearchIndexMethod, VideoSearchQueryResponse, VideoSearchIndexInfo,
 } from 'dive-common/apispec';
 
 import {
@@ -28,6 +29,7 @@ import {
   DesktopJob,
   MultiCamBatchScanResult,
   RunScoring,
+  BuildSearchIndex,
 } from 'platform/desktop/constants';
 
 import { gpuJobQueue, cpuJobQueue, jobHistory } from './store/jobs';
@@ -620,6 +622,76 @@ async function runTextQueryPipeline(
   gpuJobQueue.enqueue(args);
 }
 
+/**
+ * Video Search / IQR API
+ */
+
+async function videoSearchInstalled(): Promise<boolean> {
+  return window.diveDesktop.invoke('video-search-installed');
+}
+
+async function videoSearchIndexStatus(datasetId: string): Promise<VideoSearchIndexStatus> {
+  return window.diveDesktop.invoke('video-search-index-status', datasetId);
+}
+
+/** Queue a search index build; progress arrives via job-update events. */
+function videoSearchBuildIndex(datasetId: string, method: VideoSearchIndexMethod): void {
+  const args: BuildSearchIndex = { type: JobType.BuildSearchIndex, datasetId, method };
+  gpuJobQueue.enqueue(args);
+}
+
+/** Delete the entire shared search index from disk. */
+async function videoSearchDeleteIndex(): Promise<{ success: boolean }> {
+  return window.diveDesktop.invoke('video-search-delete-index');
+}
+
+async function videoSearchListIndexes(): Promise<VideoSearchIndexInfo[]> {
+  return window.diveDesktop.invoke('video-search-list-indexes');
+}
+
+async function videoSearchOpenIndex(): Promise<{
+  success: boolean; streams: VideoSearchIndexInfo[];
+}> {
+  return window.diveDesktop.invoke('video-search-open-index');
+}
+
+/** Remove one dataset's rows from the shared search index. */
+async function videoSearchRemoveIndex(datasetId: string): Promise<{ success: boolean }> {
+  return window.diveDesktop.invoke('video-search-remove-index', datasetId);
+}
+
+async function videoSearchFormulate(imagePath: string, boxes?: number[][]): Promise<VideoSearchQueryResponse> {
+  return window.diveDesktop.invoke('video-search-formulate', { imagePath, boxes });
+}
+
+async function videoSearchQuery(
+  options: { threshold?: number; iqrModelB64?: string; iqrModelPath?: string } = {},
+): Promise<VideoSearchQueryResponse> {
+  return window.diveDesktop.invoke('video-search-query', options);
+}
+
+/** Build a local media-server URL for an arbitrary file (e.g. thumbnails). */
+async function getMediaUrl(filePath: string): Promise<string> {
+  await getClient();
+  return `${_baseURL}/media?path=${encodeURIComponent(filePath)}`;
+}
+
+async function videoSearchRefine(positiveIds: string[], negativeIds: string[]): Promise<VideoSearchQueryResponse> {
+  return window.diveDesktop.invoke('video-search-refine', { positiveIds, negativeIds });
+}
+
+async function videoSearchExportModel(name: string): Promise<{ success: boolean; outputDir: string }> {
+  return window.diveDesktop.invoke('video-search-export-model', { name });
+}
+
+async function videoSearchClose(): Promise<{ success: boolean }> {
+  return window.diveDesktop.invoke('video-search-close');
+}
+
+async function videoSearchExtractFrame(videoPath: string, frameNum: number, fps: number): Promise<string> {
+  return window.diveDesktop.invoke('video-search-extract-frame', { videoPath, frameNum, fps });
+}
+
 /**
  * Interactive Stereo API
  */
@@ -829,6 +901,13 @@ function getTileURL(itemId: string, x: number, y: number, level: number, query:
   return `${_baseURL}/dataset/${itemId}/tiles/${level}/${x}/${y}${suffix}`;
 }
 
+/** Frame rate, size and length of a video file on disk, read by the backend. */
+async function videoInfo(videoPath: string) {
+  const client = await getClient();
+  const { data } = await client.get<{ fps: number; width: number; height: number; frameCount?: number; duration?: number }>('video-info', { params: { path: videoPath } });
+  return data;
+}
+
 async function loadConfig(id: string) {
   const client = await getClient();
   const { data } = await client.get<DesktopConfig>(`dataset/${id}/meta`);
@@ -954,6 +1033,7 @@ export {
   /* Standard Specification APIs */
   loadConfig,
   peekConfig,
+  videoInfo,
   loadDetections,
   loadFrameMetadata,
   getPipelineList,
@@ -1029,6 +1109,21 @@ export {
   refineDetections,
   runTextQueryPipeline,
   /* Auto Register APIs */
+  /* Video Search / IQR */
+  videoSearchInstalled,
+  videoSearchIndexStatus,
+  videoSearchBuildIndex,
+  videoSearchRemoveIndex,
+  videoSearchDeleteIndex,
+  videoSearchListIndexes,
+  videoSearchOpenIndex,
+  videoSearchFormulate,
+  videoSearchQuery,
+  videoSearchRefine,
+  videoSearchExportModel,
+  videoSearchClose,
+  videoSearchExtractFrame,
+  getMediaUrl,
   /* Stereo APIs */
   stereoEnable,
   stereoDisable,
diff --git a/client/platform/desktop/frontend/components/JobsHistory.vue b/client/platform/desktop/frontend/components/JobsHistory.vue
index d6fcbb0a7..753385c0e 100644
--- a/client/platform/desktop/frontend/components/JobsHistory.vue
+++ b/client/platform/desktop/frontend/components/JobsHistory.vue
@@ -42,7 +42,7 @@ export default defineComponent({
     }
 
     async function cancelInProgressJob(job: DesktopJob): Promise<void> {
-      if (job.exitCode === null && !job.cancelledJob) {
+      if (job.pid > 0 && job.exitCode === null && !job.cancelledJob) {
         await cancelJob(job);
       }
     }
@@ -203,6 +203,7 @@ export default defineComponent({
                     text
                     small
                     class="mb-2 error--text text--lighten-3 text-decoration-none"
+                    :disabled="job.job.pid <= 0"
                     @click="cancelInProgressJob(job.job)"
                   >
                     <v-icon
diff --git a/client/platform/desktop/frontend/components/JobsQueued.vue b/client/platform/desktop/frontend/components/JobsQueued.vue
index fd0057799..66875a6bf 100644
--- a/client/platform/desktop/frontend/components/JobsQueued.vue
+++ b/client/platform/desktop/frontend/components/JobsQueued.vue
@@ -43,6 +43,9 @@ export default defineComponent({
       if (jobSpec.type === JobType.ExportTrainedPipeline) {
         return `export trained pipeline: ${jobSpec.path}`;
       }
+      if (jobSpec.type === JobType.BuildSearchIndex) {
+        return `indexing: ${datasetName(jobSpec.datasetId)} (${jobSpec.method})`;
+      }
       if (jobSpec.type === JobType.RunTraining) {
         const title = `training: ${datasetName(jobSpec.datasetIds[0])}`;
         if (jobSpec.datasetIds.length > 1) {
@@ -69,7 +72,7 @@ export default defineComponent({
       if (jobSpec.type === JobType.Conversion) {
         return [jobSpec.meta.id];
       }
-      if (jobSpec.type === JobType.RunPipeline) {
+      if (jobSpec.type === JobType.RunPipeline || jobSpec.type === JobType.BuildSearchIndex) {
         return [jobSpec.datasetId];
       }
       if (jobSpec.type === JobType.RunTraining) {
diff --git a/client/platform/desktop/frontend/components/QueryDatasetsPanel.vue b/client/platform/desktop/frontend/components/QueryDatasetsPanel.vue
new file mode 100644
index 000000000..7848419d8
--- /dev/null
+++ b/client/platform/desktop/frontend/components/QueryDatasetsPanel.vue
@@ -0,0 +1,334 @@
+<script lang="ts">
+import {
+  computed, defineComponent, PropType, ref,
+} from 'vue';
+import type { VideoSearchIndexMethod } from 'dive-common/apispec';
+import { usePrompt } from 'dive-common/vue-utilities/prompt-service';
+import type { QueryPageState } from 'platform/desktop/frontend/useQueryPage';
+import DatasetPicker from 'dive-common/components/DatasetPicker.vue';
+
+const IndexMethodItems: { text: string; value: VideoSearchIndexMethod }[] = [
+  { text: 'Around generic detections', value: 'detections' },
+  { text: 'Detection and tracking', value: 'tracking' },
+  { text: 'Around existing annotations', value: 'existing' },
+  { text: 'Whole frames', value: 'frames' },
+];
+
+const IndexMethodLabels: Record<VideoSearchIndexMethod, string> = {
+  detections: 'Detections',
+  tracking: 'Tracking',
+  existing: 'Annotations',
+  frames: 'Frames',
+};
+
+/**
+ * Which datasets queries search: pick them from the library with the
+ * shared picker, see whether each one is in the search index, and build
+ * or drop indexes for several at once.
+ */
+export default defineComponent({
+  name: 'QueryDatasetsPanel',
+  components: { DatasetPicker },
+  props: {
+    page: {
+      type: Object as PropType<QueryPageState>,
+      required: true,
+    },
+  },
+  setup(props, { emit }) {
+    const { prompt } = usePrompt();
+    const method = ref<VideoSearchIndexMethod>('detections');
+
+    const pendingDatasets = computed(() => props.page.datasets.value.filter((dataset) => dataset.index !== 'indexed'));
+    const listedIds = computed(() => props.page.datasets.value.map((d) => d.id));
+    // Indexed datasets are listed above; a multicamera dataset is indexed through its first camera.
+    const addableDatasets = computed(() => {
+      const indexed = props.page.indexMembers.value.map((member) => member.datasetId);
+      return props.page.available.value.filter((dataset) => !indexed
+        .some((id) => id === dataset.id || id.startsWith(`${dataset.id}/`)));
+    });
+
+    function removeMany(ids: string[]) {
+      ids.forEach((id) => props.page.removeDataset(id));
+    }
+
+    const unindexedIds = computed(() => props.page.datasets.value
+      .filter((d) => d.index === 'not-indexed' || d.index === 'error')
+      .map((d) => d.id));
+
+    function buildUnindexed() {
+      props.page.buildIndex(unindexedIds.value, method.value);
+    }
+
+    function buildOne(id: string) {
+      props.page.buildIndex([id], method.value);
+    }
+
+    async function removeIndex(id: string) {
+      const ok = await prompt({
+        title: 'Remove From Search Index',
+        text: [`Remove ${props.page.indexMembers.value.find((member) => member.datasetId === id)?.name || props.page.datasetName(id)} from the search index?`,
+          'The video and annotations will be kept. It can be indexed again later.'],
+        confirm: true,
+        positiveButton: 'Remove',
+        negativeButton: 'Cancel',
+      });
+      if (ok) await props.page.removeFromIndex(id);
+    }
+
+    async function deleteIndex() {
+      const ok = await prompt({
+        title: 'Delete Entire Search Index',
+        text: ['Delete the search index for all listed sequences?', 'Videos and annotations will be kept. Searching will require building the index again.'],
+        confirm: true,
+        positiveButton: 'Delete index',
+        negativeButton: 'Cancel',
+      });
+      if (ok) await props.page.deleteEntireIndex();
+    }
+
+    function indexBadge(state: string) {
+      switch (state) {
+        case 'indexed': return { icon: 'mdi-check-circle', color: 'success', text: 'Indexed' };
+        case 'building': return { icon: 'mdi-progress-wrench', color: 'primary', text: 'Building index…' };
+        case 'not-indexed': return { icon: 'mdi-circle-outline', color: 'grey', text: 'Not indexed' };
+        case 'error': return { icon: 'mdi-alert-circle', color: 'error', text: 'Error' };
+        default: return { icon: 'mdi-progress-clock', color: 'grey', text: 'Checking…' };
+      }
+    }
+
+    return {
+      listedIds,
+      addableDatasets,
+      pendingDatasets,
+      methodLabel: (method?: VideoSearchIndexMethod) => (method ? IndexMethodLabels[method] : ''),
+      deleteIndex,
+      removeMany,
+      method,
+      methodItems: IndexMethodItems,
+      unindexedIds,
+      buildUnindexed,
+      buildOne,
+      removeIndex,
+      indexBadge,
+      open: (id: string) => emit('open-dataset', id),
+    };
+  },
+});
+</script>
+
+<template>
+  <div class="query-datasets">
+    <div class="d-flex align-center mb-2">
+      <h3 class="text-subtitle-1">
+        Sequences in the search index ({{ page.indexMembers.value.length }})
+      </h3>
+      <v-spacer />
+      <v-btn small outlined color="error" :disabled="!page.indexMembers.value.length || page.indexActionsDisabled.value" @click="deleteIndex">
+        Delete entire index
+      </v-btn>
+    </div>
+    <p class="text-caption">
+      One shared index stores one entry per video or sequence. Rebuilding a sequence replaces its entry.
+    </p>
+    <v-simple-table v-if="page.indexMembers.value.length" dense class="datasets-table mb-4">
+      <thead>
+        <tr>
+          <th>Video / sequence</th>
+          <th>Index type</th>
+          <th class="text-right">
+            Actions
+          </th>
+        </tr>
+      </thead>
+      <tbody>
+        <tr v-for="member in page.indexMembers.value" :key="member.streamName">
+          <td><a @click="open(member.datasetId)">{{ member.name }}</a></td>
+          <td class="text-caption">
+            {{ methodLabel(member.method) }}
+          </td>
+          <td class="text-right">
+            <v-btn small text color="error" :disabled="page.indexActionsDisabled.value" @click="removeIndex(member.datasetId)">
+              Remove from index
+            </v-btn>
+          </td>
+        </tr>
+      </tbody>
+    </v-simple-table>
+    <p v-else class="text-caption grey--text">
+      No successfully generated index entries yet.
+    </p>
+    <v-divider class="mb-4" />
+    <h3 class="text-subtitle-1 mb-2">
+      Build index
+    </h3>
+    <DatasetPicker
+      :items="addableDatasets"
+      :selected-ids="listedIds"
+      hint="Queries search the indexed datasets listed here. Build an index for a dataset before searching it."
+      no-data-text="No datasets in the library."
+      compact
+      class="mb-3"
+      @add="page.addDataset"
+      @add-many="page.addDatasets"
+      @remove="page.removeDataset"
+      @remove-many="removeMany"
+    />
+    <div class="text-subtitle-2 mb-1">
+      Pending sequences ({{ pendingDatasets.length }})
+    </div>
+    <div
+      v-if="pendingDatasets.length === 0"
+      class="text-caption grey--text py-2"
+    >
+      None yet. Add datasets from the list above, or select them in the library and choose Index.
+    </div>
+    <template v-else>
+      <div class="d-flex align-center flex-wrap mb-2 build-row">
+        <v-select
+          v-model="method"
+          :items="methodItems"
+          label="Index type"
+          dense
+          outlined
+          hide-details
+          class="method-select mr-2"
+        />
+        <v-btn
+          small
+          depressed
+          color="primary"
+          :disabled="unindexedIds.length === 0 || page.installed.value === false || page.changingIndex.value"
+          @click="buildUnindexed"
+        >
+          <v-icon
+            small
+            left
+          >
+            mdi-database-plus
+          </v-icon>
+          Build index for {{ unindexedIds.length }} not indexed
+        </v-btn>
+        <span
+          v-if="page.installed.value === false"
+          class="text-caption error--text ml-3"
+        >
+          Video search tools were not found in the VIAME install.
+        </span>
+      </div>
+      <v-simple-table
+        dense
+        class="datasets-table"
+      >
+        <thead>
+          <tr>
+            <th>Dataset</th>
+            <th>Type</th>
+            <th>Search index</th>
+            <th />
+          </tr>
+        </thead>
+        <tbody>
+          <tr
+            v-for="dataset in pendingDatasets"
+            :key="dataset.id"
+          >
+            <td class="name-cell">
+              <a @click="open(dataset.id)">{{ dataset.name }}</a>
+            </td>
+            <td class="text-caption">
+              {{ dataset.type || '' }}
+            </td>
+            <td>
+              <span class="d-inline-flex align-center">
+                <v-icon
+                  small
+                  :color="indexBadge(dataset.index).color"
+                  class="mr-1"
+                >
+                  {{ indexBadge(dataset.index).icon }}
+                </v-icon>
+                <span
+                  class="text-caption"
+                  :class="dataset.index === 'error' ? 'error--text' : 'grey--text'"
+                >{{ dataset.index === 'error' && dataset.error ? dataset.error : indexBadge(dataset.index).text }}</span>
+              </span>
+            </td>
+            <td class="text-right actions-cell">
+              <v-btn
+                v-if="dataset.index === 'not-indexed' || dataset.index === 'error'"
+                icon
+                x-small
+                title="Build the search index for this dataset"
+                :disabled="page.installed.value === false || page.changingIndex.value"
+                @click="buildOne(dataset.id)"
+              >
+                <v-icon small>
+                  mdi-database-plus
+                </v-icon>
+              </v-btn>
+              <v-btn
+                icon
+                x-small
+                title="Re-check index status"
+                :disabled="dataset.index === 'building'"
+                @click="page.refreshIndexStatus(dataset.id)"
+              >
+                <v-icon small>
+                  mdi-refresh
+                </v-icon>
+              </v-btn>
+              <v-btn
+                icon
+                x-small
+                title="Remove from this list"
+                @click="page.removeDataset(dataset.id)"
+              >
+                <v-icon small>
+                  mdi-close
+                </v-icon>
+              </v-btn>
+            </td>
+          </tr>
+        </tbody>
+      </v-simple-table>
+    </template>
+  </div>
+</template>
+
+<style lang="scss" scoped>
+.query-datasets {
+  padding-top: 12px;
+}
+
+.build-row {
+  gap: 4px;
+}
+
+.method-select {
+  max-width: 260px;
+}
+
+.name-cell {
+  max-width: 320px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.actions-cell {
+  white-space: nowrap;
+}
+
+.datasets-table ::v-deep td {
+  padding: 4px 8px !important;
+}
+
+// Line the table text up with the section titles and captions.
+.datasets-table ::v-deep th:first-child,
+.datasets-table ::v-deep td:first-child,
+.query-datasets ::v-deep .picker-table th:first-child,
+.query-datasets ::v-deep .picker-table td:first-child {
+  padding-left: 0 !important;
+}
+</style>
diff --git a/client/platform/desktop/frontend/components/QueryExemplar.vue b/client/platform/desktop/frontend/components/QueryExemplar.vue
new file mode 100644
index 000000000..b392c9a1a
--- /dev/null
+++ b/client/platform/desktop/frontend/components/QueryExemplar.vue
@@ -0,0 +1,145 @@
+<script lang="ts">
+import {
+  defineComponent, PropType, ref, watch,
+} from 'vue';
+
+type Box = [number, number, number, number];
+
+/**
+ * An exemplar image with a box the user drags out on it, reported in image
+ * pixels. Dragging again replaces the box; a click clears it.
+ */
+export default defineComponent({
+  name: 'QueryExemplar',
+  props: {
+    src: {
+      type: String,
+      required: true,
+    },
+    box: {
+      type: Array as unknown as PropType<Box | null>,
+      default: null,
+    },
+  },
+  setup(props, { emit }) {
+    const image = ref<HTMLImageElement | null>(null);
+    const draft = ref<Box | null>(props.box);
+    let start: [number, number] | null = null;
+
+    watch(() => props.box, (next) => { draft.value = next; });
+
+    /** Image pixel under a pointer event, allowing for the displayed scale. */
+    function imagePoint(event: PointerEvent): [number, number] | null {
+      const el = image.value;
+      if (!el || !el.naturalWidth) return null;
+      const rect = el.getBoundingClientRect();
+      const x = ((event.clientX - rect.left) / rect.width) * el.naturalWidth;
+      const y = ((event.clientY - rect.top) / rect.height) * el.naturalHeight;
+      return [
+        Math.min(el.naturalWidth, Math.max(0, x)),
+        Math.min(el.naturalHeight, Math.max(0, y)),
+      ];
+    }
+
+    function onDown(event: PointerEvent) {
+      if (event.button !== 0) return;
+      const point = imagePoint(event);
+      if (!point) return;
+      start = point;
+      draft.value = null;
+      image.value?.setPointerCapture(event.pointerId);
+    }
+
+    function onMove(event: PointerEvent) {
+      if (!start) return;
+      const point = imagePoint(event);
+      if (!point) return;
+      draft.value = [
+        Math.min(start[0], point[0]), Math.min(start[1], point[1]),
+        Math.max(start[0], point[0]), Math.max(start[1], point[1]),
+      ];
+    }
+
+    function onUp(event: PointerEvent) {
+      if (!start) return;
+      start = null;
+      try {
+        image.value?.releasePointerCapture(event.pointerId);
+      } catch {
+        // Capture may already be gone.
+      }
+      const box = draft.value;
+      // A tiny drag is a click: clear the box.
+      if (!box || (box[2] - box[0]) < 4 || (box[3] - box[1]) < 4) {
+        draft.value = null;
+        emit('update:box', null);
+        return;
+      }
+      emit('update:box', box.map(Math.round) as Box);
+    }
+
+    /** The box as a percentage rectangle over the displayed image. */
+    function boxStyle(): Record<string, string> {
+      const el = image.value;
+      const box = draft.value;
+      if (!el || !box || !el.naturalWidth) return { display: 'none' };
+      return {
+        left: `${(100 * box[0]) / el.naturalWidth}%`,
+        top: `${(100 * box[1]) / el.naturalHeight}%`,
+        width: `${(100 * (box[2] - box[0])) / el.naturalWidth}%`,
+        height: `${(100 * (box[3] - box[1])) / el.naturalHeight}%`,
+      };
+    }
+
+    return {
+      image, draft, onDown, onMove, onUp, boxStyle,
+    };
+  },
+});
+</script>
+
+<template>
+  <div class="query-exemplar">
+    <img
+      ref="image"
+      :src="src"
+      class="exemplar-image"
+      draggable="false"
+      @pointerdown="onDown"
+      @pointermove="onMove"
+      @pointerup="onUp"
+      @pointercancel="onUp"
+    >
+    <div
+      class="exemplar-box"
+      :style="boxStyle()"
+    />
+    <div class="text-caption grey--text mt-1">
+      {{ draft ? `Box ${draft.map(Math.round).join(', ')} (click to clear)` : 'Whole image; drag to mark one object' }}
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.query-exemplar {
+  position: relative;
+  display: inline-block;
+  max-width: 100%;
+}
+
+.exemplar-image {
+  display: block;
+  max-width: 100%;
+  max-height: 260px;
+  user-select: none;
+  touch-action: none;
+  cursor: crosshair;
+}
+
+.exemplar-box {
+  position: absolute;
+  border: 2px solid #00e5ff;
+  background: rgba(0, 229, 255, 0.12);
+  pointer-events: none;
+}
+</style>
diff --git a/client/platform/desktop/frontend/components/QueryPage.vue b/client/platform/desktop/frontend/components/QueryPage.vue
new file mode 100644
index 000000000..fece7b33e
--- /dev/null
+++ b/client/platform/desktop/frontend/components/QueryPage.vue
@@ -0,0 +1,964 @@
+<script lang="ts">
+import {
+  computed, defineComponent, nextTick, onBeforeUnmount, onMounted, reactive, ref, watch,
+} from 'vue';
+import { onBeforeRouteLeave, useRoute, useRouter } from 'vue-router/composables';
+import { useApi } from 'dive-common/apispec';
+import { usePrompt } from 'dive-common/vue-utilities/prompt-service';
+import { createReviewService, provideReview } from 'dive-common/use/useReview';
+import { getMediaUrl } from 'platform/desktop/frontend/api';
+import { createQueryPage } from 'platform/desktop/frontend/useQueryPage';
+import { provideVideoSearch } from 'platform/desktop/frontend/useVideoSearch';
+import { createItemChips, createSearchChips } from 'platform/desktop/frontend/useSearchChips';
+import { createSearchReview, OverlapChoice, OverlapSummary } from 'platform/desktop/frontend/useSearchReview';
+import { holdQuerySession, takeQuerySession } from 'platform/desktop/frontend/querySession';
+import { usePersistentGridSettings } from 'dive-common/review/gridSettings';
+import { useReviewGrid } from 'dive-common/review/useReviewGrid';
+import { reviewViewerLocation } from 'dive-common/review/viewerNavigation';
+import type { ReviewItem } from 'dive-common/review/types';
+import ReviewGrid from 'dive-common/components/Review/ReviewGrid.vue';
+import ReviewGridControls from 'dive-common/components/Review/ReviewGridControls.vue';
+import ReviewCell from 'dive-common/components/Review/ReviewCell.vue';
+import NavigationBar from './NavigationBar.vue';
+import QueryDatasetsPanel from './QueryDatasetsPanel.vue';
+import VideoSearchResultsGrid from './VideoSearchResultsGrid.vue';
+import QueryExemplar from './QueryExemplar.vue';
+import { takeQueryLaunch } from '../queryLaunch';
+
+type QueryView = 'query' | 'datasets';
+
+/** The overlap dialog's choices, laid out left to right, top to bottom. */
+const OverlapOptions: { choice: OverlapChoice; label: string; hint: string }[] = [
+  { choice: 'overwrite-overlapping', label: 'Replace Overlapping', hint: 'Delete only the existing annotations these results overlap, then save every result.' },
+  { choice: 'overwrite-all', label: 'Replace All Existing', hint: 'Delete every existing annotation in these sequences, then save the results.' },
+  { choice: 'keep-originals', label: 'Save Non-Overlapping Only', hint: 'Keep the existing annotations and save just the results that do not overlap them.' },
+  { choice: 'discard', label: 'Discard All Results', hint: 'Save nothing and drop every result change.' },
+];
+
+/** Footer height of a text-hit cell (label and frame line), for the chip aspect. */
+const TextCellFooterPx = 44;
+
+/**
+ * The Query page: choose datasets and index them, then search across them
+ * from an image, a video frame or a text prompt, reviewing the ranked hits
+ * in the chip grid.
+ */
+export default defineComponent({
+  name: 'QueryPage',
+  components: {
+    NavigationBar, QueryDatasetsPanel, VideoSearchResultsGrid, QueryExemplar, ReviewGrid, ReviewGridControls, ReviewCell,
+  },
+  setup() {
+    const route = useRoute();
+    const router = useRouter();
+    // Coming back (e.g. from a result opened in the viewer) resumes the
+    // session that was parked on leaving: exemplar, results, marks, edits.
+    const resumed = takeQuerySession();
+    const page = resumed?.page ?? createQueryPage();
+    provideVideoSearch(page.search);
+    // Results edited as annotations are held (and saved) by a review service.
+    const review = resumed?.review ?? createReviewService({ api: useApi() });
+    provideReview(review);
+    const { prompt } = usePrompt();
+
+    // Results that overlap annotations a dataset already has: the user
+    // picks how to save them in a four-way dialog owned by this page.
+    const overlapDialog = ref<OverlapSummary | null>(null);
+    let overlapResolve: ((choice: OverlapChoice) => void) | null = null;
+    function resolveOverlap(summary: OverlapSummary): Promise<OverlapChoice> {
+      overlapDialog.value = summary;
+      return new Promise((resolve) => { overlapResolve = resolve; });
+    }
+    function chooseOverlap(choice: OverlapChoice) {
+      const resolve = overlapResolve;
+      overlapResolve = null;
+      overlapDialog.value = null;
+      resolve?.(choice);
+    }
+    const searchReview = resumed?.searchReview ?? createSearchReview(page.search, review, { resolveOverlap });
+    const view = ref<QueryView>(route.query.view === 'datasets' ? 'datasets' : (resumed?.view ?? 'query'));
+    const searchChips = resumed?.searchChips ?? createSearchChips(page.search, {
+      itemFor: (result) => searchReview.itemOf(result),
+      hidden: (result) => searchReview.isRemoved(result),
+    });
+    const textChips = resumed?.textChips ?? createItemChips(page.textItems);
+    const resultsMemory = resumed?.results ?? reactive({ page: 0, hideReviewed: false });
+    const gridSettings = usePersistentGridSettings();
+    const textGridActive = computed(() => view.value === 'query' && page.mode.value === 'text');
+    const textGrid = useReviewGrid({
+      items: page.textItems,
+      grid: gridSettings,
+      chipStore: textChips.store,
+      active: textGridActive,
+      footerPx: TextCellFooterPx,
+      outline: '',
+    });
+
+    const imageUrl = ref('');
+    watch(page.imagePath, async (path) => {
+      imageUrl.value = path ? await getMediaUrl(path) : '';
+    }, { immediate: true });
+    const videoFrameUrl = ref('');
+    watch(page.videoFramePath, async (path) => {
+      videoFrameUrl.value = path ? await getMediaUrl(path) : '';
+    }, { immediate: true });
+
+    const datasetChoices = computed(() => page.datasets.value.map((d) => ({ value: d.id, text: d.name })));
+    /** The controls-and-results layout is up; its left column then carries the view and mode toggles. */
+    const showLayout = computed(() => view.value === 'query' && page.installed.value !== false
+      && (page.indexedIds.value.length > 0 || page.mode.value === 'text'));
+
+    /** Dataset ids handed off by the library selection. */
+    const initialDatasetIds = computed(() => {
+      const query = route.query.datasetIds;
+      const values = Array.isArray(query) ? query : [query];
+      return values.flatMap((value) => (value || '').split(',')).filter(Boolean);
+    });
+
+    async function pickImage() {
+      const ret = await window.diveDesktop.showOpenDialog({
+        properties: ['openFile'],
+        filters: [
+          { name: 'Images', extensions: ['jpg', 'jpeg', 'png', 'bmp', 'tif', 'tiff'] },
+          { name: 'All Files', extensions: ['*'] },
+        ],
+      });
+      if (ret.canceled || !ret.filePaths?.length) return;
+      [page.imagePath.value] = ret.filePaths;
+      page.imageBox.value = null;
+    }
+
+    async function pickVideoFile() {
+      const ret = await window.diveDesktop.showOpenDialog({
+        properties: ['openFile'],
+        filters: [
+          { name: 'Videos', extensions: ['mp4', 'avi', 'mov', 'mkv', 'mpg', 'mpeg', 'webm'] },
+          { name: 'All Files', extensions: ['*'] },
+        ],
+      });
+      if (ret.canceled || !ret.filePaths?.length) return;
+      [page.video.filePath] = ret.filePaths;
+      page.video.kind = 'file';
+      page.videoFramePath.value = '';
+    }
+
+    async function pickModel() {
+      const ret = await window.diveDesktop.showOpenDialog({
+        properties: ['openFile'],
+        filters: [
+          { name: 'SVM Models', extensions: ['svm'] },
+          { name: 'All Files', extensions: ['*'] },
+        ],
+      });
+      if (ret.canceled || !ret.filePaths?.length) return;
+      [page.warmStartModel.value] = ret.filePaths;
+    }
+
+    function openViewer(datasetId: string, frame?: number, trackId?: number) {
+      router.push(reviewViewerLocation(datasetId, {
+        ...(frame === undefined ? {} : { frame }),
+        ...(trackId === undefined ? {} : { trackId }),
+      }));
+    }
+
+    function onBeforeUnload(event: BeforeUnloadEvent) {
+      if (searchReview.hasChanges.value) {
+        event.preventDefault();
+        // eslint-disable-next-line no-param-reassign
+        event.returnValue = '';
+      }
+    }
+
+    onBeforeRouteLeave(async (_to, _from, next) => {
+      if (!searchReview.hasChanges.value) { next(); return; }
+      const pending = searchReview.changeCount.value;
+      const ok = await prompt({
+        title: 'Unsaved annotation changes',
+        text: [
+          `${pending} result${pending === 1 ? '' : 's'} would be saved as annotation${pending === 1 ? '' : 's'}.`,
+          'Save before leaving? Use Discard on the results toolbar to drop them instead.',
+        ],
+        confirm: true,
+        positiveButton: 'Save and leave',
+        negativeButton: 'Stay',
+      });
+      if (!ok) { next(false); return; }
+      const outcome = await searchReview.save();
+      // A failed save leaves its error on the page; stay put.
+      next(outcome === 'failed' ? false : undefined);
+    });
+
+    const textCells = computed(() => textGrid.pageItems.value.map((item) => {
+      const hit = page.hitOf(item.key);
+      return {
+        item,
+        hit,
+        subtitle: `${page.datasetName(item.datasetId)} · frame ${item.primary.frame}`,
+        title: `${page.datasetName(item.datasetId)} · frame ${item.primary.frame}`,
+      };
+    }));
+
+    const textCountLabel = computed(() => {
+      const count = page.textHits.value.length;
+      return `${count} hit${count === 1 ? '' : 's'}`;
+    });
+
+    function onKeydown(event: KeyboardEvent) {
+      textGrid.handleKeydown(event);
+    }
+
+    onMounted(async () => {
+      const launch = typeof route.query.launch === 'string' ? takeQueryLaunch(route.query.launch) : undefined;
+      window.addEventListener('keydown', onKeydown);
+      window.addEventListener('beforeunload', onBeforeUnload);
+      if (resumed) {
+        await nextTick();
+        textGrid.goToPage(resumed.textPage);
+      }
+      await page.refreshAvailable();
+      if (initialDatasetIds.value.length) {
+        await page.addDatasets(initialDatasetIds.value);
+        if (page.datasets.value.every((d) => d.index !== 'indexed')) view.value = 'datasets';
+      } else if (page.datasets.value.length === 0) {
+        view.value = 'datasets';
+      }
+      if (launch) {
+        view.value = 'query';
+        page.mode.value = 'image';
+        page.imagePath.value = launch.imagePath;
+        page.imageBox.value = launch.box || null;
+        page.warmStartModel.value = launch.modelPath || '';
+        page.onlySelected.value = false;
+        page.search.selectIndex(launch.streamName);
+        await page.runImageQuery();
+      }
+    });
+    onBeforeUnmount(() => {
+      window.removeEventListener('keydown', onKeydown);
+      window.removeEventListener('beforeunload', onBeforeUnload);
+      page.cancelTextQuery();
+      const textPage = textGrid.page.value;
+      textGrid.dispose();
+      // Parked for the next visit rather than disposed; chips stay cached.
+      holdQuerySession({
+        page, review, searchReview, searchChips, textChips, view: view.value, results: resultsMemory, textPage,
+      });
+    });
+
+    async function saveModel() {
+      const name = window.prompt('Name for the trained model');
+      if (!name) return;
+      const dir = await page.search.saveModel(name.trim());
+      if (dir) window.alert(`Saved trained model to ${dir}.`);
+    }
+
+    function searchSimilar(item: ReviewItem) {
+      const hit = page.hitOf(item.key);
+      if (hit) {
+        page.mode.value = 'image';
+        page.searchSimilarTo(hit);
+      }
+    }
+
+    return {
+      page,
+      view,
+      showLayout,
+      searchChips,
+      searchReview,
+      resultsMemory,
+      overlapDialog,
+      overlapOptions: OverlapOptions,
+      chooseOverlap,
+      textChips,
+      gridSettings,
+      textGrid,
+      textCells,
+      textCountLabel,
+      imageUrl,
+      videoFrameUrl,
+      datasetChoices,
+      pickImage,
+      pickVideoFile,
+      pickModel,
+      openViewer,
+      saveModel,
+      searchSimilar,
+    };
+  },
+});
+</script>
+
+<template>
+  <v-main>
+    <navigation-bar />
+    <div class="query-page">
+      <div
+        v-if="!showLayout"
+        class="query-toolbar d-flex align-center flex-wrap px-2 pt-2"
+      >
+        <v-btn-toggle
+          :value="view"
+          mandatory
+          dense
+          class="mr-3"
+          @change="view = $event"
+        >
+          <v-btn
+            small
+            value="query"
+          >
+            <v-icon
+              small
+              left
+            >
+              mdi-image-search-outline
+            </v-icon>
+            Query
+          </v-btn>
+          <v-btn
+            small
+            value="datasets"
+          >
+            <v-icon
+              small
+              left
+            >
+              mdi-database
+            </v-icon>
+            Index
+            <span class="ml-1 grey--text">({{ page.datasets.value.length }})</span>
+          </v-btn>
+        </v-btn-toggle>
+        <v-spacer />
+      </div>
+
+      <v-alert
+        v-if="page.error.value"
+        dense
+        dismissible
+        type="error"
+        class="mx-2 my-1"
+        @input="page.clearError()"
+      >
+        {{ page.error.value }}
+      </v-alert>
+
+      <div class="query-body px-2 pb-2 pt-2">
+        <QueryDatasetsPanel
+          v-if="view === 'datasets'"
+          :page="page"
+          @open-dataset="openViewer"
+        />
+        <template v-else>
+          <div
+            v-if="page.installed.value === false"
+            class="d-flex flex-column align-center justify-center fill-height grey--text"
+          >
+            Video search tools were not found in the VIAME install.
+          </div>
+          <div
+            v-else-if="page.indexedIds.value.length === 0 && page.mode.value !== 'text'"
+            class="d-flex flex-column align-center justify-center fill-height grey--text"
+          >
+            <div class="mb-3">
+              No searchable indices are available. Select one or more on the Index panel.
+            </div>
+            <v-btn
+              small
+              outlined
+              @click="view = 'datasets'"
+            >
+              Index
+            </v-btn>
+          </div>
+          <div
+            v-else
+            class="query-layout"
+          >
+            <!-- Query controls -->
+            <div class="query-controls">
+              <div class="d-flex align-center mb-2">
+                <v-btn-toggle
+                  :value="view"
+                  mandatory
+                  dense
+                  class="mr-3"
+                  @change="view = $event"
+                >
+                  <v-btn
+                    small
+                    value="query"
+                  >
+                    <v-icon
+                      small
+                      left
+                    >
+                      mdi-image-search-outline
+                    </v-icon>
+                    Query
+                  </v-btn>
+                  <v-btn
+                    small
+                    value="datasets"
+                  >
+                    <v-icon
+                      small
+                      left
+                    >
+                      mdi-database
+                    </v-icon>
+                    Index
+                    <span class="ml-1 grey--text">({{ page.datasets.value.length }})</span>
+                  </v-btn>
+                </v-btn-toggle>
+              </div>
+              <div class="d-flex align-center flex-wrap mb-3 mode-row">
+                <v-btn-toggle
+                  :value="page.mode.value"
+                  mandatory
+                  dense
+                  class="mr-3"
+                  @change="page.mode.value = $event"
+                >
+                  <v-btn
+                    small
+                    value="image"
+                  >
+                    Image
+                  </v-btn>
+                  <v-btn
+                    small
+                    value="video"
+                  >
+                    Video
+                  </v-btn>
+                  <v-btn
+                    small
+                    value="text"
+                  >
+                    Text
+                  </v-btn>
+                </v-btn-toggle>
+                <span class="text-caption grey--text">
+                  {{ page.indexedIds.value.length }} of {{ page.datasets.value.length }} indexed
+                </span>
+              </div>
+              <template v-if="page.mode.value === 'image'">
+                <div class="text-subtitle-2 mb-1">
+                  Search from an image
+                </div>
+                <div class="text-caption grey--text mb-2">
+                  Pick an exemplar image; drag a box on it to search for one object, or leave it to search for the whole image.
+                </div>
+                <v-btn
+                  small
+                  outlined
+                  class="mb-2"
+                  @click="pickImage"
+                >
+                  <v-icon
+                    small
+                    left
+                  >
+                    mdi-image
+                  </v-icon>
+                  {{ page.imagePath.value ? 'Change image' : 'Choose image…' }}
+                </v-btn>
+                <QueryExemplar
+                  v-if="imageUrl"
+                  :src="imageUrl"
+                  :box="page.imageBox.value"
+                  @update:box="page.imageBox.value = $event"
+                />
+                <div class="text-caption text-truncate grey--text mt-1">
+                  {{ page.imagePath.value }}
+                </div>
+                <v-btn
+                  small
+                  depressed
+                  color="primary"
+                  class="mt-2"
+                  :disabled="!page.imagePath.value || !page.canSearch.value"
+                  :loading="!!page.search.state.busy"
+                  @click="page.runImageQuery()"
+                >
+                  <v-icon
+                    small
+                    left
+                  >
+                    mdi-magnify
+                  </v-icon>
+                  Search {{ page.indexedIds.value.length }} indexed datasets
+                </v-btn>
+              </template>
+
+              <template v-else-if="page.mode.value === 'video'">
+                <div class="text-subtitle-2 mb-1">
+                  Search from a video frame
+                </div>
+                <v-btn-toggle
+                  :value="page.video.kind"
+                  mandatory
+                  dense
+                  class="mb-2"
+                  @change="page.video.kind = $event; page.videoFramePath.value = ''"
+                >
+                  <v-btn
+                    small
+                    value="dataset"
+                  >
+                    A dataset
+                  </v-btn>
+                  <v-btn
+                    small
+                    value="file"
+                  >
+                    A video file
+                  </v-btn>
+                </v-btn-toggle>
+                <v-select
+                  v-if="page.video.kind === 'dataset'"
+                  :value="page.video.datasetId"
+                  :items="datasetChoices"
+                  label="Dataset"
+                  dense
+                  outlined
+                  hide-details
+                  class="mb-2"
+                  @change="page.video.datasetId = $event; page.videoFramePath.value = ''"
+                />
+                <div
+                  v-else
+                  class="mb-2"
+                >
+                  <v-btn
+                    small
+                    outlined
+                    @click="pickVideoFile"
+                  >
+                    <v-icon
+                      small
+                      left
+                    >
+                      mdi-video
+                    </v-icon>
+                    {{ page.video.filePath ? 'Change video' : 'Choose video…' }}
+                  </v-btn>
+                  <div class="text-caption text-truncate grey--text mt-1">
+                    {{ page.video.filePath }}
+                  </div>
+                </div>
+                <div class="d-flex align-center mb-2">
+                  <v-text-field
+                    :value="page.video.frame"
+                    type="number"
+                    min="0"
+                    step="1"
+                    label="Frame"
+                    dense
+                    outlined
+                    hide-details
+                    class="frame-field mr-2"
+                    @change="page.video.frame = Math.max(0, Number($event) || 0); page.videoFramePath.value = ''"
+                  />
+                  <v-btn
+                    small
+                    outlined
+                    @click="page.previewVideoFrame()"
+                  >
+                    Show frame
+                  </v-btn>
+                </div>
+                <QueryExemplar
+                  v-if="videoFrameUrl"
+                  :src="videoFrameUrl"
+                  :box="page.videoFrameBox.value"
+                  @update:box="page.videoFrameBox.value = $event"
+                />
+                <div
+                  v-else
+                  class="text-caption grey--text"
+                >
+                  Show the frame, then drag a box on it to search for one object (or search the whole frame).
+                </div>
+                <v-btn
+                  small
+                  depressed
+                  color="primary"
+                  class="mt-2"
+                  :disabled="!page.canSearch.value || (page.video.kind === 'dataset' ? !page.video.datasetId : !page.video.filePath)"
+                  :loading="!!page.search.state.busy"
+                  @click="page.runVideoQuery()"
+                >
+                  <v-icon
+                    small
+                    left
+                  >
+                    mdi-magnify
+                  </v-icon>
+                  Search {{ page.indexedIds.value.length }} indexed datasets
+                </v-btn>
+              </template>
+
+              <template v-else>
+                <div class="text-subtitle-2 mb-1">
+                  Search by text
+                </div>
+                <div class="text-caption grey--text mb-2">
+                  Describe what to find. Sampled frames of every listed dataset are searched with the SAM3 text model;
+                  hits can then seed a similarity search over the index.
+                </div>
+                <v-alert
+                  v-if="page.sam3Installed.value === false"
+                  dense
+                  text
+                  type="warning"
+                  class="mb-2"
+                >
+                  The SAM3 add-on was not found in the VIAME install; text queries need it.
+                </v-alert>
+                <v-text-field
+                  v-model="page.text.prompt"
+                  label="What to find (e.g. fish, diver, net)"
+                  dense
+                  outlined
+                  hide-details
+                  class="mb-2"
+                  @keydown.enter="page.runTextQuery()"
+                />
+                <div class="d-flex flex-wrap text-fields mb-2">
+                  <v-text-field
+                    v-model.number="page.text.threshold"
+                    type="number"
+                    min="0"
+                    max="1"
+                    step="0.05"
+                    label="Min score"
+                    dense
+                    outlined
+                    hide-details
+                  />
+                  <v-text-field
+                    v-model.number="page.text.maxPerFrame"
+                    type="number"
+                    min="1"
+                    step="1"
+                    label="Hits per frame"
+                    dense
+                    outlined
+                    hide-details
+                  />
+                  <v-text-field
+                    v-model.number="page.text.stride"
+                    type="number"
+                    min="1"
+                    step="1"
+                    label="Every N frames"
+                    dense
+                    outlined
+                    hide-details
+                  />
+                  <v-text-field
+                    v-model.number="page.text.maxFrames"
+                    type="number"
+                    min="1"
+                    step="1"
+                    label="Frames per dataset"
+                    dense
+                    outlined
+                    hide-details
+                  />
+                </div>
+                <v-btn
+                  small
+                  depressed
+                  color="primary"
+                  :disabled="!page.text.prompt.trim() || page.textProgress.running || page.sam3Installed.value === false"
+                  :loading="page.textProgress.running"
+                  @click="page.runTextQuery()"
+                >
+                  <v-icon
+                    small
+                    left
+                  >
+                    mdi-text-search
+                  </v-icon>
+                  Search {{ page.datasets.value.length }} datasets
+                </v-btn>
+              </template>
+
+              <div class="mt-4">
+                <v-switch
+                  v-if="page.mode.value !== 'text'"
+                  v-model="page.onlySelected.value"
+                  dense
+                  hide-details
+                  label="Only results from the listed datasets"
+                  class="mt-0"
+                />
+                <div
+                  v-if="page.mode.value !== 'text'"
+                  class="text-caption grey--text mt-2"
+                >
+                  <span v-if="page.warmStartModel.value">Warm start model: {{ page.warmStartModel.value }}</span>
+                  <a
+                    class="ml-1"
+                    @click="pickModel"
+                  >{{ page.warmStartModel.value ? 'change' : 'Start from a saved model…' }}</a>
+                  <a
+                    v-if="page.warmStartModel.value"
+                    class="ml-1"
+                    @click="page.warmStartModel.value = ''"
+                  >clear</a>
+                </div>
+              </div>
+            </div>
+
+            <!-- Results -->
+            <div class="query-results">
+              <VideoSearchResultsGrid
+                v-if="page.mode.value !== 'text'"
+                inline
+                :search-chips="searchChips"
+                :search-review="searchReview"
+                :memory="resultsMemory"
+                @open-result="openViewer"
+                @save-model="saveModel"
+              />
+              <v-card
+                v-else
+                flat
+                class="text-results d-flex flex-column"
+              >
+                <v-toolbar
+                  dense
+                  flat
+                  color="grey darken-4"
+                  class="flex-grow-0"
+                >
+                  <v-toolbar-title class="text-subtitle-1">
+                    Text Query Hits
+                  </v-toolbar-title>
+                  <v-spacer />
+                  <span
+                    v-if="page.textProgress.running"
+                    class="text-caption mr-3"
+                  >
+                    {{ page.textProgress.done }} / {{ page.textProgress.total }} frames
+                  </span>
+                  <v-btn
+                    small
+                    outlined
+                    :disabled="!page.textProgress.running"
+                    @click="page.cancelTextQuery()"
+                  >
+                    Stop
+                  </v-btn>
+                </v-toolbar>
+                <ReviewGridControls
+                  :grid="gridSettings"
+                  :page="textGrid.page.value"
+                  :page-count="textGrid.pageCount.value"
+                  :count-label="textCountLabel"
+                  :can-zoom-in="textGrid.canZoomIn.value"
+                  :can-zoom-out="textGrid.canZoomOut.value"
+                  @update:page="textGrid.goToPage"
+                  @set-columns="textGrid.setColumns"
+                  @set-rows="textGrid.setRows"
+                  @set-padding="textGrid.setPadding"
+                  @zoom="textGrid.zoom"
+                />
+                <v-progress-linear
+                  v-if="page.textProgress.running"
+                  :value="page.textProgress.total ? (100 * page.textProgress.done) / page.textProgress.total : 0"
+                  class="flex-grow-0"
+                />
+                <div
+                  v-if="page.textHits.value.length === 0"
+                  class="d-flex align-center justify-center flex-grow-1 grey--text"
+                >
+                  {{ page.textProgress.running ? 'Searching…' : 'No text query hits to review.' }}
+                </div>
+                <div
+                  v-else
+                  class="text-results-body flex-grow-1 pa-2"
+                >
+                  <ReviewGrid
+                    :columns="gridSettings.columns"
+                    :rows="gridSettings.rows"
+                    @cell-size="textGrid.cellSize.value = $event"
+                  >
+                    <ReviewCell
+                      v-for="cell in textCells"
+                      :key="cell.item.key"
+                      :src="textChips.chips.value[cell.item.key] || null"
+                      :transform="textChips.store.transforms.value[cell.item.key] || null"
+                      :frames="cell.item.frames"
+                      :failure="textChips.store.failures.value[cell.item.key] || null"
+                      :animate="false"
+                      :type="cell.item.type"
+                      :confidence="cell.item.confidence"
+                      :title="cell.title"
+                      :subtitle="cell.subtitle"
+                      :editable="false"
+                      :deletable="false"
+                      @open="openViewer(cell.item.datasetId, cell.item.primary.frame)"
+                    >
+                      <template #actions>
+                        <v-btn
+                          icon
+                          small
+                          class="cell-action"
+                          title="Search the index for objects like this one"
+                          :disabled="!page.canSearch.value"
+                          @click.stop="searchSimilar(cell.item)"
+                        >
+                          <v-icon color="grey lighten-1">
+                            mdi-magnify-scan
+                          </v-icon>
+                        </v-btn>
+                        <v-btn
+                          icon
+                          small
+                          class="cell-action"
+                          title="Open in the annotation viewer at this frame"
+                          @click.stop="openViewer(cell.item.datasetId, cell.item.primary.frame)"
+                        >
+                          <v-icon color="grey lighten-1">
+                            mdi-open-in-new
+                          </v-icon>
+                        </v-btn>
+                      </template>
+                    </ReviewCell>
+                  </ReviewGrid>
+                </div>
+              </v-card>
+            </div>
+          </div>
+        </template>
+      </div>
+    </div>
+    <v-dialog
+      :value="overlapDialog !== null"
+      max-width="640"
+      persistent
+    >
+      <v-card v-if="overlapDialog">
+        <v-card-title style="word-break: normal;">
+          Results overlap existing annotations
+        </v-card-title>
+        <v-card-text>
+          {{ overlapDialog.overlapping }} of the {{ overlapDialog.total }} result{{ overlapDialog.total === 1 ? '' : 's' }}
+          to save overlap{{ overlapDialog.overlapping === 1 ? 's' : '' }} annotations already in
+          {{ overlapDialog.datasetIds.map((id) => page.datasetName(id)).join(', ') }}. How should they be saved?
+        </v-card-text>
+        <div class="overlap-grid pa-4">
+          <div
+            v-for="option in overlapOptions"
+            :key="option.choice"
+            class="overlap-option text-center"
+          >
+            <v-btn
+              depressed
+              block
+              :color="option.choice === 'discard' ? 'error' : 'primary'"
+              @click="chooseOverlap(option.choice)"
+            >
+              {{ option.label }}
+            </v-btn>
+            <div class="text-caption grey--text mt-1">
+              {{ option.hint }}
+            </div>
+          </div>
+        </div>
+      </v-card>
+    </v-dialog>
+  </v-main>
+</template>
+
+<style lang="scss" scoped>
+.query-page {
+  position: absolute;
+  inset: 0;
+  display: flex;
+  flex-direction: column;
+  min-height: 0;
+  min-width: 0;
+}
+
+.query-toolbar {
+  flex: 0 0 auto;
+  gap: 4px 0;
+}
+
+.mode-row {
+  gap: 4px 0;
+}
+
+.query-body {
+  flex: 1 1 auto;
+  min-height: 0;
+  position: relative;
+  overflow: auto;
+}
+
+.query-layout {
+  display: flex;
+  height: 100%;
+  min-height: 0;
+  gap: 12px;
+}
+
+.query-controls {
+  flex: 0 0 340px;
+  min-width: 0;
+  overflow: auto;
+  padding: 8px;
+  border: 1px solid #333;
+  border-radius: 4px;
+}
+
+.query-results {
+  flex: 1 1 auto;
+  min-width: 0;
+  min-height: 0;
+  border: 1px solid #333;
+  border-radius: 4px;
+  overflow: hidden;
+}
+
+.text-results {
+  height: 100%;
+  min-height: 0;
+}
+
+.text-results-body {
+  min-height: 0;
+  overflow: hidden;
+}
+
+.frame-field {
+  max-width: 140px;
+}
+
+.overlap-grid {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 12px 16px;
+  justify-items: center;
+}
+
+.overlap-option {
+  width: 100%;
+  max-width: 280px;
+}
+
+.text-fields {
+  gap: 8px;
+
+  .v-input {
+    flex: 1 1 120px;
+  }
+}
+</style>
diff --git a/client/platform/desktop/frontend/components/Recent.vue b/client/platform/desktop/frontend/components/Recent.vue
index ecdca6f55..8a8d4ad4f 100644
--- a/client/platform/desktop/frontend/components/Recent.vue
+++ b/client/platform/desktop/frontend/components/Recent.vue
@@ -273,6 +273,10 @@ export default defineComponent({
     function reviewSelected() {
       router.push({ name: 'review', query: selectedIdsQuery() });
     }
+
+    function indexSelected() {
+      router.push({ name: 'query', query: { ...selectedIdsQuery(), view: 'datasets' } });
+    }
     function getTypeIcon(recent: JsonConfigCache) {
       if (recent.subType) {
         if (recent.subType === 'stereo') {
@@ -369,6 +373,7 @@ export default defineComponent({
       runTrainingOnSelected,
       scoreSelected,
       reviewSelected,
+      indexSelected,
       isSelected,
       toggleSelected,
       toggleSelectAll,
@@ -633,7 +638,7 @@ export default defineComponent({
                       >
                         mdi-brain
                       </v-icon>
-                      Run Training
+                      Training
                     </v-btn>
                   </template>
                   <span>Train a model on the selected datasets</span>
@@ -646,18 +651,18 @@ export default defineComponent({
                       outlined
                       small
                       v-on="on"
-                      @click="scoreSelected"
+                      @click="indexSelected"
                     >
                       <v-icon
                         left
                         small
                       >
-                        mdi-chart-box-outline
+                        mdi-database-plus
                       </v-icon>
-                      Score
+                      Index
                     </v-btn>
                   </template>
-                  <span>Score the selected datasets against ground truth</span>
+                  <span>Build search indexes for the selected datasets</span>
                 </v-tooltip>
                 <v-tooltip bottom>
                   <template #activator="{ on }">
@@ -680,6 +685,27 @@ export default defineComponent({
                   </template>
                   <span>Review the selected datasets' annotations as a grid</span>
                 </v-tooltip>
+                <v-tooltip bottom>
+                  <template #activator="{ on }">
+                    <v-btn
+                      class="ml-2 align-self-center"
+                      color="primary"
+                      outlined
+                      small
+                      v-on="on"
+                      @click="scoreSelected"
+                    >
+                      <v-icon
+                        left
+                        small
+                      >
+                        mdi-chart-box-outline
+                      </v-icon>
+                      Score
+                    </v-btn>
+                  </template>
+                  <span>Score the selected datasets against ground truth</span>
+                </v-tooltip>
                 <v-tooltip bottom>
                   <template #activator="{ on }">
                     <v-btn
diff --git a/client/platform/desktop/frontend/components/VideoSearchContext.spec.ts b/client/platform/desktop/frontend/components/VideoSearchContext.spec.ts
new file mode 100644
index 000000000..e50c80ee8
--- /dev/null
+++ b/client/platform/desktop/frontend/components/VideoSearchContext.spec.ts
@@ -0,0 +1,84 @@
+// @vitest-environment jsdom
+import { shallowMount } from '@vue/test-utils';
+import { reactive, ref } from 'vue';
+import { videoSearchListIndexes } from '../api';
+import VideoSearchContext from './VideoSearchContext.vue';
+import { takeQueryLaunch } from '../queryLaunch';
+
+const mocks = vi.hoisted(() => ({ search: null as unknown, push: vi.fn(async (location: unknown) => location) }));
+vi.mock('vue-router/composables', () => ({ useRouter: () => ({ push: mocks.push }) }));
+vi.mock('../api', () => ({ videoSearchListIndexes: vi.fn() }));
+vi.mock('../useVideoSearch', () => ({ useVideoSearch: () => mocks.search }));
+vi.mock('../useSearchChips', () => ({ createSearchChips: () => ({ chips: ref({}), dispose: vi.fn() }) }));
+vi.mock('../store/jobs', () => ({ runningJobs: ref([]) }));
+vi.mock('dive-common/vue-utilities/prompt-service', () => ({ usePrompt: () => ({ prompt: vi.fn() }) }));
+vi.mock('vue-media-annotator/provides', () => ({
+  useCameraStore: () => ({}),
+  useHandler: () => ({}),
+  useSelectedCamera: () => ref('left'),
+  useSelectedTrackId: () => ref(null),
+  useTime: () => ({ frame: ref(0) }),
+}));
+vi.mock('./VideoSearchResultsGrid.vue', () => ({ default: {} }));
+
+it.each([0, 2])('offers index creation on the Query Datasets page with %s indexes', async (count) => {
+  mocks.search = {
+    datasetId: 'current-sequence',
+    state: reactive({
+      installed: true, status: { datasetCount: count }, results: [], busy: null, selectedStream: null,
+    }),
+    refreshStatus: vi.fn(),
+    selectIndex: vi.fn(),
+  };
+  vi.mocked(videoSearchListIndexes).mockResolvedValue([
+    {
+      name: 'Alpha', datasetId: 'a', streamName: 'a-stream', method: 'detections',
+    },
+    {
+      name: 'Beta', datasetId: 'b', streamName: 'b-stream', method: 'detections',
+    },
+  ]);
+  const wrapper = shallowMount(VideoSearchContext, { stubs: ['v-btn', 'v-select', 'v-divider', 'v-dialog', 'v-card', 'v-card-title', 'v-card-text', 'v-card-actions', 'v-text-field', 'v-spacer'] });
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  const link = wrapper.findAll('v-btn-stub').wrappers.find((button) => button.text().includes(count ? 'Build a new index' : 'Create index'));
+  expect(link).toBeDefined();
+  expect((wrapper.vm as unknown as { buildLocation: unknown }).buildLocation).toEqual({
+    name: 'query', query: { datasetIds: 'current-sequence', view: 'datasets' },
+  });
+  expect(wrapper.findAll('v-select-stub').length).toBe(count ? 1 : 0);
+  expect(wrapper.text()).not.toContain('Add to index');
+  expect(wrapper.text()).not.toContain('Remove');
+  if (count) {
+    expect((wrapper.vm as unknown as { indexChoices: unknown }).indexChoices).toEqual([
+      { text: 'All indexed sequences', value: '' },
+      { text: 'Alpha', value: 'a-stream' },
+      { text: 'Beta', value: 'b-stream' },
+    ]);
+  } else expect(wrapper.text()).toContain('No search index is available yet');
+  wrapper.destroy();
+});
+
+it('launches an image query on the Query page without querying or rendering results in the sidebar', async () => {
+  const queryFromImage = vi.fn();
+  mocks.search = {
+    datasetId: 'current',
+    state: reactive({
+      installed: true, status: { datasetCount: 1 }, selectedStream: 'a-stream', results: [], busy: null,
+    }),
+    refreshStatus: vi.fn(),
+    selectIndex: vi.fn(),
+    queryFromImage,
+  };
+  window.diveDesktop = { showOpenDialog: vi.fn(async () => ({ canceled: false, filePaths: ['/image.jpg'] })) } as never;
+  const wrapper = shallowMount(VideoSearchContext, { stubs: ['v-btn', 'v-select', 'v-divider', 'v-alert', 'v-progress-linear'] });
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  await (wrapper.vm as unknown as { queryFromImageFile(): Promise<void> }).queryFromImageFile();
+  const location = mocks.push.mock.calls.at(-1)?.[0] as unknown as { name: string; query: { launch: string } };
+  expect(location.name).toBe('query');
+  expect(takeQueryLaunch(location.query.launch)).toMatchObject({ imagePath: '/image.jpg', streamName: 'a-stream' });
+  expect(takeQueryLaunch(location.query.launch)).toBeUndefined();
+  expect(queryFromImage).not.toHaveBeenCalled();
+  expect(wrapper.find('.results-list').exists()).toBe(false);
+  expect(wrapper.findAll('.query-launch-button')).toHaveLength(3);
+  wrapper.destroy();
+});
diff --git a/client/platform/desktop/frontend/components/VideoSearchContext.vue b/client/platform/desktop/frontend/components/VideoSearchContext.vue
new file mode 100644
index 000000000..59c4162d6
--- /dev/null
+++ b/client/platform/desktop/frontend/components/VideoSearchContext.vue
@@ -0,0 +1,257 @@
+<script lang="ts">
+import {
+  computed, defineComponent, onMounted, ref, watch,
+} from 'vue';
+import {
+  useCameraStore,
+  useSelectedCamera,
+  useSelectedTrackId,
+  useTime,
+} from 'vue-media-annotator/provides';
+import type { VideoSearchIndexInfo } from 'dive-common/apispec';
+import { isNavigationFailure } from 'vue-router';
+import { useRouter } from 'vue-router/composables';
+import { videoSearchListIndexes } from 'platform/desktop/frontend/api';
+import { runningJobs } from 'platform/desktop/frontend/store/jobs';
+import { useVideoSearch } from 'platform/desktop/frontend/useVideoSearch';
+import { holdQueryLaunch, takeQueryLaunch, QueryLaunch } from '../queryLaunch';
+
+export default defineComponent({
+  name: 'VideoSearchContext',
+  description: 'Video Search',
+  setup() {
+    const search = useVideoSearch();
+    const router = useRouter();
+    const launching = ref(false);
+    const { frame } = useTime();
+    const selectedTrackId = useSelectedTrackId();
+    const selectedCamera = useSelectedCamera();
+    const cameraStore = useCameraStore();
+
+    const indexes = ref<VideoSearchIndexInfo[]>([]);
+    const indexChoices = computed(() => [
+      { text: 'All indexed sequences', value: '' },
+      ...indexes.value.map((index) => ({ text: index.name, value: index.streamName })),
+    ]);
+    const buildLocation = computed(() => ({
+      name: 'query', query: { datasetIds: search?.datasetId || '', view: 'datasets' },
+    }));
+    async function refreshIndexes() {
+      if (!search) return;
+      await search.refreshStatus();
+      try {
+        indexes.value = search.state.status?.datasetCount ? await videoSearchListIndexes() : [];
+        if (search.state.selectedStream && !indexes.value.some((index) => index.streamName === search.state.selectedStream)) {
+          search.selectIndex(null);
+        }
+      } catch (err) { search.state.error = (err as Error).message; }
+    }
+    const state = computed(() => search?.state ?? null);
+
+    /** Any completed index build can add a new choice to the shared database. */
+    watch(runningJobs, (current, previous) => {
+      if (!search) return;
+      const finished = previous.some((item) => (
+        /search index/i.test(item.job.title)
+        && !current.some((c) => c.job.key === item.job.key)
+      ));
+      if (finished) {
+        refreshIndexes();
+      }
+    });
+
+    // Note there is deliberately no unmount cleanup: the session stays open
+    // because re-opening (postgres + descriptor load) is expensive and the
+    // panel may just be toggled. The session closes with the app or when
+    // another dataset's index opens.
+    onMounted(() => {
+      if (search) {
+        refreshIndexes();
+      }
+    });
+
+    /** The selected track's bounding box on the current frame, if any. */
+    const selectedTrackBox = computed(() => {
+      if (!search || selectedTrackId.value === null) return null;
+      try {
+        const track = cameraStore.getTrack(selectedTrackId.value, selectedCamera.value);
+        const [real] = track.getFeature(frame.value);
+        if (real && real.bounds) {
+          return real.bounds as [number, number, number, number];
+        }
+      } catch {
+        return null;
+      }
+      return null;
+    });
+
+    async function queryFromSelectedTrack() {
+      if (!search || !selectedTrackBox.value) return;
+      launching.value = true;
+      try {
+        const box = [...selectedTrackBox.value] as [number, number, number, number];
+        const imagePath = await search.exemplarImageForFrame(frame.value);
+        await launchQuery({ imagePath, box, streamName: search.state.selectedStream });
+      } catch (err) { search.state.error = (err as Error).message; } finally { launching.value = false; }
+    }
+
+    async function queryFromImageFile(warmStart = false) {
+      if (!search) return;
+      let modelPath: string | undefined;
+      if (warmStart) {
+        const modelRet = await window.diveDesktop.showOpenDialog({
+          properties: ['openFile'],
+          filters: [
+            { name: 'SVM Models', extensions: ['svm'] },
+            { name: 'All Files', extensions: ['*'] },
+          ],
+        });
+        if (modelRet.canceled || !modelRet.filePaths?.length) return;
+        [modelPath] = modelRet.filePaths;
+      }
+      const ret = await window.diveDesktop.showOpenDialog({
+        properties: ['openFile'],
+        filters: [
+          { name: 'Images', extensions: ['jpg', 'jpeg', 'png', 'bmp', 'tif', 'tiff'] },
+          { name: 'All Files', extensions: ['*'] },
+        ],
+      });
+      if (ret.canceled || !ret.filePaths?.length) return;
+      await launchQuery({ imagePath: ret.filePaths[0], modelPath, streamName: search.state.selectedStream });
+    }
+
+    async function launchQuery(launch: QueryLaunch) {
+      launching.value = true;
+      const key = holdQueryLaunch(launch);
+      try {
+        await router.push({ name: 'query', query: { launch: key } });
+      } catch (err) {
+        takeQueryLaunch(key);
+        if (search && !isNavigationFailure(err)) search.state.error = (err as Error).message;
+      } finally { launching.value = false; }
+    }
+
+    return {
+      search,
+      state,
+      indexes,
+      indexChoices,
+      buildLocation,
+      selectedTrackBox,
+      launching,
+      queryFromSelectedTrack,
+      queryFromImageFile,
+
+    };
+  },
+});
+</script>
+
+<template>
+  <div class="video-search-context pa-2">
+    <div v-if="!search || !state">
+      <v-alert type="info" dense text>
+        Video search is unavailable for this dataset.
+      </v-alert>
+    </div>
+    <div v-else-if="state.installed === false">
+      <v-alert type="warning" dense text>
+        This VIAME install does not include the video search components
+        (query pipeline and database tools).
+      </v-alert>
+    </div>
+    <div v-else>
+      <div class="text-subtitle-2 mb-2">
+        Search Index
+      </div>
+      <v-select
+        v-if="indexes.length"
+        :value="state.selectedStream || ''"
+        :items="indexChoices"
+        :disabled="!!state.busy"
+        dense
+        outlined
+        hide-details
+        label="Index to search"
+        class="mb-2"
+        @change="search.selectIndex($event || null)"
+      />
+      <div v-else class="text-caption mb-2">
+        No search index is available yet.
+      </div>
+      <v-btn small text color="primary" :to="buildLocation" class="mb-3">
+        {{ indexes.length ? 'Build a new index' : 'Create index' }}
+      </v-btn>
+      <v-divider class="mb-2" />
+
+      <!-- Query formulation -->
+      <div class="text-subtitle-2 mb-1">
+        Query
+      </div>
+      <div class="mb-3">
+        <v-btn
+          large
+          block
+          class="query-launch-button mb-3"
+          color="primary"
+          :disabled="!indexes.length || selectedTrackBox === null || !!state.busy || launching"
+          @click="queryFromSelectedTrack"
+        >
+          Search from<br>selected annotation
+        </v-btn>
+        <v-btn
+          large
+          block
+          class="query-launch-button mb-3"
+          :disabled="!indexes.length || !!state.busy || launching"
+          @click="queryFromImageFile(false)"
+        >
+          Search from<br>image file...
+        </v-btn>
+        <v-btn
+          large
+          block
+          class="query-launch-button mb-3"
+          :disabled="!indexes.length || !!state.busy || launching"
+          @click="queryFromImageFile(true)"
+        >
+          Search with<br>saved model (.svm)...
+        </v-btn>
+      </div>
+
+      <v-progress-linear
+        v-if="state.busy"
+        indeterminate
+        class="mb-2"
+      />
+      <div v-if="state.busy" class="text-caption mb-2">
+        {{ state.busy }}
+      </div>
+      <v-alert
+        v-if="state.error"
+        type="error"
+        dense
+        text
+        class="text-caption"
+      >
+        {{ state.error }}
+      </v-alert>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.query-launch-button {
+  min-height: 64px;
+  height: auto !important;
+  padding: 12px 8px !important;
+  font-size: 12.5px;
+  letter-spacing: 0.02em;
+}
+.query-launch-button ::v-deep .v-btn__content {
+  display: block;
+  text-align: center;
+  white-space: normal;
+  line-height: 1.4;
+}
+</style>
diff --git a/client/platform/desktop/frontend/components/VideoSearchResultsGrid.vue b/client/platform/desktop/frontend/components/VideoSearchResultsGrid.vue
new file mode 100644
index 000000000..87fc4165c
--- /dev/null
+++ b/client/platform/desktop/frontend/components/VideoSearchResultsGrid.vue
@@ -0,0 +1,546 @@
+<script lang="ts">
+import {
+  computed, defineComponent, onBeforeUnmount, PropType, ref, watch,
+} from 'vue';
+import { useHandler } from 'vue-media-annotator/provides';
+import { usePrompt } from 'dive-common/vue-utilities/prompt-service';
+import { useVideoSearch } from 'platform/desktop/frontend/useVideoSearch';
+import type { SearchChips } from 'platform/desktop/frontend/useSearchChips';
+import type { SearchReview } from 'platform/desktop/frontend/useSearchReview';
+import type { ResultsGridMemory } from 'platform/desktop/frontend/querySession';
+import { useReview } from 'dive-common/use/useReview';
+import type { ReviewService } from 'dive-common/use/useReview';
+import { usePersistentGridSettings } from 'dive-common/review/gridSettings';
+import { useReviewGrid } from 'dive-common/review/useReviewGrid';
+import type { ReviewItem } from 'dive-common/review/types';
+import type { VideoSearchResult } from 'dive-common/apispec';
+import ReviewGrid from 'dive-common/components/Review/ReviewGrid.vue';
+import ReviewGridControls from 'dive-common/components/Review/ReviewGridControls.vue';
+import ReviewCell, { ReviewCellGeometryEdit } from 'dive-common/components/Review/ReviewCell.vue';
+
+/** Footer height of a search cell (type field and caption), for the chip aspect ratio. */
+const SearchCellFooterPx = 48;
+
+/**
+ * Full-window review grid of ranked search results across every indexed
+ * video, for rapid adjudication: accept/reject each chip, then refine.
+ * Shares session state (and adjudications) with the Video Search side
+ * panel, and the grid shape, zoom, context and paging with the Review page.
+ * With a search review attached, cells are also editable annotations:
+ * typing a type or adjusting a box adopts the result into its dataset.
+ */
+export default defineComponent({
+  name: 'VideoSearchResultsGrid',
+  components: { ReviewGrid, ReviewGridControls, ReviewCell },
+  props: {
+    value: {
+      type: Boolean,
+      default: false,
+    },
+    searchChips: {
+      type: Object as PropType<SearchChips>,
+      required: true,
+    },
+    /**
+     * Render in place instead of as a full-window dialog (the Query page).
+     * Opening a result then emits `open-result` rather than seeking.
+     */
+    inline: {
+      type: Boolean,
+      default: false,
+    },
+    /** Lets results be typed, edited and deleted as annotations (needs a provided review service). */
+    searchReview: {
+      type: Object as PropType<SearchReview | null>,
+      default: null,
+    },
+    /** Grid page and filter to start from, kept up to date so a later visit resumes them. */
+    memory: {
+      type: Object as PropType<ResultsGridMemory | null>,
+      default: null,
+    },
+  },
+  setup(props, { emit }) {
+    const search = useVideoSearch();
+    // The annotator handler only exists inside the viewer.
+    const handler = props.inline ? null : useHandler();
+    const review: ReviewService | null = props.searchReview ? useReview() : null;
+    const { prompt } = usePrompt();
+    const gridSettings = usePersistentGridSettings();
+    const open = computed(() => props.inline || props.value);
+
+    const state = computed(() => search?.state ?? null);
+    const results = computed(() => state.value?.results ?? []);
+    const resultsByRef = computed(() => new Map(results.value.map((r) => [r.ref, r])));
+    const adjudications = computed(() => state.value?.adjudications ?? {});
+
+    const hideReviewed = ref(props.memory?.hideReviewed ?? false);
+    const reviewedCount = computed(() => props.searchChips.items.value
+      .filter((item) => adjudications.value[item.key]).length);
+    const visibleItems = computed(() => (hideReviewed.value
+      ? props.searchChips.items.value.filter((item) => !adjudications.value[item.key])
+      : props.searchChips.items.value));
+
+    const grid = useReviewGrid({
+      items: visibleItems,
+      grid: gridSettings,
+      chipStore: props.searchChips.store,
+      active: open,
+      footerPx: SearchCellFooterPx,
+      // The box is drawn over the chip so it follows edits.
+      outline: '',
+      retainPage: true,
+    });
+    watch(() => state.value?.queryGeneration, () => grid.goToPage(0));
+    if (props.memory) {
+      grid.goToPage(props.memory.page);
+      watch([grid.page, hideReviewed], ([page, hide]) => {
+        Object.assign(props.memory as ResultsGridMemory, { page, hideReviewed: hide });
+      });
+    }
+
+    const adjudicationCounts = computed(() => {
+      const counts = { positive: 0, negative: 0 };
+      Object.values(adjudications.value).forEach((adj) => {
+        if (adj) counts[adj] += 1;
+      });
+      return counts;
+    });
+
+    const cells = computed(() => {
+      // Carries dataRevision so type and box edits re-render.
+      const revision = review?.dataRevision.value ?? 0;
+      return grid.pageItems.value.map((item) => {
+        const result = resultsByRef.value.get(item.key);
+        const adopted = result && props.searchReview ? props.searchReview.itemOf(result) : undefined;
+        const current = adopted && review ? review.currentType(adopted) : null;
+        const datasetName = search && result ? search.resultDatasetName(result) : null;
+        const local = Boolean(search && result && search.resultIsLocal(result));
+        const bits = [`Frame ${item.primary.frame}`];
+        if (datasetName) bits.push(datasetName);
+        if (adopted) bits.push(`#${adopted.trackId}`);
+        const adjudication: '' | 'positive' | 'negative' = (result && adjudications.value[result.ref]) || '';
+        const type = current?.type ?? '';
+        return {
+          item,
+          result,
+          revision,
+          local,
+          adjudication,
+          adopted: adopted !== undefined,
+          type,
+          pending: adopted && review ? review.isPending(adopted) : false,
+          color: review ? review.colorFor(type) : '#00e5ff',
+          subtitle: bits.join(' · '),
+          title: `${datasetName || 'This dataset'} · frame ${item.primary.frame}`,
+        };
+      });
+    });
+
+    const countLabel = computed(() => {
+      const count = visibleItems.value.length;
+      const base = `${count} result${count === 1 ? '' : 's'}`;
+      return state.value?.iteration ? `${base} · iteration ${state.value.iteration}` : base;
+    });
+
+    function close() {
+      emit('input', false);
+    }
+
+    function onKeydown(event: KeyboardEvent) {
+      // Swallow paging keys before they bubble to document, where the
+      // annotator's mousetrap left/right bindings would seek the (hidden)
+      // playhead one frame per grid page turn.
+      if (grid.handleKeydown(event)) {
+        event.stopPropagation();
+      }
+    }
+    watch(open, (isOpen) => {
+      if (isOpen) {
+        window.addEventListener('keydown', onKeydown, true);
+      } else {
+        window.removeEventListener('keydown', onKeydown, true);
+      }
+    }, { immediate: true });
+    onBeforeUnmount(() => {
+      window.removeEventListener('keydown', onKeydown, true);
+      grid.dispose();
+    });
+
+    /** Jump the annotator to a result in the currently open dataset, or hand it up inline. */
+    function openItem(item: ReviewItem, frame?: number) {
+      const result = resultsByRef.value.get(item.key);
+      if (!search || !result) return;
+      const shown = frame ?? item.primary.frame;
+      if (props.inline) {
+        const datasetId = search.resultDatasetId(result);
+        const adopted = props.searchReview?.itemOf(result);
+        if (datasetId) emit('open-result', datasetId, shown, adopted?.trackId);
+        return;
+      }
+      if (!handler || !search.resultIsLocal(result)) return;
+      handler.seekFrame(shown);
+      close();
+    }
+
+    function mark(item: ReviewItem, adjudication: 'positive' | 'negative') {
+      search?.mark(item.key, adjudication);
+    }
+
+    function assign(result: VideoSearchResult | undefined, type: string) {
+      if (result && props.searchReview) props.searchReview.assignType(result, type);
+    }
+
+    function editGeometry(result: VideoSearchResult | undefined, edit: ReviewCellGeometryEdit) {
+      if (result && props.searchReview) props.searchReview.editGeometry(result, edit);
+    }
+
+    function remove(result: VideoSearchResult | undefined) {
+      if (result && props.searchReview) props.searchReview.remove(result);
+    }
+
+    async function discard() {
+      if (!props.searchReview || !props.searchReview.hasChanges.value) return;
+      const count = props.searchReview.changeCount.value;
+      const ok = await prompt({
+        title: 'Discard changes',
+        text: `Throw away ${count} unsaved annotation change${count === 1 ? '' : 's'} from the results?`,
+        confirm: true,
+      });
+      if (ok) await props.searchReview.discardAll();
+    }
+
+    function save() {
+      props.searchReview?.save();
+    }
+
+    return {
+      search,
+      state,
+      results,
+      review,
+      open,
+      gridSettings,
+      grid,
+      cells,
+      countLabel,
+      adjudicationCounts,
+      hideReviewed,
+      reviewedCount,
+      close,
+      openItem,
+      mark,
+      assign,
+      editGeometry,
+      remove,
+      discard,
+      save,
+    };
+  },
+});
+</script>
+
+<template>
+  <component
+    :is="inline ? 'div' : 'v-dialog'"
+    v-bind="inline ? {} : {
+      value, fullscreen: true, hideOverlay: true, transition: 'dialog-bottom-transition',
+    }"
+    :class="{ 'results-grid-inline': inline }"
+    @input="inline ? undefined : $emit('input', $event)"
+  >
+    <v-card
+      v-if="search && state"
+      class="results-grid-page d-flex flex-column"
+      :class="{ 'results-grid-page-inline': inline }"
+      :flat="inline"
+    >
+      <v-toolbar
+        dense
+        flat
+        color="grey darken-4"
+        class="flex-grow-0"
+      >
+        <v-toolbar-title class="text-subtitle-1">
+          Search Results
+        </v-toolbar-title>
+        <v-spacer />
+        <span class="text-caption mr-3">
+          <v-icon
+            small
+            color="success"
+          >
+            mdi-check-circle
+          </v-icon>
+          {{ adjudicationCounts.positive }}
+          <v-icon
+            small
+            color="error"
+            class="ml-2"
+          >
+            mdi-close-circle
+          </v-icon>
+          {{ adjudicationCounts.negative }}
+        </span>
+        <v-btn
+          small
+          color="primary"
+          :disabled="!!state.busy || (!adjudicationCounts.positive && !adjudicationCounts.negative)"
+          @click="search.refine()"
+        >
+          Refine
+        </v-btn>
+        <template v-if="review && searchReview">
+          <v-btn
+            small
+            outlined
+            class="ml-2"
+            :disabled="!searchReview.hasChanges.value || review.saving.value"
+            title="Throw away the unsaved annotation changes"
+            @click="discard"
+          >
+            Discard
+          </v-btn>
+          <v-btn
+            small
+            outlined
+            class="ml-2"
+            :disabled="!state.modelAvailable || !!state.busy"
+            title="Keep the refined classifier as a trained pipeline"
+            @click="$emit('save-model')"
+          >
+            <v-icon
+              small
+              left
+            >
+              mdi-content-save-outline
+            </v-icon>
+            Save model
+          </v-btn>
+          <v-btn
+            small
+            color="primary"
+            class="ml-2"
+            :disabled="!searchReview.hasChanges.value"
+            :loading="review.saving.value"
+            title="Save accepted and typed results as annotations of their datasets"
+            @click="save"
+          >
+            <v-icon
+              small
+              left
+            >
+              mdi-content-save
+            </v-icon>
+            Save Annotations<span
+              v-if="searchReview.changeCount.value"
+              class="ml-1"
+            >({{ searchReview.changeCount.value }})</span>
+          </v-btn>
+        </template>
+        <v-btn
+          v-if="!inline"
+          icon
+          class="ml-2"
+          @click="close"
+        >
+          <v-icon>mdi-close</v-icon>
+        </v-btn>
+      </v-toolbar>
+
+      <ReviewGridControls
+        :grid="gridSettings"
+        :page="grid.page.value"
+        :page-count="grid.pageCount.value"
+        :count-label="countLabel"
+        :can-zoom-in="grid.canZoomIn.value"
+        :can-zoom-out="grid.canZoomOut.value"
+        @update:page="grid.goToPage"
+        @set-columns="grid.setColumns"
+        @set-rows="grid.setRows"
+        @set-padding="grid.setPadding"
+        @zoom="grid.zoom"
+      >
+        <v-btn
+          small
+          :text="!hideReviewed"
+          :outlined="hideReviewed"
+          :color="hideReviewed ? 'primary' : undefined"
+          class="mr-2"
+          title="Hide the results already marked correct or incorrect"
+          @click="hideReviewed = !hideReviewed"
+        >
+          <v-icon
+            small
+            left
+          >
+            {{ hideReviewed ? 'mdi-eye-off' : 'mdi-eye-off-outline' }}
+          </v-icon>
+          Hide reviewed
+          <span
+            v-if="reviewedCount"
+            class="ml-1 grey--text"
+          >({{ reviewedCount }})</span>
+        </v-btn>
+      </ReviewGridControls>
+
+      <v-progress-linear
+        v-if="state.busy || (review && review.saving.value)"
+        indeterminate
+        class="flex-grow-0"
+      />
+      <v-alert
+        v-if="state.error"
+        type="error"
+        dense
+        text
+        class="ma-2 flex-grow-0"
+      >
+        {{ state.error }}
+      </v-alert>
+      <v-alert
+        v-if="searchReview && searchReview.error.value"
+        type="error"
+        dense
+        text
+        dismissible
+        class="ma-2 flex-grow-0"
+        @input="searchReview.clearError()"
+      >
+        {{ searchReview.error.value }}
+      </v-alert>
+      <v-alert
+        v-if="review && review.error.value"
+        type="error"
+        dense
+        text
+        dismissible
+        class="ma-2 flex-grow-0"
+        @input="review.clearError()"
+      >
+        {{ review.error.value }}
+      </v-alert>
+
+      <div
+        v-if="!cells.length"
+        class="d-flex align-center justify-center flex-grow-1 grey--text"
+      >
+        {{ results.length && hideReviewed ? 'Every result has been reviewed.' : 'No search results to review.' }}
+      </div>
+      <div
+        v-else
+        class="results-grid-body flex-grow-1 pa-2"
+      >
+        <ReviewGrid
+          :columns="gridSettings.columns"
+          :rows="gridSettings.rows"
+          @cell-size="grid.cellSize.value = $event"
+        >
+          <ReviewCell
+            v-for="cell in cells"
+            :key="cell.item.key"
+            :src="searchChips.chips.value[cell.item.key] || null"
+            :srcs="searchChips.store.sequences.value[cell.item.key] || null"
+            :transform="searchChips.store.transforms.value[cell.item.key] || null"
+            :transforms="searchChips.store.sequenceTransforms.value[cell.item.key] || null"
+            :frames="cell.item.frames"
+            :failure="searchChips.store.failures.value[cell.item.key] || null"
+            :animate="open"
+            :cycle-interval-ms="gridSettings.cycleIntervalMs"
+            :confidence="cell.item.confidence"
+            :frame-count="cell.item.keyframeCount"
+            :type="cell.type"
+            :type-options="review ? review.knownTypes.value : []"
+            :color="cell.color"
+            :pending="cell.pending"
+            :editable="!!searchReview"
+            :deletable="false"
+            :title="cell.title"
+            :subtitle="cell.subtitle"
+            :highlight="cell.adjudication"
+            @assign="assign(cell.result, $event)"
+            @open="openItem(cell.item, $event)"
+            @edit-geometry="editGeometry(cell.result, $event)"
+          >
+            <template #actions="{ beginEdit, frame }">
+              <v-btn
+                icon
+                small
+                class="chip-action"
+                color="success"
+                title="Mark as a correct match"
+                @click.stop="mark(cell.item, 'positive')"
+              >
+                <v-icon>
+                  {{ cell.adjudication === 'positive' ? 'mdi-check-circle' : 'mdi-check-circle-outline' }}
+                </v-icon>
+              </v-btn>
+              <v-btn
+                icon
+                small
+                class="chip-action"
+                color="error"
+                title="Mark as an incorrect match"
+                @click.stop="mark(cell.item, 'negative')"
+              >
+                <v-icon>
+                  {{ cell.adjudication === 'negative' ? 'mdi-close-circle' : 'mdi-close-circle-outline' }}
+                </v-icon>
+              </v-btn>
+              <v-btn
+                v-if="searchReview"
+                icon
+                small
+                class="chip-action"
+                title="Edit this frame's box as an annotation (or right click)"
+                @click.stop="beginEdit($event)"
+              >
+                <v-icon color="grey lighten-1">
+                  mdi-vector-square-edit
+                </v-icon>
+              </v-btn>
+              <v-btn
+                v-if="cell.adopted"
+                icon
+                small
+                class="chip-action"
+                title="Delete this annotation"
+                @click.stop="remove(cell.result)"
+              >
+                <v-icon color="red lighten-1">
+                  mdi-delete-outline
+                </v-icon>
+              </v-btn>
+              <v-btn
+                icon
+                small
+                class="chip-action"
+                title="Open in the annotation viewer at this frame (or double click)"
+                @click.stop="openItem(cell.item, frame)"
+              >
+                <v-icon color="grey lighten-1">
+                  mdi-open-in-new
+                </v-icon>
+              </v-btn>
+            </template>
+          </ReviewCell>
+        </ReviewGrid>
+      </div>
+    </v-card>
+  </component>
+</template>
+
+<style scoped>
+.results-grid-page {
+  height: 100vh;
+}
+.results-grid-inline,
+.results-grid-page-inline {
+  height: 100%;
+  min-height: 0;
+}
+.results-grid-body {
+  min-height: 0;
+  overflow: hidden;
+}
+</style>
diff --git a/client/platform/desktop/frontend/components/ViewerLoader.vue b/client/platform/desktop/frontend/components/ViewerLoader.vue
index efff85944..92ee9e89b 100644
--- a/client/platform/desktop/frontend/components/ViewerLoader.vue
+++ b/client/platform/desktop/frontend/components/ViewerLoader.vue
@@ -47,6 +47,10 @@ import Export from './Export.vue';
 import JobTab from './JobTab.vue';
 import AnnotationOtherMenu from './AnnotationOtherMenu.vue';
 import DatasetSourceInfo from './DatasetSourceInfo.vue';
+import VideoSearchContext from './VideoSearchContext.vue';
+import {
+  createVideoSearch, provideVideoSearch, VideoSearchMediaInfo,
+} from '../useVideoSearch';
 import { datasets, rememberAnnotation } from '../store/dataset';
 import { settings } from '../store/settings';
 import { runningJobs } from '../store/jobs';
@@ -63,6 +67,13 @@ function joinPath(base: string, file: string): string {
   return `${base.replace(/[\\/]+$/, '')}${sep}${file}`;
 }
 
+// Desktop-only context panel: registered here (not in the shared context
+// store) so the web build does not pick it up.
+context.register({
+  description: 'Video Search',
+  component: VideoSearchContext,
+});
+
 const buttonOptions = {
   outlined: true,
   color: 'grey lighten-1',
@@ -582,10 +593,31 @@ export default defineComponent({
       }
     }
 
+    /**
+     * Video Search / IQR session (index-backed similarity queries).
+     * Media info resolves lazily once metadata loads; multicam datasets are
+     * not yet supported (media stays null and the panel reports unavailable).
+     */
+    const videoSearchMedia = ref<VideoSearchMediaInfo | null>(null);
+    const videoSearch = createVideoSearch(props.id, () => videoSearchMedia.value);
+    provideVideoSearch(videoSearch);
+
     // Initialize segmentation when component is mounted
-    onMounted(() => {
+    onMounted(async () => {
       initializeSegmentation();
       refreshTextQueryAvailability();
+      try {
+        const meta = await loadConfig(props.id);
+        if (!meta.multiCamMedia) {
+          videoSearchMedia.value = {
+            type: meta.type,
+            fps: meta.fps,
+            getImagePath: buildImagePathGetter(meta),
+          };
+        }
+      } catch {
+        // Video search stays unavailable if metadata cannot load
+      }
     });
 
     /**
diff --git a/client/platform/desktop/frontend/queryItems.spec.ts b/client/platform/desktop/frontend/queryItems.spec.ts
new file mode 100644
index 000000000..1f7cdf573
--- /dev/null
+++ b/client/platform/desktop/frontend/queryItems.spec.ts
@@ -0,0 +1,34 @@
+import { textHitItem, textQueryFrames, textQueryHits } from './queryItems';
+
+describe('textQueryFrames', () => {
+  it('walks a known length at the stride and thins evenly past the cap', () => {
+    expect(textQueryFrames(10, 3, 100)).toEqual([0, 3, 6, 9]);
+    expect(textQueryFrames(100, 1, 5)).toEqual([0, 25, 50, 74, 99]);
+    expect(textQueryFrames(0, 1, 5)).toEqual([]);
+  });
+
+  it('takes the first frames at the stride when the length is unknown', () => {
+    expect(textQueryFrames(null, 10, 3)).toEqual([0, 10, 20]);
+  });
+});
+
+describe('text query hits', () => {
+  it('turns detections into keyed hits and single-frame grid items', () => {
+    const hits = textQueryHits('ds', 7, '/frames/7.png', [
+      {
+        box: [1, 2, 3, 4], score: 0.9, label: 'fish', polygon: [[1, 2], [3, 2], [3, 4]],
+      },
+      {
+        box: [5, 6, 7, 8], score: 0.4, label: 'fish', polygon: [[1, 2]],
+      },
+    ]);
+    expect(hits.map((h) => h.key)).toEqual(['text:ds#7#0', 'text:ds#7#1']);
+    expect(hits[1].polygon).toBeUndefined();
+    const item = textHitItem(hits[0]);
+    expect(item).toMatchObject({
+      key: 'text:ds#7#0', datasetId: 'ds', type: 'fish', confidence: 0.9,
+    });
+    expect(item.primary).toEqual({ frame: 7, bounds: [1, 2, 3, 4], polygons: [[[1, 2], [3, 2], [3, 4]]] });
+    expect(item.frames).toHaveLength(1);
+  });
+});
diff --git a/client/platform/desktop/frontend/queryItems.ts b/client/platform/desktop/frontend/queryItems.ts
new file mode 100644
index 000000000..c64db1f2a
--- /dev/null
+++ b/client/platform/desktop/frontend/queryItems.ts
@@ -0,0 +1,77 @@
+/**
+ * Pure helpers behind the Query page: which frames a text query visits and
+ * how its hits become review grid items.
+ */
+import type { TextQueryDetection } from 'dive-common/apispec';
+import type { ReviewItem, ReviewPolygon } from 'dive-common/review/types';
+
+/** One detection a text query found on a frame of a dataset. */
+export interface TextQueryHit {
+  key: string;
+  datasetId: string;
+  frame: number;
+  box: [number, number, number, number];
+  score: number;
+  label: string;
+  polygon?: ReviewPolygon;
+  /** Image the query ran on, reusable as an exemplar for a similarity search. */
+  imagePath: string;
+}
+
+/**
+ * Frames a text query visits in a dataset: every `stride`-th frame from the
+ * first, capped at `maxFrames` spread evenly when the dataset is long.
+ * `frameCount` null (unknown length, e.g. a video) yields `maxFrames` frames
+ * at the stride.
+ */
+export function textQueryFrames(frameCount: number | null, stride: number, maxFrames: number): number[] {
+  const step = Math.max(1, Math.round(stride));
+  const cap = Math.max(1, Math.round(maxFrames));
+  if (frameCount === null) {
+    return Array.from({ length: cap }, (_, i) => i * step);
+  }
+  const count = Math.max(0, Math.floor(frameCount));
+  if (count === 0) return [];
+  const strided: number[] = [];
+  for (let frame = 0; frame < count; frame += step) strided.push(frame);
+  if (strided.length <= cap) return strided;
+  // Too many: keep an even spread over the strided frames, ends included.
+  return Array.from({ length: cap }, (_, i) => strided[Math.round((i * (strided.length - 1)) / (cap - 1))]);
+}
+
+export function textQueryHits(
+  datasetId: string,
+  frame: number,
+  imagePath: string,
+  detections: readonly TextQueryDetection[],
+): TextQueryHit[] {
+  return detections.map((det, index) => ({
+    key: `text:${datasetId}#${frame}#${index}`,
+    datasetId,
+    frame,
+    box: det.box,
+    score: det.score,
+    label: det.label,
+    polygon: det.polygon && det.polygon.length >= 3 ? det.polygon : undefined,
+    imagePath,
+  }));
+}
+
+/** A grid item for a text query hit: one box on one frame. */
+export function textHitItem(hit: TextQueryHit): ReviewItem {
+  const primary = {
+    frame: hit.frame,
+    bounds: hit.box,
+    ...(hit.polygon ? { polygons: [hit.polygon] } : {}),
+  };
+  return {
+    key: hit.key,
+    datasetId: hit.datasetId,
+    trackId: -1,
+    primary,
+    frames: [primary],
+    keyframeCount: 1,
+    type: hit.label,
+    confidence: hit.score,
+  };
+}
diff --git a/client/platform/desktop/frontend/queryLaunch.ts b/client/platform/desktop/frontend/queryLaunch.ts
new file mode 100644
index 000000000..5c5454d0b
--- /dev/null
+++ b/client/platform/desktop/frontend/queryLaunch.ts
@@ -0,0 +1,22 @@
+/** One-shot handoff after the viewer's normal unsaved-change navigation guard. */
+export interface QueryLaunch {
+  imagePath: string;
+  box?: [number, number, number, number];
+  modelPath?: string;
+  streamName: string | null;
+}
+let serial = 0;
+const pending = new Map<string, QueryLaunch>();
+export function holdQueryLaunch(launch: QueryLaunch): string {
+  serial += 1;
+  const key = String(serial);
+  pending.set(key, launch);
+  // Abandoned navigation must not retain image paths indefinitely.
+  while (pending.size > 10) pending.delete(pending.keys().next().value!);
+  return key;
+}
+export function takeQueryLaunch(key: string): QueryLaunch | undefined {
+  const launch = pending.get(key);
+  pending.delete(key);
+  return launch;
+}
diff --git a/client/platform/desktop/frontend/querySession.spec.ts b/client/platform/desktop/frontend/querySession.spec.ts
new file mode 100644
index 000000000..b697af0fb
--- /dev/null
+++ b/client/platform/desktop/frontend/querySession.spec.ts
@@ -0,0 +1,11 @@
+import { holdQuerySession, QuerySession, takeQuerySession } from './querySession';
+
+describe('querySession', () => {
+  it('hands the held session to exactly one taker', () => {
+    const session = { view: 'query', results: { page: 2, hideReviewed: true }, textPage: 0 } as QuerySession;
+    expect(takeQuerySession()).toBeNull();
+    holdQuerySession(session);
+    expect(takeQuerySession()).toBe(session);
+    expect(takeQuerySession()).toBeNull();
+  });
+});
diff --git a/client/platform/desktop/frontend/querySession.ts b/client/platform/desktop/frontend/querySession.ts
new file mode 100644
index 000000000..be7035170
--- /dev/null
+++ b/client/platform/desktop/frontend/querySession.ts
@@ -0,0 +1,42 @@
+/**
+ * The Query page parks its state here when it is left (e.g. to open a
+ * result in the viewer) and takes it back when next shown, so the
+ * exemplar, results, marks, edits in progress and grid position resume
+ * where the user left off. Only one session is held.
+ */
+import { shallowRef } from 'vue';
+import type { ReviewService } from 'dive-common/use/useReview';
+import type { QueryPageState } from './useQueryPage';
+import type { ItemChips, SearchChips } from './useSearchChips';
+import type { SearchReview } from './useSearchReview';
+
+/** Grid position the results grid restores on return. */
+export interface ResultsGridMemory {
+  page: number;
+  hideReviewed: boolean;
+}
+
+export interface QuerySession {
+  page: QueryPageState;
+  review: ReviewService;
+  searchReview: SearchReview;
+  searchChips: SearchChips;
+  textChips: ItemChips;
+  view: 'query' | 'datasets';
+  results: ResultsGridMemory;
+  textPage: number;
+}
+
+/** Shallow: the services must not be deeply unwrapped. */
+const held = shallowRef<QuerySession | null>(null);
+
+export function holdQuerySession(session: QuerySession) {
+  held.value = session;
+}
+
+/** The held session, if any; the caller now owns it. */
+export function takeQuerySession(): QuerySession | null {
+  const session = held.value;
+  held.value = null;
+  return session;
+}
diff --git a/client/platform/desktop/frontend/store/jobs.spec.ts b/client/platform/desktop/frontend/store/jobs.spec.ts
new file mode 100644
index 000000000..fc8b26790
--- /dev/null
+++ b/client/platform/desktop/frontend/store/jobs.spec.ts
@@ -0,0 +1,52 @@
+import { DesktopJobUpdate, JobType } from 'platform/desktop/constants';
+
+const prompt = vi.hoisted(() => vi.fn().mockResolvedValue(true));
+vi.mock('dive-common/vue-utilities/prompt-service', () => ({ usePrompt: () => ({ prompt }) }));
+vi.mock('./dataset', () => ({ setRecents: vi.fn() }));
+const Queue = vi.hoisted(() => class {
+  jobSpecs = [];
+
+  init = vi.fn();
+});
+vi.mock('./queues/asyncGpuJobQueue', () => ({ default: Queue }));
+vi.mock('./queues/asyncCpuJobQueue', () => ({ default: Queue }));
+
+beforeEach(() => {
+  vi.resetModules();
+  prompt.mockClear();
+  vi.stubGlobal('window', { navigator: { userAgent: '' }, diveDesktop: { on: vi.fn(), invoke: vi.fn() } });
+});
+afterEach(() => vi.unstubAllGlobals());
+function indexingJob(): DesktopJobUpdate {
+  return {
+    key: 'index',
+    command: '',
+    workingDir: '',
+    jobType: 'indexing',
+    pid: 123,
+    title: 'Add search index (detections)',
+    args: { type: JobType.BuildSearchIndex, datasetId: 'fish', method: 'detections' },
+    datasetIds: ['fish'],
+    exitCode: null,
+    startTime: new Date(),
+    body: [],
+  };
+}
+it('opens an indexing failure pop-up with the underlying error and retains the console log', async () => {
+  const { updateHistory, jobHistory } = await import('./jobs');
+  const job = indexingJob();
+  updateHistory({ ...job, body: ['ERROR: Descriptor model could not be loaded'] });
+  expect(prompt).not.toHaveBeenCalled();
+  updateHistory({ ...job, exitCode: 1, endTime: new Date() });
+  expect(prompt).toHaveBeenCalledWith(expect.objectContaining({ title: 'Add search index (detections) failed', text: ['Descriptor model could not be loaded'] }));
+  expect(jobHistory.value.index.truncatedLogs).toContain('ERROR: Descriptor model could not be loaded');
+  updateHistory({ ...job, exitCode: 1, endTime: new Date() });
+  expect(prompt).toHaveBeenCalledTimes(1);
+});
+it('does not show a failure pop-up for a canceled indexing job', async () => {
+  const { updateHistory } = await import('./jobs');
+  updateHistory({
+    ...indexingJob(), exitCode: 143, cancelledJob: true, endTime: new Date(),
+  });
+  expect(prompt).not.toHaveBeenCalled();
+});
diff --git a/client/platform/desktop/frontend/store/jobs.ts b/client/platform/desktop/frontend/store/jobs.ts
index 8149b8103..43429d007 100644
--- a/client/platform/desktop/frontend/store/jobs.ts
+++ b/client/platform/desktop/frontend/store/jobs.ts
@@ -6,6 +6,7 @@ import {
   reactive,
 } from 'vue';
 import {
+  BuildSearchIndex,
   ConversionArgs,
   DesktopJob,
   DesktopJobUpdate,
@@ -69,6 +70,11 @@ export function updateHistory(args: DesktopJobUpdate) {
     existing.truncatedLogs.splice(0, existing.truncatedLogs.length - truncateOutputAtLines);
     existing.totalLogLength += args.body.length;
   }
+  // Preparation registers a job before its process and working directory exist.
+  ['pid', 'command', 'title', 'workingDir', 'datasetIds'].forEach((field) => {
+    const key = field as 'pid' | 'command' | 'title' | 'workingDir' | 'datasetIds';
+    if (args[key] !== undefined) set(existing.job, key, args[key]);
+  });
   // Only update exitCode if explicitly set
   if (args.exitCode !== undefined) {
     set(existing.job, 'exitCode', args.exitCode);
@@ -208,7 +214,8 @@ function removeJobFromQueue(jobArgs: JobArgs) {
       break;
     case JobType.RunPipeline:
     case JobType.RunTraining:
-      gpuJobQueue.removeJobFromQueue(jobArgs as RunPipeline | RunTraining);
+    case JobType.BuildSearchIndex:
+      gpuJobQueue.removeJobFromQueue(jobArgs as RunPipeline | RunTraining | BuildSearchIndex);
       break;
     default:
       break;
diff --git a/client/platform/desktop/frontend/store/queues/asyncGpuJobQueue.spec.ts b/client/platform/desktop/frontend/store/queues/asyncGpuJobQueue.spec.ts
new file mode 100644
index 000000000..62b929e93
--- /dev/null
+++ b/client/platform/desktop/frontend/store/queues/asyncGpuJobQueue.spec.ts
@@ -0,0 +1,16 @@
+import { DesktopJob, JobType } from 'platform/desktop/constants';
+import AsyncGpuJobQueue from './asyncGpuJobQueue';
+
+it('continues to the next index build after a registered preparation failure', async () => {
+  const ipc = {
+    on: vi.fn(),
+    invoke: vi.fn()
+      .mockResolvedValueOnce({ key: 'failed', exitCode: 1, endTime: new Date() } as DesktopJob)
+      .mockResolvedValueOnce({ key: 'running', exitCode: null } as DesktopJob),
+  };
+  const queue = new AsyncGpuJobQueue(ipc);
+  await queue.enqueue({ type: JobType.BuildSearchIndex, datasetId: 'first', method: 'detections' });
+  await queue.enqueue({ type: JobType.BuildSearchIndex, datasetId: 'second', method: 'detections' });
+  await vi.waitFor(() => expect(queue.processingJobs.map((job) => job.key)).toEqual(['running']));
+  expect(ipc.invoke).toHaveBeenCalledTimes(2);
+});
diff --git a/client/platform/desktop/frontend/store/queues/asyncGpuJobQueue.ts b/client/platform/desktop/frontend/store/queues/asyncGpuJobQueue.ts
index cf28bdbe8..3978e3350 100644
--- a/client/platform/desktop/frontend/store/queues/asyncGpuJobQueue.ts
+++ b/client/platform/desktop/frontend/store/queues/asyncGpuJobQueue.ts
@@ -2,6 +2,7 @@ import {
   JobType,
   RunPipeline,
   RunTraining,
+  BuildSearchIndex,
   DesktopJob,
 } from 'platform/desktop/constants';
 import AsyncJobQueue from './asyncJobQueue';
@@ -24,30 +25,38 @@ function runTrainingsAreEquivalent(a: RunTraining, b: RunTraining) {
   );
 }
 
-export default class AsyncGpuJobQueue extends AsyncJobQueue<RunPipeline | RunTraining> {
-  async beginJob(spec: RunPipeline | RunTraining) {
+type GpuJobSpec = RunPipeline | RunTraining | BuildSearchIndex;
+
+export default class AsyncGpuJobQueue extends AsyncJobQueue<GpuJobSpec> {
+  async beginJob(spec: GpuJobSpec) {
     let newJob: DesktopJob;
     if (spec.type === JobType.RunPipeline) {
       newJob = await this.ipcRenderer.invoke<DesktopJob>('run-pipeline', spec);
     } else if (spec.type === JobType.RunTraining) {
       newJob = await this.ipcRenderer.invoke<DesktopJob>('run-training', spec);
+    } else if (spec.type === JobType.BuildSearchIndex) {
+      newJob = await this.ipcRenderer.invoke<DesktopJob>('video-search-build-index', spec);
     } else {
       throw new Error('Unsupported job arguments provided to beginJob.');
     }
-    this.processingJobs.push(newJob);
+    if (!newJob.endTime) this.processingJobs.push(newJob);
   }
 
-  removeJobFromQueue(removeSpec: RunPipeline | RunTraining): void {
+  removeJobFromQueue(removeSpec: GpuJobSpec): void {
     let removeSpecIndex = -1;
     if (removeSpec.type === JobType.RunPipeline) {
-      removeSpecIndex = this.jobSpecs.findIndex((spec: RunPipeline | RunTraining) => (spec.type === JobType.RunPipeline
+      removeSpecIndex = this.jobSpecs.findIndex((spec: GpuJobSpec) => (spec.type === JobType.RunPipeline
         && spec.datasetId === removeSpec.datasetId
         && spec.pipeline.pipe === removeSpec.pipeline.pipe
       ));
     } else if (removeSpec.type === JobType.RunTraining) {
-      removeSpecIndex = this.jobSpecs.findIndex((spec: RunPipeline | RunTraining) => (spec.type === JobType.RunTraining
+      removeSpecIndex = this.jobSpecs.findIndex((spec: GpuJobSpec) => (spec.type === JobType.RunTraining
         && runTrainingsAreEquivalent(spec, removeSpec)
       ));
+    } else if (removeSpec.type === JobType.BuildSearchIndex) {
+      removeSpecIndex = this.jobSpecs.findIndex((spec: GpuJobSpec) => (spec.type === JobType.BuildSearchIndex
+        && spec.datasetId === removeSpec.datasetId
+      ));
     }
     if (removeSpecIndex > -1) {
       this.jobSpecs.splice(removeSpecIndex, 1);
diff --git a/client/platform/desktop/frontend/useQueryPage.spec.ts b/client/platform/desktop/frontend/useQueryPage.spec.ts
new file mode 100644
index 000000000..f8a540810
--- /dev/null
+++ b/client/platform/desktop/frontend/useQueryPage.spec.ts
@@ -0,0 +1,140 @@
+import { effectScope } from 'vue';
+import {
+  loadConfig, videoSearchIndexStatus, videoSearchListIndexes, videoSearchRemoveIndex, videoSearchDeleteIndex,
+} from './api';
+import { recentHistory, runningJobs } from './store/jobs';
+import { createQueryPage } from './useQueryPage';
+
+vi.mock('./api', () => ({
+  videoSearchRemoveIndex: vi.fn(),
+  videoSearchDeleteIndex: vi.fn(),
+  loadConfig: vi.fn(),
+  videoSearchIndexStatus: vi.fn(),
+  videoSearchListIndexes: vi.fn(async () => []),
+  listScoringDatasets: vi.fn(async () => []),
+  videoSearchInstalled: vi.fn(async () => true),
+  segmentationSam3Installed: vi.fn(async () => ({ installed: false })),
+}));
+vi.mock('./store/jobs', async () => {
+  const { ref } = await import('vue');
+  return { runningJobs: ref([]), recentHistory: ref([]), queuedGpuJobs: ref([]) };
+});
+vi.mock('./useVideoSearch', () => ({ createVideoSearch: () => ({ state: { results: [], streams: {}, busy: false } }) }));
+
+it('selects the first stereo camera and checks the index of that camera', async () => {
+  vi.mocked(loadConfig).mockResolvedValue({
+    name: 'Stereo',
+    type: 'multi',
+    multiCamMedia: {
+      cameras: { right: { type: 'video' }, left: { type: 'video' } }, cameraOrder: ['left', 'right'], defaultDisplay: 'right',
+    },
+  } as never);
+  vi.mocked(videoSearchIndexStatus).mockResolvedValue({ indexed: true } as never);
+  const scope = effectScope();
+  const page = scope.run(() => createQueryPage())!;
+  try {
+    await page.addDatasets(['stereo']);
+    expect(page.datasets.value).toEqual([expect.objectContaining({ id: 'stereo/left', name: 'Stereo / left', index: 'indexed' })]);
+    expect(videoSearchIndexStatus).toHaveBeenCalledWith('stereo/left');
+    expect(page.indexedIds.value).toEqual(['stereo/left']);
+  } finally { scope.stop(); }
+});
+
+it.each([undefined, 0, 1])('restores an index row after leaving while its job finishes (%s)', async (exitCode) => {
+  recentHistory.value.splice(0);
+  vi.mocked(loadConfig).mockResolvedValue({ name: 'Sequence', type: 'video' } as never);
+  vi.mocked(videoSearchIndexStatus).mockResolvedValue({ indexed: exitCode === 0 } as never);
+  const firstScope = effectScope();
+  const first = firstScope.run(() => createQueryPage())!;
+  first.datasets.value.forEach((dataset) => first.removeDataset(dataset.id));
+  await first.addDataset('sequence');
+  firstScope.stop();
+  recentHistory.value.push({
+    job: {
+      key: 'index-job',
+      title: 'Add search index (detections)',
+      datasetIds: ['sequence'],
+      startTime: new Date(),
+      endTime: exitCode === undefined ? undefined : new Date(),
+      exitCode: exitCode ?? null,
+    },
+    truncatedLogs: exitCode === 1 ? ['ERROR: index failed'] : [],
+    totalLogLength: 0,
+  } as never);
+  const secondScope = effectScope();
+  const second = secondScope.run(() => createQueryPage())!;
+  await second.refreshAvailable();
+  expect(second.datasets.value).toEqual([expect.objectContaining({
+    id: 'sequence', index: ({ running: 'building', 0: 'indexed', 1: 'error' } as Record<string, string>)[exitCode ?? 'running'],
+  })]);
+  if (exitCode === 1) expect(second.datasets.value[0].error).toContain('index failed');
+  secondScope.stop();
+});
+
+it('discovers completed indexes even without a prior page selection', async () => {
+  recentHistory.value.splice(0);
+  vi.mocked(loadConfig).mockResolvedValue({ name: 'Existing', type: 'video' } as never);
+  vi.mocked(videoSearchIndexStatus).mockResolvedValue({ indexed: true } as never);
+  vi.mocked(videoSearchListIndexes).mockResolvedValue([{
+    datasetId: 'existing', name: 'Existing', streamName: 'stream', method: 'detections',
+  }]);
+  const scope = effectScope();
+  const page = scope.run(() => createQueryPage())!;
+  page.datasets.value.forEach((dataset) => page.removeDataset(dataset.id));
+  await page.refreshAvailable();
+  expect(page.indexedIds.value).toEqual(['existing']);
+  scope.stop();
+});
+
+it('keeps index membership visible independently of the build selection and refreshes after removal', async () => {
+  recentHistory.value.splice(0);
+  vi.mocked(loadConfig).mockResolvedValue({ name: 'Indexed', type: 'video' } as never);
+  vi.mocked(videoSearchIndexStatus).mockResolvedValue({ indexed: true } as never);
+  vi.mocked(videoSearchListIndexes).mockResolvedValue([{
+    datasetId: 'indexed', name: 'Indexed', streamName: 'stream', method: 'detections',
+  }]);
+  const scope = effectScope();
+  const page = scope.run(() => createQueryPage())!;
+  await page.refreshAvailable();
+  page.removeDataset('indexed');
+  expect(page.indexMembers.value.map((member) => member.datasetId)).toEqual(['indexed']);
+  vi.mocked(videoSearchRemoveIndex).mockResolvedValue({ success: true });
+  vi.mocked(videoSearchListIndexes).mockResolvedValue([]);
+  await page.removeFromIndex('indexed');
+  expect(videoSearchRemoveIndex).toHaveBeenCalledWith('indexed');
+  expect(page.indexMembers.value).toEqual([]);
+  scope.stop();
+});
+
+it('prevents index deletion during a build and clears membership after deleting the entire index', async () => {
+  const scope = effectScope();
+  const page = scope.run(() => createQueryPage())!;
+  vi.mocked(videoSearchDeleteIndex).mockClear().mockResolvedValue({ success: true });
+  runningJobs.value.push({ job: { title: 'Add search index (detections)' } } as never);
+  await page.deleteEntireIndex();
+  expect(videoSearchDeleteIndex).not.toHaveBeenCalled();
+  runningJobs.value.splice(0);
+  vi.mocked(videoSearchListIndexes).mockResolvedValue([]);
+  vi.mocked(videoSearchIndexStatus).mockResolvedValue({ indexed: false } as never);
+  page.search.state.results = [{ ref: 'old-result' }] as never;
+  await page.deleteEntireIndex();
+  expect(videoSearchDeleteIndex).toHaveBeenCalledOnce();
+  expect(page.indexMembers.value).toEqual([]);
+  expect(page.search.state.results).toEqual([]);
+  expect(page.changingIndex.value).toBe(false);
+  scope.stop();
+});
+
+it('reports deletion errors without clearing successful index entries', async () => {
+  const scope = effectScope();
+  const page = scope.run(() => createQueryPage())!;
+  page.indexMembers.value = [{
+    datasetId: 'indexed', name: 'Indexed', streamName: 'stream', method: 'detections',
+  }];
+  vi.mocked(videoSearchDeleteIndex).mockRejectedValue(new Error('Permission denied'));
+  await page.deleteEntireIndex();
+  expect(page.error.value).toBe('Permission denied');
+  expect(page.indexMembers.value).toHaveLength(1);
+  expect(page.changingIndex.value).toBe(false);
+  scope.stop();
+});
diff --git a/client/platform/desktop/frontend/useQueryPage.ts b/client/platform/desktop/frontend/useQueryPage.ts
new file mode 100644
index 000000000..ceda0a226
--- /dev/null
+++ b/client/platform/desktop/frontend/useQueryPage.ts
@@ -0,0 +1,443 @@
+/**
+ * State behind the Query page: the datasets chosen for searching (with their
+ * search index status and index building), one search session spanning every
+ * indexed dataset, and the three ways to start a query: an image file, a frame
+ * of a video or dataset, or a text prompt swept over the datasets' frames.
+ */
+import {
+  computed, reactive, ref, Ref, watch,
+} from 'vue';
+import { JobType } from 'platform/desktop/constants';
+import { orderedMultiCamCameraNames } from 'dive-common/multicamDisplay';
+import type { ScoringDatasetSummary } from 'dive-common/scoring/types';
+import type { VideoSearchIndexMethod, VideoSearchResult, VideoSearchIndexInfo } from 'dive-common/apispec';
+import type { ReviewItem } from 'dive-common/review/types';
+import {
+  listScoringDatasets, loadConfig, segmentationSam3Installed, textQuery,
+  videoInfo, videoSearchBuildIndex, videoSearchExtractFrame, videoSearchIndexStatus,
+  videoSearchInstalled, videoSearchRemoveIndex, videoSearchListIndexes, videoSearchDeleteIndex,
+} from 'platform/desktop/frontend/api';
+import { runningJobs, recentHistory, queuedGpuJobs } from 'platform/desktop/frontend/store/jobs';
+import { createVideoSearch } from 'platform/desktop/frontend/useVideoSearch';
+import {
+  textHitItem, textQueryFrames, textQueryHits, TextQueryHit,
+} from './queryItems';
+
+export type QueryIndexState = 'checking' | 'indexed' | 'not-indexed' | 'building' | 'error';
+
+export interface QueryDataset {
+  id: string;
+  name: string;
+  type?: string;
+  index: QueryIndexState;
+  error?: string;
+}
+
+export type QueryMode = 'image' | 'video' | 'text';
+
+/** Where a video-frame query takes its frame from. */
+export interface VideoQuerySource {
+  kind: 'dataset' | 'file';
+  datasetId: string;
+  filePath: string;
+  frame: number;
+}
+
+/** Index build jobs are titled "Add search index (...)" or "Update search index (...)". */
+const BuildJobTitle = /search index/i;
+
+// Keep the selected index rows when routing away; each visit reconciles disk and job state.
+const selectedIndexRows = ref<QueryDataset[]>([]);
+
+export function createQueryPage() {
+  const available = ref<ScoringDatasetSummary[]>([]);
+  const datasets = selectedIndexRows;
+  const indexMembers = ref<VideoSearchIndexInfo[]>([]);
+  const changingIndex = ref(false);
+  const indexJobsActive = computed(() => runningJobs.value.some(({ job }) => BuildJobTitle.test(job.title))
+    || queuedGpuJobs.value.some((job) => job.type === JobType.BuildSearchIndex));
+  const indexActionsDisabled = computed(() => changingIndex.value || indexJobsActive.value || !!search.state.busy);
+  const installed = ref<boolean | null>(null);
+  const sam3Installed = ref<boolean | null>(null);
+  const error = ref<string | null>(null);
+
+  // One session searches every indexed dataset; results are filtered to the
+  // chosen ones below.
+  const search = createVideoSearch('', () => null);
+
+  const mode = ref<QueryMode>('image');
+  const imagePath = ref('');
+  /** Exemplar box on the image, in image pixels, or null for the whole image. */
+  const imageBox = ref<[number, number, number, number] | null>(null);
+  const video = reactive<VideoQuerySource>({
+    kind: 'dataset', datasetId: '', filePath: '', frame: 0,
+  });
+  /** Image on disk for the chosen video frame, once resolved. */
+  const videoFramePath = ref('');
+  const videoFrameBox = ref<[number, number, number, number] | null>(null);
+  const warmStartModel = ref('');
+  const onlySelected = ref(true);
+
+  const text = reactive({
+    prompt: '',
+    threshold: 0.3,
+    maxPerFrame: 10,
+    stride: 30,
+    maxFrames: 40,
+  });
+  const textHits = ref<TextQueryHit[]>([]);
+  const textProgress = reactive({ running: false, done: 0, total: 0 });
+  let textCancel = false;
+
+  function fail(reason: unknown, fallback: string) {
+    error.value = reason instanceof Error ? reason.message : String(reason || fallback);
+  }
+
+  function entry(id: string) {
+    return datasets.value.find((d) => d.id === id);
+  }
+
+  function patch(id: string, changes: Partial<QueryDataset>) {
+    datasets.value = datasets.value.map((d) => (d.id === id ? { ...d, ...changes } : d));
+  }
+
+  function datasetName(id: string) {
+    return entry(id)?.name || available.value.find((d) => d.id === id)?.name || id;
+  }
+
+  async function refreshIndexMembers() {
+    const members = await videoSearchListIndexes();
+    const statuses = await Promise.all(members.map((member) => videoSearchIndexStatus(member.datasetId)));
+    indexMembers.value = members.filter((_member, index) => statuses[index].indexed);
+  }
+
+  async function refreshAvailable() {
+    try {
+      available.value = await listScoringDatasets();
+      if (installed.value === null) installed.value = await videoSearchInstalled();
+      if (installed.value) await refreshIndexMembers();
+      const indexed = indexMembers.value;
+      const jobIds = recentHistory.value.filter(({ job }) => BuildJobTitle.test(job.title))
+        .flatMap(({ job }) => job.datasetIds);
+      // A stereo build job lists its parent for navigation and its child for indexing.
+      const candidates = Array.from(new Set([...indexed.map((item) => item.datasetId), ...jobIds,
+        ...queuedGpuJobs.value.filter((job) => job.type === JobType.BuildSearchIndex).map((job) => job.datasetId)]));
+      await addDatasets(candidates.filter((id) => !candidates.some((other) => other.startsWith(`${id}/`))));
+      await Promise.all(datasets.value.map((dataset) => refreshIndexStatus(dataset.id)));
+      if (sam3Installed.value === null) {
+        sam3Installed.value = (await segmentationSam3Installed()).installed;
+      }
+    } catch (err) {
+      fail(err, 'Could not list datasets');
+    }
+  }
+
+  async function refreshIndexStatus(id: string) {
+    if (!entry(id)) return;
+    if (queuedGpuJobs.value.some((job) => job.type === JobType.BuildSearchIndex && job.datasetId === id)) {
+      patch(id, { index: 'building', error: undefined });
+      return;
+    }
+    const latest = recentHistory.value.filter(({ job }) => (
+      BuildJobTitle.test(job.title) && job.datasetIds.includes(id)
+    )).sort((a, b) => +new Date(b.job.startTime) - +new Date(a.job.startTime))[0];
+    if (latest && latest.job.endTime === undefined) {
+      patch(id, { index: 'building', error: undefined });
+      return;
+    }
+    if (latest && latest.job.exitCode !== 0) {
+      const details = latest.truncatedLogs.slice(-8).join('\n');
+      patch(id, { index: 'error', error: details || `Index generation failed (exit ${latest.job.exitCode ?? 'unknown'})` });
+      return;
+    }
+    try {
+      const status = await videoSearchIndexStatus(id);
+      if (!entry(id)) return;
+      const index = status.indexed ? 'indexed' : 'not-indexed';
+      patch(id, { index: isBuilding(id) ? 'building' : index, error: undefined });
+    } catch (err) {
+      if (!entry(id)) return;
+      patch(id, { index: 'error', error: err instanceof Error ? err.message : String(err) });
+    }
+  }
+
+  async function addDataset(id: string, summary?: ScoringDatasetSummary) {
+    if (!id || entry(id)) return;
+    const known = summary || available.value.find((d) => d.id === id);
+    if (!known || known.type === 'multi') {
+      try {
+        const config = await loadConfig(id);
+        if (config.multiCamMedia) {
+          const [camera] = orderedMultiCamCameraNames(config.multiCamMedia);
+          if (!camera) throw new Error('This multicamera dataset has no cameras to index');
+          await addDataset(`${id}/${camera}`, {
+            ...known,
+            id: `${id}/${camera}`,
+            name: `${known?.name || config.name} / ${camera}`,
+            type: config.multiCamMedia.cameras[camera].type,
+          } as ScoringDatasetSummary);
+          return;
+        }
+      } catch (err) { fail(err, 'Could not select the first camera'); return; }
+    }
+    datasets.value = [...datasets.value, {
+      id, name: known?.name || id, type: known?.type, index: 'checking',
+    }];
+    await refreshIndexStatus(id);
+  }
+
+  async function addDatasets(ids: string[]) {
+    await Promise.all(Array.from(new Set(ids.filter(Boolean))).map((id) => addDataset(id)));
+  }
+
+  function removeDataset(id: string) {
+    datasets.value = datasets.value.filter((d) => d.id !== id);
+  }
+
+  function isBuilding(id: string) {
+    return queuedGpuJobs.value.some((job) => job.type === JobType.BuildSearchIndex && job.datasetId === id)
+      || runningJobs.value.some((item) => (
+        item.job.exitCode === null
+      && item.job.datasetIds.includes(id)
+      && BuildJobTitle.test(item.job.title)
+      ));
+  }
+
+  /** How long a queued build may take to show up as a running job. */
+  const BuildStartGraceMs = 20000;
+
+  /** Queue an index build (a GPU job) for each dataset given. */
+  function buildIndex(ids: string[], method: VideoSearchIndexMethod) {
+    if (changingIndex.value) return;
+    ids.forEach((id) => {
+      if (!entry(id) || isBuilding(id)) return;
+      videoSearchBuildIndex(id, method);
+      patch(id, { index: 'building', error: undefined });
+      // A build that never starts (e.g. an invalid VIAME path) leaves no
+      // running job behind; fall back to the real status after a grace period.
+      window.setTimeout(() => {
+        if (entry(id)?.index === 'building' && !isBuilding(id)) refreshIndexStatus(id);
+      }, BuildStartGraceMs);
+    });
+  }
+
+  async function changeIndex(remove: () => Promise<unknown>) {
+    if (indexActionsDisabled.value) return;
+    changingIndex.value = true;
+    error.value = null;
+    try {
+      await remove();
+      search.state.sessionOpen = false;
+      search.state.streams = {};
+      search.state.results = [];
+      search.state.adjudications = {};
+      search.state.modelAvailable = false;
+      await refreshIndexMembers();
+      await Promise.all(datasets.value.map((dataset) => refreshIndexStatus(dataset.id)));
+    } catch (err) {
+      fail(err, 'Could not update the search index');
+    } finally { changingIndex.value = false; }
+  }
+
+  async function removeFromIndex(id: string) {
+    await changeIndex(() => videoSearchRemoveIndex(id));
+  }
+
+  async function deleteEntireIndex() {
+    await changeIndex(() => videoSearchDeleteIndex());
+  }
+
+  // Observe terminal state as well as running jobs, so failures remain visible on return.
+  watch(() => recentHistory.value.map(({ job }) => `${job.key}:${job.endTime}:${job.exitCode}`).join('|'), () => {
+    search.state.sessionOpen = false;
+    datasets.value.forEach((dataset) => { refreshIndexStatus(dataset.id); });
+    if (installed.value) refreshIndexMembers().catch((err) => fail(err, 'Could not list indexed sequences'));
+  });
+
+  const indexedIds = computed(() => datasets.value.filter((d) => d.index === 'indexed').map((d) => d.id));
+  const canSearch = computed(() => installed.value === true && indexedIds.value.length > 0 && !search.state.busy);
+
+  /** Similarity results, limited to the chosen datasets unless asked otherwise. */
+  const results = computed<VideoSearchResult[]>(() => {
+    const all = search.state.results;
+    if (!onlySelected.value) return all;
+    const chosen = new Set(datasets.value.map((d) => d.id));
+    return all.filter((r) => {
+      const id = search.resultDatasetId(r);
+      return id !== null && chosen.has(id);
+    });
+  });
+
+  // ---- image and video-frame queries -----------------------------------
+
+  async function runImageQuery() {
+    if (!imagePath.value) return;
+    error.value = null;
+    const boxes = imageBox.value ? [[...imageBox.value]] : undefined;
+    await search.queryFromImage(imagePath.value, boxes, warmStartModel.value || undefined);
+  }
+
+  /** Resolve the chosen video frame to an image on disk (extracting it for videos). */
+  async function resolveVideoFrame(): Promise<string> {
+    if (video.kind === 'dataset') {
+      if (!video.datasetId) throw new Error('Choose a dataset');
+      return search.imageForDatasetFrame(video.datasetId, video.frame);
+    }
+    if (!video.filePath) throw new Error('Choose a video file');
+    const info = await videoInfo(video.filePath);
+    return videoSearchExtractFrame(video.filePath, video.frame, info.fps);
+  }
+
+  async function previewVideoFrame() {
+    error.value = null;
+    try {
+      videoFramePath.value = await resolveVideoFrame();
+      videoFrameBox.value = null;
+    } catch (err) {
+      fail(err, 'Could not read that frame');
+    }
+  }
+
+  async function runVideoQuery() {
+    error.value = null;
+    try {
+      if (!videoFramePath.value) videoFramePath.value = await resolveVideoFrame();
+    } catch (err) {
+      fail(err, 'Could not read that frame');
+      return;
+    }
+    const boxes = videoFrameBox.value ? [[...videoFrameBox.value]] : undefined;
+    await search.queryFromImage(videoFramePath.value, boxes, warmStartModel.value || undefined);
+  }
+
+  /** Start a similarity search from one text hit, box included. */
+  async function searchSimilarTo(hit: TextQueryHit) {
+    error.value = null;
+    await search.queryFromImage(hit.imagePath, [[...hit.box]]);
+  }
+
+  // ---- text queries ---------------------------------------------------------
+
+  /** Frames of a dataset: image count, or null (unknown) for videos. */
+  async function frameCountOf(id: string): Promise<number | null> {
+    const config = await loadConfig(id);
+    if (config.type === 'video') return null;
+    return config.imageData?.length ?? null;
+  }
+
+  async function runTextQuery() {
+    const prompt = text.prompt.trim();
+    if (!prompt || textProgress.running) return;
+    error.value = null;
+    textCancel = false;
+    textHits.value = [];
+    const targets = datasets.value.map((d) => d.id);
+    const plan: { id: string; frames: number[] }[] = [];
+    try {
+      await Promise.all(targets.map(async (id) => {
+        const frames = textQueryFrames(await frameCountOf(id), text.stride, text.maxFrames);
+        plan.push({ id, frames });
+      }));
+    } catch (err) {
+      fail(err, 'Could not plan the text query');
+      return;
+    }
+    textProgress.running = true;
+    textProgress.done = 0;
+    textProgress.total = plan.reduce((sum, p) => sum + p.frames.length, 0);
+    try {
+      // The segmentation service handles one request at a time.
+      // eslint-disable-next-line no-restricted-syntax
+      for (const { id, frames } of plan) {
+        // eslint-disable-next-line no-restricted-syntax
+        for (const frame of frames) {
+          if (textCancel) return;
+          try {
+            // eslint-disable-next-line no-await-in-loop
+            const image = await search.imageForDatasetFrame(id, frame);
+            // eslint-disable-next-line no-await-in-loop
+            const response = await textQuery({
+              imagePath: image,
+              text: prompt,
+              boxThreshold: text.threshold,
+              maxDetections: text.maxPerFrame,
+            });
+            if (response.success && response.detections?.length) {
+              textHits.value = [...textHits.value, ...textQueryHits(id, frame, image, response.detections)];
+            } else if (!response.success && response.error) {
+              throw new Error(response.error);
+            }
+          } catch (err) {
+            fail(err, `Text query failed on ${datasetName(id)} frame ${frame}`);
+            return;
+          } finally {
+            textProgress.done += 1;
+          }
+        }
+      }
+    } finally {
+      textProgress.running = false;
+    }
+  }
+
+  function cancelTextQuery() {
+    textCancel = true;
+  }
+
+  const textItems: Ref<ReviewItem[]> = computed(() => textHits.value.map(textHitItem));
+
+  function hitOf(key: string) {
+    return textHits.value.find((hit) => hit.key === key);
+  }
+
+  function clearError() {
+    error.value = null;
+  }
+
+  return {
+    available,
+    datasets,
+    indexMembers,
+    indexActionsDisabled,
+    changingIndex,
+    deleteEntireIndex,
+    installed,
+    sam3Installed,
+    error,
+    search,
+    mode,
+    imagePath,
+    imageBox,
+    video,
+    videoFramePath,
+    videoFrameBox,
+    warmStartModel,
+    onlySelected,
+    text,
+    textHits,
+    textItems,
+    textProgress,
+    indexedIds,
+    canSearch,
+    results,
+    datasetName,
+    refreshAvailable,
+    addDataset,
+    addDatasets,
+    removeDataset,
+    refreshIndexStatus,
+    buildIndex,
+    removeFromIndex,
+    isBuilding,
+    runImageQuery,
+    previewVideoFrame,
+    runVideoQuery,
+    searchSimilarTo,
+    runTextQuery,
+    cancelTextQuery,
+    hitOf,
+    clearError,
+  };
+}
+
+export type QueryPageState = ReturnType<typeof createQueryPage>;
diff --git a/client/platform/desktop/frontend/useSearchChips.ts b/client/platform/desktop/frontend/useSearchChips.ts
new file mode 100644
index 000000000..d9dfc77b7
--- /dev/null
+++ b/client/platform/desktop/frontend/useSearchChips.ts
@@ -0,0 +1,112 @@
+/**
+ * Video search results as review grid items plus the chip store that
+ * renders them, shared by the Video Search side panel (row thumbnails) and
+ * the full-window results grid. Chips are cropped client-side from each
+ * result's own dataset media through the review frame sources, so
+ * cross-dataset results need no backend frame extraction.
+ *
+ * Results and their cached chips are only comparable within one query
+ * generation (state.queryGeneration): the service can reuse refs across
+ * queries, so the store is reset whenever a new query starts.
+ */
+import { computed, Ref, watch } from 'vue';
+import type { VideoSearchResult } from 'dive-common/apispec';
+import { loadConfig } from 'platform/desktop/frontend/api';
+import type { VideoSearchContextType } from 'platform/desktop/frontend/useVideoSearch';
+import { createChipStore } from 'dive-common/review/chipStore';
+import { createFrameSourceRegistry } from 'dive-common/review/frameSource';
+import { searchResultItem } from 'dive-common/review/searchResultItems';
+import type { ReviewItem } from 'dive-common/review/types';
+import { DEFAULT_REVIEW_GRID } from 'dive-common/review/types';
+
+/** How many of the newest results the panel eagerly loads thumbnails for. */
+const EagerLoadCount = 50;
+/** Thumbnail resolution for the panel list; the grid re-renders at its own size. */
+const PanelChipSize = 128;
+
+export interface SearchChipsOptions {
+  /** A replacement item for a result (e.g. once it is an editable annotation). */
+  itemFor?: (result: VideoSearchResult) => ReviewItem | undefined;
+  /** Results to leave out of the grid. */
+  hidden?: (result: VideoSearchResult) => boolean;
+}
+
+export function createSearchChips(search: VideoSearchContextType, options: SearchChipsOptions = {}) {
+  const registry = createFrameSourceRegistry(loadConfig);
+  const store = createChipStore({ frameSourceFor: registry.frameSourceFor }, {
+    padding: DEFAULT_REVIEW_GRID.padding, size: PanelChipSize, aspect: 1, outline: '#00e5ff',
+  });
+
+  /** Every current result as a grid item, in rank order. */
+  const items = computed<ReviewItem[]>(() => search.state.results
+    .filter((result) => !options.hidden?.(result))
+    .map((result) => options.itemFor?.(result) ?? searchResultItem(
+      result,
+      search.resultDatasetId(result) ?? '',
+      DEFAULT_REVIEW_GRID.maxSequenceFrames,
+    ))
+    .filter((item): item is ReviewItem => item !== null));
+
+  const itemsByRef = computed(() => {
+    const map = new Map<string, ReviewItem>();
+    items.value.forEach((item) => map.set(item.key, item));
+    return map;
+  });
+
+  let generation = search.state.queryGeneration;
+  // Immediate so results that predate this store (e.g. the panel was
+  // toggled closed and back open) still get their chips loaded.
+  watch(items, (current) => {
+    if (search.state.queryGeneration !== generation) {
+      // New query: refs may repeat with different content, so start over.
+      generation = search.state.queryGeneration;
+      store.reset();
+    }
+    // Refinement re-ranks within the same query; cached chips stay valid.
+    store.ensurePrimary(current.slice(0, EagerLoadCount));
+  }, { immediate: true });
+
+  function dispose() {
+    store.reset();
+    registry.dispose();
+  }
+
+  return {
+    store,
+    items,
+    itemsByRef,
+    chips: store.chips,
+    dispose,
+  };
+}
+
+export type SearchChips = ReturnType<typeof createSearchChips>;
+
+/**
+ * Chips for any list of grid items whose datasets can be loaded by id
+ * (e.g. text query hits), with the same cross-dataset cropping.
+ */
+export function createItemChips(items: Ref<ReviewItem[]>) {
+  const registry = createFrameSourceRegistry(loadConfig);
+  const store = createChipStore({ frameSourceFor: registry.frameSourceFor }, {
+    padding: DEFAULT_REVIEW_GRID.padding, size: PanelChipSize, aspect: 1, outline: '',
+  });
+  const itemsByKey = computed(() => new Map(items.value.map((item) => [item.key, item])));
+  watch(items, (current, previous) => {
+    // A new hit list is a new result set; cached chips would belong to the old one.
+    if (!previous || current.length === 0 || current[0]?.key !== previous[0]?.key) store.reset();
+    store.ensurePrimary(current.slice(0, EagerLoadCount));
+  }, { immediate: true });
+  return {
+    store,
+    items,
+    itemsByKey,
+    chips: store.chips,
+    dispose: () => {
+      store.reset();
+      registry.dispose();
+    },
+  };
+}
+
+export type ItemChips = ReturnType<typeof createItemChips>;
diff --git a/client/platform/desktop/frontend/useSearchReview.spec.ts b/client/platform/desktop/frontend/useSearchReview.spec.ts
new file mode 100644
index 000000000..fff919f30
--- /dev/null
+++ b/client/platform/desktop/frontend/useSearchReview.spec.ts
@@ -0,0 +1,164 @@
+import { reactive } from 'vue';
+import type { VideoSearchResult } from 'dive-common/apispec';
+import type { ReviewItem } from 'dive-common/review/types';
+import type { TrackData } from 'vue-media-annotator/track';
+import type { ReviewService } from 'dive-common/use/useReview';
+import type { VideoSearchContextType } from './useVideoSearch';
+import { createSearchReview, OverlapChoice } from './useSearchReview';
+
+function result(ref: string, frame = 3, bbox: [number, number, number, number] = [0, 0, 10, 10]): VideoSearchResult {
+  return {
+    ref,
+    session: 0,
+    index_dir: '',
+    instance_id: 1,
+    query_id: 'q',
+    stream_id: 'left',
+    relevancy_score: 0.5,
+    start_frame: frame,
+    end_frame: frame,
+    tracks: [{ id: 9, states: [{ frame, bbox }] }],
+  };
+}
+
+function track(id: number, frame: number, bounds: [number, number, number, number], type = 'fish'): TrackData {
+  return {
+    id, begin: frame, end: frame, confidencePairs: [[type, 1]], attributes: {}, features: [{ frame, keyframe: true, bounds }],
+  };
+}
+
+/** A minimal in-memory stand-in for the review service's track store. */
+function setup(originals: TrackData[], choice: OverlapChoice = 'keep-originals') {
+  const tracks = new Map(originals.map((t) => [t.id, t]));
+  const pending = new Set<number>();
+  const deleted = new Set<number>();
+  let nextId = 100;
+  const search = {
+    state: reactive({ queryGeneration: 1, results: [] as VideoSearchResult[], adjudications: {} as Record<string, 'positive' | 'negative' | undefined> }),
+    resultDatasetId: vi.fn(() => 'ds'),
+  } as unknown as VideoSearchContextType;
+  const review = {
+    dataRevision: { value: 0 },
+    pendingCount: { get value() { return pending.size + deleted.size; } },
+    ensureLoaded: vi.fn(async () => true),
+    insertTrack: vi.fn((_id: string, data: Omit<TrackData, 'id'>) => {
+      const inserted = { ...data, id: nextId };
+      nextId += 1;
+      tracks.set(inserted.id, inserted);
+      pending.add(inserted.id);
+      return inserted;
+    }),
+    itemFor: vi.fn((_id: string, trackId: number, key: string): ReviewItem => ({
+      key, datasetId: 'ds', trackId, primary: { frame: 3, bounds: [0, 0, 10, 10] }, frames: [], keyframeCount: 1, type: '', confidence: 1,
+    })),
+    trackOf: vi.fn((_id: string, trackId: number) => tracks.get(trackId)),
+    tracksOf: vi.fn(() => Array.from(tracks.values())),
+    currentType: vi.fn((item: ReviewItem) => ({ type: tracks.get(item.trackId)?.confidencePairs[0]?.[0] ?? '', confidence: 1 })),
+    isPending: vi.fn((item: ReviewItem) => pending.has(item.trackId)),
+    assignType: vi.fn((item: ReviewItem, type: string) => { tracks.get(item.trackId)!.confidencePairs = [[type, 1]]; pending.add(item.trackId); }),
+    updateGeometry: vi.fn(),
+    discardTrack: vi.fn((_id: string, trackId: number) => { tracks.delete(trackId); pending.delete(trackId); }),
+    deleteTrackById: vi.fn((_id: string, trackId: number) => { tracks.delete(trackId); pending.delete(trackId); deleted.add(trackId); }),
+    deleteTrack: vi.fn((item: ReviewItem) => { tracks.delete(item.trackId); pending.delete(item.trackId); deleted.add(item.trackId); }),
+    save: vi.fn(async () => { pending.clear(); deleted.clear(); }),
+    discardChanges: vi.fn(async () => { pending.clear(); deleted.clear(); return true; }),
+  } as unknown as ReviewService;
+  const resolveOverlap = vi.fn(async () => choice);
+  return {
+    search, review, tracks, deleted, resolveOverlap, searchReview: createSearchReview(search, review, { resolveOverlap }),
+  };
+}
+
+describe('createSearchReview', () => {
+  it('saves accepted results and typed rejected ones, but not untyped rejected or unmarked ones', async () => {
+    const {
+      search, review, tracks, searchReview,
+    } = setup([]);
+    const accepted = result('0:1', 1, [100, 100, 110, 110]);
+    const rejectedTyped = result('0:2', 2, [200, 200, 210, 210]);
+    const rejectedUntyped = result('0:3', 3, [300, 300, 310, 310]);
+    const unmarked = result('0:4', 4, [400, 400, 410, 410]);
+    search.state.results = [accepted, rejectedTyped, rejectedUntyped, unmarked];
+    search.state.adjudications = { '0:1': 'positive', '0:2': 'negative', '0:3': 'negative' };
+    await searchReview.assignType(rejectedTyped, 'crab');
+    await searchReview.editGeometry(rejectedUntyped, {
+      slot: 0, frame: 3, bounds: [1, 1, 9, 9], polygons: [], head: null, tail: null,
+    });
+    expect(searchReview.changeCount.value).toBe(2);
+
+    expect(await searchReview.save()).toBe('saved');
+    expect(review.save).toHaveBeenCalledTimes(1);
+    const savedTypes = Array.from(tracks.values()).map((t) => t.confidencePairs[0][0]).sort();
+    expect(savedTypes).toEqual(['crab', 'unknown']);
+    expect(searchReview.itemOf(rejectedUntyped)).toBeUndefined();
+    expect(searchReview.changeCount.value).toBe(0);
+  });
+
+  it('asks about overlaps and can keep the originals, replace the overlapped ones, or replace everything', async () => {
+    const run = async (choice: OverlapChoice) => {
+      const {
+        search, review, tracks, deleted, resolveOverlap, searchReview,
+      } = setup([
+        track(1, 3, [0, 0, 10, 10]), track(2, 9, [50, 50, 60, 60]),
+      ], choice);
+      const overlapping = result('0:1');
+      const clear = result('0:2', 5, [70, 70, 80, 80]);
+      search.state.results = [overlapping, clear];
+      search.state.adjudications = { '0:1': 'positive', '0:2': 'positive' };
+      const outcome = await searchReview.save();
+      expect(resolveOverlap).toHaveBeenCalledWith({ overlapping: 1, total: 2, datasetIds: ['ds'] });
+      return {
+        outcome, review, ids: Array.from(tracks.keys()).sort((a, b) => a - b), deleted: Array.from(deleted),
+      };
+    };
+    const kept = await run('keep-originals');
+    expect(kept.outcome).toBe('saved');
+    expect(kept.ids).toEqual([1, 2, 101]);
+
+    const replaced = await run('overwrite-overlapping');
+    expect(replaced.review.deleteTrackById).toHaveBeenCalledWith('ds', 1);
+    expect(replaced.ids).toEqual([2, 100, 101]);
+
+    const all = await run('overwrite-all');
+    expect(all.review.deleteTrackById).toHaveBeenCalledTimes(2);
+    expect(all.ids).toEqual([100, 101]);
+
+    const discarded = await run('discard');
+    expect(discarded.outcome).toBe('discarded');
+    expect(discarded.review.save).not.toHaveBeenCalled();
+    expect(discarded.ids).toEqual([1, 2]);
+  });
+
+  it('drops unsaved result tracks on a new query and deletes saved ones on remove', async () => {
+    const {
+      search, review, tracks, searchReview,
+    } = setup([]);
+    const first = result('0:1');
+    search.state.results = [first];
+    search.state.adjudications = { '0:1': 'positive' };
+    await searchReview.save();
+    expect(tracks.size).toBe(1);
+    searchReview.remove(first);
+    expect(review.deleteTrack).toHaveBeenCalledTimes(1);
+    expect(searchReview.isRemoved(first)).toBe(true);
+
+    const second = result('0:2');
+    search.state.results = [second];
+    await searchReview.assignType(second, 'crab');
+    expect(tracks.size).toBe(1);
+    search.state.queryGeneration += 1;
+    await Promise.resolve();
+    expect(review.discardTrack).toHaveBeenCalledWith('ds', 101);
+    expect(searchReview.itemOf(second)).toBeUndefined();
+  });
+
+  it('reports results that cannot become annotations instead of throwing', async () => {
+    const { review, searchReview } = setup([]);
+    const boxless = { ...result('0:3'), tracks: [{ id: 9, states: [{ frame: 3 }] }] };
+    await searchReview.editGeometry(boxless, {
+      slot: 0, frame: 3, bounds: [1, 1, 9, 9], polygons: [], head: null, tail: null,
+    });
+    expect(review.updateGeometry).not.toHaveBeenCalled();
+    expect(searchReview.error.value).toMatch(/no box/);
+  });
+});
diff --git a/client/platform/desktop/frontend/useSearchReview.ts b/client/platform/desktop/frontend/useSearchReview.ts
new file mode 100644
index 000000000..3ea067880
--- /dev/null
+++ b/client/platform/desktop/frontend/useSearchReview.ts
@@ -0,0 +1,300 @@
+/**
+ * Search results as annotations of their datasets. Editing a result's
+ * type or box, or accepting it, gives it a track of its own in the review
+ * service (never touching the annotations already there). Saving then
+ * decides what is written: accepted results and results given a type
+ * (rejected ones only with a type), and where those overlap annotations
+ * the dataset already has, the caller is asked whether to keep the
+ * originals, replace the overlapped ones, replace every original, or
+ * drop the results altogether.
+ */
+import { computed, ref, watch } from 'vue';
+import type { VideoSearchResult } from 'dive-common/apispec';
+import type { ReviewCellGeometryEdit } from 'dive-common/components/Review/ReviewCell.vue';
+import { tracksOverlapping } from 'dive-common/review/reviewItems';
+import { searchResultTrack } from 'dive-common/review/searchResultItems';
+import type { ReviewItem } from 'dive-common/review/types';
+import type { ReviewService } from 'dive-common/use/useReview';
+import type { VideoSearchContextType } from 'platform/desktop/frontend/useVideoSearch';
+
+/** Type of a result saved or box-edited without one; not counted as an assigned type. */
+export const UNTYPED_RESULT = 'unknown';
+
+/** Overlap at which a result counts as the same object as an existing annotation. */
+const OVERLAP_MIN_IOU = 0.5;
+
+export type OverlapChoice = 'keep-originals' | 'overwrite-overlapping' | 'overwrite-all' | 'discard';
+
+export interface OverlapSummary {
+  /** Results to save that overlap an existing annotation. */
+  overlapping: number;
+  /** Results to save in total. */
+  total: number;
+  /** Datasets those results belong to. */
+  datasetIds: string[];
+}
+
+export interface SearchReviewOptions {
+  /** How to save results that overlap existing annotations. */
+  resolveOverlap: (summary: OverlapSummary) => Promise<OverlapChoice>;
+}
+
+interface CreatedTrack {
+  datasetId: string;
+  trackId: number;
+}
+
+export type SearchSaveOutcome = 'saved' | 'nothing' | 'discarded' | 'failed';
+
+export function createSearchReview(
+  search: VideoSearchContextType,
+  review: ReviewService,
+  options: SearchReviewOptions,
+) {
+  /** Results with a track of their own, as the review items backing their cells. */
+  const adopted = ref<Record<string, ReviewItem>>({});
+  /** The track each adopted result created (saved or not). */
+  const created = ref<Record<string, CreatedTrack>>({});
+  /** Results whose track has been written to its dataset. */
+  const saved = ref<Record<string, true>>({});
+  /** Results whose box was adjusted. */
+  const edited = ref<Record<string, true>>({});
+  /** Results taken out of the grid. */
+  const removed = ref<Record<string, true>>({});
+  const error = ref<string | null>(null);
+  const adopting = new Map<string, Promise<ReviewItem>>();
+
+  function without<T>(record: Record<string, T>, ref: string): Record<string, T> {
+    const rest = { ...record };
+    delete rest[ref];
+    return rest;
+  }
+
+  function discardEntry(ref: string) {
+    const track = created.value[ref];
+    if (track && !saved.value[ref]) review.discardTrack(track.datasetId, track.trackId);
+    adopted.value = without(adopted.value, ref);
+    created.value = without(created.value, ref);
+    edited.value = without(edited.value, ref);
+  }
+
+  // Refs are only unique within one query, so a new query starts over;
+  // tracks not yet saved are dropped with it.
+  watch(() => search.state.queryGeneration, () => {
+    Object.keys(created.value).forEach((ref) => {
+      const track = created.value[ref];
+      if (!saved.value[ref]) review.discardTrack(track.datasetId, track.trackId);
+    });
+    adopted.value = {};
+    created.value = {};
+    saved.value = {};
+    edited.value = {};
+    removed.value = {};
+    adopting.clear();
+  });
+
+  function itemOf(result: VideoSearchResult): ReviewItem | undefined {
+    return adopted.value[result.ref];
+  }
+
+  function isRemoved(result: VideoSearchResult): boolean {
+    return removed.value[result.ref] === true;
+  }
+
+  async function doAdopt(result: VideoSearchResult, type: string): Promise<ReviewItem> {
+    const datasetId = search.resultDatasetId(result);
+    if (!datasetId) throw new Error('This result belongs to a dataset that is no longer in the index');
+    if (!await review.ensureLoaded(datasetId)) {
+      throw new Error(`Could not load the annotations of ${datasetId}`);
+    }
+    const data = searchResultTrack(result, type);
+    if (!data) throw new Error('This result has no box to annotate');
+    const track = review.insertTrack(datasetId, data);
+    if (!track) throw new Error(`Could not add the annotation to ${datasetId}`);
+    const item = review.itemFor(datasetId, track.id, result.ref);
+    if (!item) throw new Error('This annotation has no box to show');
+    adopted.value = { ...adopted.value, [result.ref]: item };
+    created.value = { ...created.value, [result.ref]: { datasetId, trackId: track.id } };
+    return item;
+  }
+
+  /** The review item behind a result, giving it a track of its own first when needed. */
+  function adopt(result: VideoSearchResult, type = UNTYPED_RESULT): Promise<ReviewItem> {
+    const existing = adopted.value[result.ref];
+    if (existing) return Promise.resolve(existing);
+    let pending = adopting.get(result.ref);
+    if (!pending) {
+      pending = doAdopt(result, type).finally(() => { adopting.delete(result.ref); });
+      adopting.set(result.ref, pending);
+    }
+    return pending;
+  }
+
+  async function guarded<T>(op: () => Promise<T>): Promise<T | undefined> {
+    error.value = null;
+    try {
+      return await op();
+    } catch (err) {
+      error.value = err instanceof Error ? err.message : String(err);
+      return undefined;
+    }
+  }
+
+  function assignType(result: VideoSearchResult, type: string) {
+    const trimmed = type.trim();
+    if (!trimmed) return Promise.resolve(undefined);
+    return guarded(async () => {
+      const item = await adopt(result, trimmed);
+      if (review.currentType(item).type !== trimmed) review.assignType(item, trimmed);
+    });
+  }
+
+  function editGeometry(result: VideoSearchResult, edit: ReviewCellGeometryEdit) {
+    return guarded(async () => {
+      const item = await adopt(result);
+      review.updateGeometry(item, edit.frame, {
+        bounds: edit.bounds ?? undefined,
+        polygons: edit.polygons,
+        head: edit.head,
+        tail: edit.tail,
+      });
+      edited.value = { ...edited.value, [result.ref]: true };
+    });
+  }
+
+  /** Drop a result from the grid; a saved one is also deleted from its dataset on save. */
+  function remove(result: VideoSearchResult) {
+    const item = adopted.value[result.ref];
+    if (item && saved.value[result.ref]) review.deleteTrack(item);
+    discardEntry(result.ref);
+    removed.value = { ...removed.value, [result.ref]: true };
+  }
+
+  function assignedType(item: ReviewItem): string {
+    const { type } = review.currentType(item);
+    return type === UNTYPED_RESULT ? '' : type;
+  }
+
+  /**
+   * Whether an adopted result is worth writing: accepted ones always,
+   * rejected ones only with a type, the rest when typed or box-edited.
+   */
+  function qualifies(result: VideoSearchResult, item: ReviewItem): boolean {
+    const adjudication = search.state.adjudications[result.ref];
+    if (adjudication === 'positive') return true;
+    const typed = assignedType(item) !== '';
+    if (adjudication === 'negative') return typed;
+    return typed || edited.value[result.ref] === true;
+  }
+
+  /** Results the next save would write or update, for the toolbar. */
+  const changeCount = computed(() => {
+    review.dataRevision.value; // eslint-disable-line no-unused-expressions
+    return search.state.results.filter((result) => {
+      if (removed.value[result.ref]) return false;
+      const item = adopted.value[result.ref];
+      if (!item) return search.state.adjudications[result.ref] === 'positive';
+      if (saved.value[result.ref]) return review.isPending(item);
+      return qualifies(result, item);
+    }).length;
+  });
+
+  const hasChanges = computed(() => changeCount.value > 0 || review.pendingCount.value > 0);
+
+  /** Track ids this session created in a dataset; the rest are the dataset's own. */
+  function createdIn(datasetId: string): Set<number> {
+    const ids = new Set<number>();
+    Object.values(created.value).forEach((track) => {
+      if (track.datasetId === datasetId) ids.add(track.trackId);
+    });
+    return ids;
+  }
+
+  function originalsOf(datasetId: string) {
+    const mine = createdIn(datasetId);
+    return review.tracksOf(datasetId).filter((track) => !mine.has(track.id));
+  }
+
+  function save(): Promise<SearchSaveOutcome> {
+    return guarded(async (): Promise<SearchSaveOutcome> => {
+      const results = search.state.results.filter((result) => !removed.value[result.ref]);
+      // Accepted results without a track get one now.
+      await Promise.all(results
+        .filter((result) => search.state.adjudications[result.ref] === 'positive' && !adopted.value[result.ref])
+        .map((result) => adopt(result)));
+
+      const unsaved = results.filter((result) => adopted.value[result.ref] && !saved.value[result.ref]);
+      const keep = unsaved.filter((result) => qualifies(result, adopted.value[result.ref]));
+      unsaved.filter((result) => !keep.includes(result)).forEach((result) => discardEntry(result.ref));
+
+      const overlaps = new Map<string, { datasetId: string; tracks: number[] }>();
+      keep.forEach((result) => {
+        const { datasetId, trackId } = created.value[result.ref];
+        const track = review.trackOf(datasetId, trackId);
+        if (!track) return;
+        const hits = tracksOverlapping(originalsOf(datasetId), track, OVERLAP_MIN_IOU);
+        if (hits.length) overlaps.set(result.ref, { datasetId, tracks: hits.map((hit) => hit.id) });
+      });
+      if (overlaps.size > 0) {
+        const choice = await options.resolveOverlap({
+          overlapping: overlaps.size,
+          total: keep.length,
+          datasetIds: Array.from(new Set(keep.map((result) => created.value[result.ref].datasetId))),
+        });
+        if (choice === 'discard') {
+          keep.forEach((result) => discardEntry(result.ref));
+          return 'discarded';
+        }
+        if (choice === 'keep-originals') {
+          overlaps.forEach((_hit, ref) => discardEntry(ref));
+        } else if (choice === 'overwrite-overlapping') {
+          overlaps.forEach(({ datasetId, tracks }) => {
+            tracks.forEach((trackId) => review.deleteTrackById(datasetId, trackId));
+          });
+        } else if (choice === 'overwrite-all') {
+          new Set(keep.map((result) => created.value[result.ref].datasetId)).forEach((datasetId) => {
+            originalsOf(datasetId).forEach((track) => review.deleteTrackById(datasetId, track.id));
+          });
+        }
+      }
+
+      if (review.pendingCount.value === 0) return 'nothing';
+      await review.save();
+      if (review.pendingCount.value > 0) return 'failed';
+      const written: Record<string, true> = { ...saved.value };
+      keep.forEach((result) => { if (created.value[result.ref]) written[result.ref] = true; });
+      saved.value = written;
+      return 'saved';
+    }).then((outcome) => outcome ?? 'failed');
+  }
+
+  /** Drop every unsaved result track and any edits to saved ones. */
+  async function discardAll() {
+    Object.keys(created.value).forEach((ref) => {
+      if (!saved.value[ref]) discardEntry(ref);
+    });
+    if (review.pendingCount.value > 0) await review.discardChanges();
+  }
+
+  function clearError() {
+    error.value = null;
+  }
+
+  return {
+    adopted,
+    error,
+    changeCount,
+    hasChanges,
+    itemOf,
+    isRemoved,
+    adopt,
+    assignType,
+    editGeometry,
+    remove,
+    save,
+    discardAll,
+    clearError,
+  };
+}
+
+export type SearchReview = ReturnType<typeof createSearchReview>;
diff --git a/client/platform/desktop/frontend/useVideoSearch.spec.ts b/client/platform/desktop/frontend/useVideoSearch.spec.ts
new file mode 100644
index 000000000..5c7147e7e
--- /dev/null
+++ b/client/platform/desktop/frontend/useVideoSearch.spec.ts
@@ -0,0 +1,59 @@
+import { videoSearchFormulate, videoSearchOpenIndex, videoSearchRefine } from './api';
+import { createVideoSearch } from './useVideoSearch';
+
+vi.mock('./api', () => ({
+  videoSearchFormulate: vi.fn(), videoSearchOpenIndex: vi.fn(), videoSearchRefine: vi.fn(),
+}));
+
+const results = [
+  { ref: 'one', stream_id: 'left', relevancy_score: 0.8 },
+  { ref: 'two', stream_id: 'right', relevancy_score: 0.7 },
+];
+beforeEach(() => {
+  vi.mocked(videoSearchOpenIndex).mockResolvedValue({
+    success: true,
+    streams: [
+      {
+        streamName: 'left', datasetId: 'a', name: 'Alpha', method: 'detections',
+      },
+      {
+        streamName: 'right', datasetId: 'b', name: 'Beta', method: 'detections',
+      },
+    ],
+  });
+  vi.mocked(videoSearchFormulate).mockResolvedValue({ results } as never);
+  vi.mocked(videoSearchRefine).mockResolvedValue({ results: [...results].reverse() } as never);
+});
+
+it('limits query and refined results to the selected indexed sequence', async () => {
+  const search = createVideoSearch('a', () => null);
+  search.selectIndex('right');
+  await search.queryFromImage('image.jpg');
+  expect(search.state.results.map((r) => r.ref)).toEqual(['two']);
+  search.mark('two', 'positive');
+  await search.refine();
+  expect(search.state.results.map((r) => r.ref)).toEqual(['two']);
+  expect(videoSearchRefine).toHaveBeenCalledWith(['two'], []);
+});
+
+it('clears old results, feedback, and models when switching indexes and supports all sequences', async () => {
+  const search = createVideoSearch('a', () => null);
+  search.selectIndex('left');
+  await search.queryFromImage('image.jpg');
+  search.mark('one', 'negative');
+  search.state.modelAvailable = true;
+  search.selectIndex(null);
+  expect(search.state).toMatchObject({
+    results: [], adjudications: {}, modelAvailable: false, iteration: 0,
+  });
+  await search.queryFromImage('image.jpg');
+  expect(search.state.results).toEqual(results);
+});
+
+it('does not switch indexes while a query is running', () => {
+  const search = createVideoSearch('a', () => null);
+  search.selectIndex('left');
+  search.state.busy = 'Searching';
+  search.selectIndex('right');
+  expect(search.state.selectedStream).toBe('left');
+});
diff --git a/client/platform/desktop/frontend/useVideoSearch.ts b/client/platform/desktop/frontend/useVideoSearch.ts
new file mode 100644
index 000000000..e5d4d2da3
--- /dev/null
+++ b/client/platform/desktop/frontend/useVideoSearch.ts
@@ -0,0 +1,371 @@
+/**
+ * Video search / IQR session state shared between ViewerLoader (which owns
+ * dataset media details) and the VideoSearchContext side panel.
+ *
+ * Created and provided by ViewerLoader; injected by the panel.
+ *
+ * All indexed datasets share one search database, so every query searches
+ * every indexed dataset in a single IQR session. Each result's stream_id
+ * maps back to its source dataset via the index membership metadata.
+ */
+import { reactive, provide, inject } from 'vue';
+import type {
+  VideoSearchIndexStatus, VideoSearchIndexMethod, VideoSearchIndexInfo,
+  VideoSearchResult, VideoSearchQueryResponse,
+} from 'dive-common/apispec';
+import {
+  videoSearchInstalled, videoSearchIndexStatus, videoSearchBuildIndex,
+  videoSearchRemoveIndex, videoSearchOpenIndex,
+  videoSearchFormulate, videoSearchQuery, videoSearchRefine,
+  videoSearchExportModel, videoSearchClose, videoSearchExtractFrame,
+  loadConfig,
+} from 'platform/desktop/frontend/api';
+
+export const VideoSearchInjectKey = 'DesktopVideoSearch';
+
+export type Adjudication = 'positive' | 'negative';
+
+export interface VideoSearchMediaInfo {
+  type: string; // 'image-sequence' | 'video'
+  fps: number;
+  getImagePath: (frameNum: number) => string;
+}
+
+interface VideoSearchState {
+  installed: boolean | null;
+  status: VideoSearchIndexStatus | null;
+  sessionOpen: boolean;
+  /** stream identifier -> source dataset info for the open index. */
+  streams: Record<string, VideoSearchIndexInfo>;
+  /** Human-readable description of the operation in flight, or null. */
+  busy: string | null;
+  error: string | null;
+  results: VideoSearchResult[];
+  /** Keyed by result ref ("<session>:<instance_id>"). */
+  adjudications: Record<string, Adjudication | undefined>;
+  /** Completed refinement iterations for the active query. */
+  iteration: number;
+  /**
+   * Bumped whenever a new query starts. Refs and cached chips are only
+   * comparable within one generation (the service can reuse instance ids
+   * and query ids across queries).
+   */
+  queryGeneration: number;
+  modelAvailable: boolean;
+  selectedStream: string | null;
+}
+
+/** Renderer-safe path join (node 'path' is unavailable here). */
+function isAbsolutePath(p: string): boolean {
+  return /^([A-Za-z]:[\\/]|[\\/])/.test(p);
+}
+function joinPath(base: string, file: string): string {
+  if (!base) return file;
+  const sep = base.includes('\\') ? '\\' : '/';
+  return `${base.replace(/[\\/]+$/, '')}${sep}${file}`;
+}
+
+/** Recover the on-disk path behind a media server URL (/api/media?path=...). */
+function mediaUrlToPath(url: string | undefined): string | null {
+  if (!url) return null;
+  try {
+    return new URL(url).searchParams.get('path');
+  } catch {
+    return null;
+  }
+}
+
+export function createVideoSearch(
+  datasetId: string,
+  getMediaInfo: () => VideoSearchMediaInfo | null,
+) {
+  const state = reactive<VideoSearchState>({
+    installed: null,
+    status: null,
+    sessionOpen: false,
+    streams: {},
+    busy: null,
+    error: null,
+    results: [],
+    adjudications: {},
+    iteration: 0,
+    queryGeneration: 0,
+    modelAvailable: false,
+    selectedStream: null,
+  });
+
+  /** Media info per dataset for cross-dataset result display. */
+  const mediaInfoCache: Record<string, VideoSearchMediaInfo | null> = {};
+
+  async function getMediaInfoFor(dsId: string): Promise<VideoSearchMediaInfo | null> {
+    if (dsId === datasetId) {
+      return getMediaInfo();
+    }
+    if (!(dsId in mediaInfoCache)) {
+      try {
+        const meta = await loadConfig(dsId);
+        const {
+          originalBasePath, originalImageFiles, type, originalVideoFile, fps,
+          imageData, videoUrl,
+        } = meta;
+        // Prefer the files the media server actually serves (the transcoded
+        // copies when they exist): the originals may have moved since import.
+        const servedVideoPath = mediaUrlToPath(videoUrl);
+        mediaInfoCache[dsId] = {
+          type,
+          fps,
+          getImagePath: (frameNum: number): string => {
+            if (type === 'video') {
+              return servedVideoPath ?? joinPath(originalBasePath, originalVideoFile || '');
+            }
+            const servedImagePath = mediaUrlToPath(imageData?.[frameNum]?.url);
+            if (servedImagePath) return servedImagePath;
+            const imagePath = originalImageFiles?.[frameNum];
+            if (!imagePath) return '';
+            return isAbsolutePath(imagePath)
+              ? imagePath : joinPath(originalBasePath, imagePath);
+          },
+        };
+      } catch {
+        mediaInfoCache[dsId] = null;
+      }
+    }
+    return mediaInfoCache[dsId];
+  }
+
+  async function refreshStatus() {
+    try {
+      if (state.installed === null) {
+        state.installed = await videoSearchInstalled();
+      }
+      if (state.installed) {
+        state.status = await videoSearchIndexStatus(datasetId);
+      }
+    } catch (err) {
+      state.error = err instanceof Error ? err.message : String(err);
+    }
+  }
+
+  /** Run an operation with busy/error bookkeeping. */
+  async function guarded<T>(label: string, op: () => Promise<T>): Promise<T | undefined> {
+    if (state.busy) {
+      return undefined;
+    }
+    state.busy = label;
+    state.error = null;
+    try {
+      return await op();
+    } catch (err) {
+      state.error = err instanceof Error ? err.message : String(err);
+      return undefined;
+    } finally {
+      state.busy = null;
+    }
+  }
+
+  function buildIndex(method: VideoSearchIndexMethod) {
+    // Runs through the GPU job queue; completion observed via the jobs store.
+    videoSearchBuildIndex(datasetId, method);
+  }
+
+  /** Remove this dataset from the shared search index. */
+  async function removeFromIndex() {
+    await guarded('Removing from index...', async () => {
+      await videoSearchRemoveIndex(datasetId);
+      state.sessionOpen = false;
+      state.streams = {};
+      resetQueryState();
+    });
+    await refreshStatus();
+  }
+
+  function resetQueryState() {
+    state.results = [];
+    state.adjudications = {};
+    state.iteration = 0;
+    state.queryGeneration += 1;
+    state.modelAvailable = false;
+  }
+
+  /**
+   * Open the shared search index (covering every indexed dataset). The
+   * backend is a no-op when it is already open.
+   */
+  async function ensureSession() {
+    const { streams } = await videoSearchOpenIndex();
+    const map: Record<string, VideoSearchIndexInfo> = {};
+    streams.forEach((info) => { map[info.streamName] = info; });
+    state.streams = map;
+    state.sessionOpen = true;
+  }
+
+  /** The dataset a result belongs to (via its stream identifier). */
+  function resultDatasetId(result: VideoSearchResult): string | null {
+    return state.streams[result.stream_id]?.datasetId ?? null;
+  }
+
+  /** Whether a result belongs to the currently open dataset. */
+  function resultIsLocal(result: VideoSearchResult): boolean {
+    return resultDatasetId(result) === datasetId;
+  }
+
+  /** Display name of a result's dataset, or null when it is this dataset. */
+  function resultDatasetName(result: VideoSearchResult): string | null {
+    const info = state.streams[result.stream_id];
+    if (!info) return null;
+    return info.datasetId === datasetId ? null : (info.name || info.datasetId);
+  }
+
+  function applyResponse(response: VideoSearchQueryResponse) {
+    if (response.results) {
+      state.results = state.selectedStream
+        ? response.results.filter((result) => result.stream_id === state.selectedStream) : response.results;
+      // Keep adjudications for refs that are still present so marks
+      // survive re-ranking across refinement rounds.
+      const keep: Record<string, Adjudication | undefined> = {};
+      response.results.forEach((r) => {
+        keep[r.ref] = state.adjudications[r.ref];
+      });
+      state.adjudications = keep;
+    }
+    if (response.model_available) {
+      state.modelAvailable = true;
+    }
+  }
+
+  /**
+   * Resolve an image on disk for a frame of any open dataset: the image
+   * file itself for image sequences, or an extracted frame for videos.
+   */
+  async function imageForDatasetFrame(dsId: string, frameNum: number): Promise<string> {
+    const media = await getMediaInfoFor(dsId);
+    if (!media) {
+      throw new Error(`Media for dataset ${dsId} is unavailable`);
+    }
+    if (media.type === 'video') {
+      return videoSearchExtractFrame(media.getImagePath(frameNum), frameNum, media.fps);
+    }
+    const imagePath = media.getImagePath(frameNum);
+    if (!imagePath) {
+      throw new Error(`No image found for frame ${frameNum}`);
+    }
+    return imagePath;
+  }
+
+  async function exemplarImageForFrame(frameNum: number): Promise<string> {
+    return imageForDatasetFrame(datasetId, frameNum);
+  }
+
+  /**
+   * Start a new query from an image chip: exemplar image plus zero or more
+   * boxes. Descriptors are computed once (on this dataset's primary
+   * session) and the similarity query fans out to every open index.
+   */
+  async function queryFromImage(imagePath: string, boxes?: number[][], warmStartModelPath?: string) {
+    await guarded('Searching...', async () => {
+      await ensureSession();
+      resetQueryState();
+      let response = await videoSearchFormulate(imagePath, boxes);
+      if (!response.results?.length || warmStartModelPath) {
+        response = await videoSearchQuery(
+          warmStartModelPath ? { iqrModelPath: warmStartModelPath } : {},
+        );
+      }
+      applyResponse(response);
+    });
+  }
+
+  /** Start a new query from a frame of this dataset + boxes. */
+  async function queryFromFrame(frameNum: number, boxes: number[][], warmStartModelPath?: string) {
+    await guarded('Searching...', async () => {
+      await ensureSession();
+      resetQueryState();
+      const imagePath = await exemplarImageForFrame(frameNum);
+      let response = await videoSearchFormulate(imagePath, boxes);
+      if (!response.results?.length || warmStartModelPath) {
+        response = await videoSearchQuery(
+          warmStartModelPath ? { iqrModelPath: warmStartModelPath } : {},
+        );
+      }
+      applyResponse(response);
+    });
+  }
+
+  function mark(ref: string, adjudication: Adjudication) {
+    if (state.adjudications[ref] === adjudication) {
+      state.adjudications = { ...state.adjudications, [ref]: undefined };
+    } else {
+      state.adjudications = { ...state.adjudications, [ref]: adjudication };
+    }
+  }
+
+  async function refine() {
+    const positives: string[] = [];
+    const negatives: string[] = [];
+    Object.entries(state.adjudications).forEach(([ref, adj]) => {
+      if (adj === 'positive') positives.push(ref);
+      if (adj === 'negative') negatives.push(ref);
+    });
+    if (!positives.length && !negatives.length) {
+      state.error = 'Mark at least one result as correct or incorrect before refining';
+      return;
+    }
+    await guarded('Refining...', async () => {
+      const response = await videoSearchRefine(positives, negatives);
+      applyResponse(response);
+      state.iteration += 1;
+    });
+  }
+
+  async function saveModel(name: string): Promise<string | undefined> {
+    return guarded('Saving model...', async () => {
+      const { outputDir } = await videoSearchExportModel(name);
+      return outputDir;
+    });
+  }
+
+  async function closeSession() {
+    await guarded('Closing...', async () => {
+      await videoSearchClose();
+      state.sessionOpen = false;
+      state.streams = {};
+    });
+  }
+
+  const context = {
+    datasetId,
+    state,
+    getMediaInfo,
+    getMediaInfoFor,
+    refreshStatus,
+    selectIndex(streamName: string | null) {
+      if (state.busy || state.selectedStream === streamName) return;
+      state.selectedStream = streamName;
+      resetQueryState();
+    },
+    buildIndex,
+    removeFromIndex,
+    queryFromImage,
+    queryFromFrame,
+    exemplarImageForFrame,
+    imageForDatasetFrame,
+    resultDatasetId,
+    resultIsLocal,
+    resultDatasetName,
+    mark,
+    refine,
+    saveModel,
+    closeSession,
+  };
+  return context;
+}
+
+export type VideoSearchContextType = ReturnType<typeof createVideoSearch>;
+
+export function provideVideoSearch(context: VideoSearchContextType) {
+  provide(VideoSearchInjectKey, context);
+}
+
+export function useVideoSearch(): VideoSearchContextType | null {
+  return inject<VideoSearchContextType | null>(VideoSearchInjectKey, null);
+}
diff --git a/client/platform/desktop/router.ts b/client/platform/desktop/router.ts
index 0e7d2527d..1a01849f9 100644
--- a/client/platform/desktop/router.ts
+++ b/client/platform/desktop/router.ts
@@ -10,6 +10,7 @@ import ViewerLoader from './frontend/components/ViewerLoader.vue';
 import PipelinePage from './frontend/components/PipelinePage.vue';
 import ScoringPage from './frontend/components/ScoringPage.vue';
 import ReviewPage from './frontend/components/ReviewPage.vue';
+import QueryPage from './frontend/components/QueryPage.vue';
 
 Vue.use(Router);
 
@@ -31,6 +32,11 @@ export default new Router({
       name: 'training',
       component: TrainingPage,
     },
+    {
+      path: '/query',
+      name: 'query',
+      component: QueryPage,
+    },
     {
       path: '/review',
       name: 'review',
diff --git a/docs/Query.md b/docs/Query.md
new file mode 100644
index 000000000..0cdc125a3
--- /dev/null
+++ b/docs/Query.md
@@ -0,0 +1,63 @@
+# Query
+
+The **Query** page (DIVE Desktop) searches many datasets at once. Pick the datasets, build a search index over them, then search from an image, a frame of a video, or a text description. Hits come back as the same chip grid the Review page uses, and a similarity search can be refined by marking hits correct or incorrect.
+
+Open it from the **Query** tab, or select datasets in the **Library** and click **Index** to open the Index panel with those sequences selected.
+
+## Index panel
+
+Add datasets with the same picker as the Training and Pipelines pages: search the library, add rows one at a time or with **Select all**, and drop them with **Remove all**. Each selected dataset shows whether it is in the search index. **Build index** indexes every selected dataset that is not indexed yet (each row also has its own build button), choosing how the index is made:
+
+* *Around generic detections*: run the generic object detector and describe its boxes.
+* *Detection and tracking*: detect and track, then describe the tracks.
+* *Around existing annotations*: describe the dataset's current annotations.
+* *Whole frames*: describe each frame as a whole, with no detector.
+
+Indexing runs as jobs on the Jobs page; the rows update as they finish. **Build all not indexed** queues every unindexed dataset. All indexed datasets share one index, so a dataset indexed here is also searchable from the viewer's Video Search panel, and the reverse.
+
+## Query panel
+
+The panel is on the left, results on the right.
+
+**Image.** Choose an image file. Drag a box on it to search for one object, or leave the whole image as the exemplar. Press **Search**.
+
+**Video.** Choose one of the listed datasets or a video file, enter a frame number and press **Show frame**, then optionally drag a box on the frame. Press **Search**.
+
+Both run a similarity search over every indexed dataset (limited to the listed datasets unless the switch is turned off). Mark results correct or incorrect and press **Refine** to re-rank; **Hide reviewed** hides the marked ones. **Save model** keeps the refined classifier as a trained pipeline. A saved `.svm` model can also start a search (*Start from a saved model*).
+
+Results can be turned into annotations without leaving the page: accepted results, and results given a type or an edited box, are written to their datasets by **Save** on the results toolbar (rejected results only when typed). Results that overlap existing annotations prompt for whether to keep the originals, replace the overlapped ones, replace every annotation in those sequences, or discard the results; see the Review page docs for details.
+
+**Text.** Type what to find. Sampled frames of every listed dataset (every N frames, up to a per-dataset cap) are searched with the SAM3 text model, which must be installed as a VIAME add-on. Hits show in the grid with their label and score. Each hit offers **Search the index for objects like this one**, which turns it into an image query, and **Open in the annotation viewer**.
+
+Double clicking any result opens its dataset in the viewer at that frame. Coming back to Query afterwards resumes the page as it was left: the exemplar, the results and their marks, unsaved annotation edits, and the grid page, so adjudication carries on where it stopped.
+
+Index builds appear in **Jobs** while preparing and running, with their dataset, indexing method, live stdout/stderr, and final result. Expand the job's output to diagnose failures; the process log is also saved as `runlog.txt` in its working directory. Builds waiting for the GPU appear under **Queued Jobs** as indexing jobs. Startup failures remain in job history.
+
+Selecting a stereo or multicamera sequence uses its first camera in the configured display order. Query shows that camera by name and indexes its media and, for the existing-detections method, its annotations. The other cameras are not indexed automatically. Results refer to the indexed camera, keeping thumbnails and frame numbers aligned with its media.
+
+Inside an annotation sequence, **Video Search** lists the available indexed
+sequences, with an option to search all of them. Selecting an indexed sequence
+limits the ranked results and result grid to that sequence; the underlying
+similarity search still uses the shared database. Changing this selection clears
+the previous results and feedback so the next query starts fresh.
+
+Use **Create index** when no index exists, or **Build a new index** below the
+selector, to open Query's **Index** panel with the current sequence selected.
+Index type, building, and removal are managed on that page.
+
+The Index list survives navigation and restores saved index membership and
+indexing jobs on return. Rows show in-progress builds, successful indexes, or
+failed builds with their job error, even when the job finished on another page.
+
+The top of **Index** lists successfully generated entries in the shared search
+index, independently of the selection used to queue new builds below. There is
+one entry per video or sequence; rebuilding replaces that entry. **Remove from
+index** deletes one sequence's search data, while **Delete entire index** removes
+the whole shared index. Both ask for confirmation and keep source media and
+annotations. Index deletion is disabled while index builds are queued or running.
+
+The sequence editor’s **Video Search** panel is a launch point. Its large search
+buttons open Query and run the selected annotation, image, or saved-model search
+there. The chosen index and annotation crop are preserved; results and refinement
+appear on Query rather than in the sidebar. Leaving the editor still follows the
+normal unsaved-annotation checks.
diff --git a/docs/Review.md b/docs/Review.md
index da63b078c..375dd3661 100644
--- a/docs/Review.md
+++ b/docs/Review.md
@@ -106,3 +106,11 @@ clearing a previous selection. A nonempty selection is retained.
 Stereo and multicamera sequences appear as one entry in the dataset list.
 Reloading or removing that entry affects all cameras. Annotations with the same
 track ID across cameras share one grid cell, showing each camera's view.
+
+## Search results
+
+On DIVE Desktop, the Query page shows ranked similarity results across indexed datasets in the same chip grid, with the same editing. Accept or reject entries with their corner buttons and **Refine** to re-rank; **Hide reviewed** (right of the context slider) takes the accepted and rejected entries out of the grid so only the unmarked ones remain.
+
+Every result is also an annotation in waiting. Typing a type under a chip, or editing its box (the edit action or a right click), gives the result a track of its own in its dataset, built from the result's frames and boxes; the dataset's existing annotations are never edited in place. Such entries show their track id and can be deleted.
+
+**Save** on the results toolbar writes the results that count as annotations: every accepted result (with its type, or `unknown` when none was given), every result given a type, rejected results only when they were given a type, and unmarked results that were typed or box-edited. When any of them overlaps an annotation the dataset already has on the same frame, a dialog asks how to proceed: **Keep originals** saves the other results and leaves the overlapping ones out, **Replace overlapping** deletes just the overlapped annotations before saving, **Replace all annotations** deletes every annotation in those sequences and saves only the results, and **Discard results** saves nothing. **Discard** drops the unsaved results, and leaving the page with unsaved changes asks first. Opening a saved entry selects its track in the viewer. Grid shape, zoom and context settings are shared with Review.
diff --git a/mkdocs.yml b/mkdocs.yml
index 1f2111ddb..a15101bb1 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -73,6 +73,7 @@ nav:
       - Image Enhancements: UI-Image-Enhancements.md
       - Annotation Sets: Annotation-Sets.md
       - Scoring: Scoring.md
+      - Query: Query.md
       - Review: Review.md
     - Keyboard Shortcut Reference: Mouse-Keyboard-Shortcuts.md
     - Advanced features: