@@ -1,12 +1,32 @@
 import Track from 'vue-media-annotator/track';
 import { headTailFeatures } from 'vue-media-annotator/headTail';
 import {
-  autoPopulatePrompt, autoPopulateTarget, boundsIoU, closedRing, polygonBounds, orientLineLike, LINE_PROMPT_FRACTIONS,
+  autoPopulatePrompt, autoPopulateTarget, boundsIoU, closedRing, interiorPromptPoints, polygonBounds, orientLineLike,
+  LINE_PROMPT_FRACTIONS,
 } from './autoPopulate';
 
 it('prompts a box with its centre', () => {
   expect(autoPopulatePrompt({ source: 'box', bounds: [10, 20, 30, 60] })).toEqual({ points: [[20, 40]], labels: [1] });
   expect(autoPopulatePrompt({ source: 'mask', polygons: [] })).toEqual({ points: [], labels: [] });
+  expect(autoPopulatePrompt({ source: 'points', points: [[1, 2], [3, 4]] })).toEqual({ points: [[1, 2], [3, 4]], labels: [1, 1] });
+});
+
+it('samples prompt points inside a mask, spread apart and clear of its holes', () => {
+  const ring: [number, number][] = [[0, 0], [90, 0], [90, 30], [0, 30]];
+  const hole: [number, number][] = [[40, 10], [50, 10], [50, 20], [40, 20]];
+  const points = interiorPromptPoints([{ exterior: ring, holes: [hole] }], 4);
+  expect(points).toHaveLength(4);
+  points.forEach(([x, y]) => {
+    expect(x).toBeGreaterThan(0); expect(x).toBeLessThan(90);
+    expect(y).toBeGreaterThan(0); expect(y).toBeLessThan(30);
+    expect(x >= 40 && x <= 50 && y >= 10 && y <= 20).toBe(false);
+  });
+  const xs = points.map((p) => p[0]);
+  expect(Math.max(...xs) - Math.min(...xs)).toBeGreaterThan(60);
+  // A thin diagonal sliver still yields points on the object, never the empty corners.
+  const sliver: [number, number][] = [[0, 0], [100, 98], [100, 100], [0, 2]];
+  interiorPromptPoints([{ exterior: sliver, holes: [] }]).forEach(([x, y]) => expect(Math.abs(x - y)).toBeLessThan(3));
+  expect(interiorPromptPoints([{ exterior: [[0, 0], [1, 1]], holes: [] }])).toEqual([]);
 });
 
 it('prompts a line with foreground points spread along its length', () => {
 
@@ -1,12 +1,14 @@
 import type Track from 'vue-media-annotator/track';
-import type { RectBounds } from 'vue-media-annotator/utils';
+import { pointInPolygon, RectBounds } from 'vue-media-annotator/utils';
 import type { SegmentationPolygon } from 'dive-common/apispec';
 
 export type Point = [number, number];
 
 export type NewAnnotationGeometry =
   | { source: 'box'; bounds: RectBounds }
   | { source: 'line'; line: Point[] }
+  /** Foreground prompts already known, e.g. points warped from the other stereo camera's mask. */
+  | { source: 'points'; points: Point[] }
   /** A mask that already exists on the detection (point segmentation); nothing to predict. */
   | { source: 'mask'; polygons: SegmentationPolygon[] };
 
@@ -24,6 +26,9 @@ export function autoPopulatePrompt(geometry: NewAnnotationGeometry): { points: P
     return { points: [[(x0 + x1) / 2, (y0 + y1) / 2]], labels: [1] };
   }
   if (geometry.source === 'mask') return { points: [], labels: [] };
+  if (geometry.source === 'points') {
+    return { points: geometry.points.map((p) => [...p] as Point), labels: geometry.points.map(() => 1) };
+  }
   const { line } = geometry;
   if (line.length < 2) return { points: line.map((p) => [...p] as Point), labels: line.map(() => 1) };
   const total = line.slice(1).reduce((sum, p, i) => sum + Math.hypot(p[0] - line[i][0], p[1] - line[i][1]), 0);
@@ -72,6 +77,48 @@ export function boundsIoU(a: RectBounds, b: RectBounds): number {
   return union > 0 ? intersection / union : 0;
 }
 
+/** Grid resolution across a mask's bounds when sampling prompt points inside it. */
+const INTERIOR_GRID = 9;
+
+/**
+ * Up to `count` points inside a mask, spread across it: the one nearest its
+ * centre first, then repeatedly the candidate farthest from those chosen.
+ * Points inside the object warp to the other camera far more reliably than a
+ * box's corners, which sit on the background.
+ */
+export function interiorPromptPoints(polygons: SegmentationPolygon[], count = 5): Point[] {
+  const xy = ([x, y]: Point) => ({ x, y });
+  const valid = polygons.filter((polygon) => polygon.exterior.length >= 3);
+  if (!valid.length) return [];
+  const [x0, y0, x1, y1] = polygonBounds(valid.flatMap((polygon) => polygon.exterior));
+  const inside: Point[] = [];
+  for (let i = 0; i < INTERIOR_GRID; i += 1) {
+    for (let j = 0; j < INTERIOR_GRID; j += 1) {
+      const point: Point = [
+        x0 + ((i + 0.5) / INTERIOR_GRID) * (x1 - x0),
+        y0 + ((j + 0.5) / INTERIOR_GRID) * (y1 - y0),
+      ];
+      if (valid.some((polygon) => pointInPolygon(xy(point), polygon.exterior.map(xy), polygon.holes.map((h) => h.map(xy))))) {
+        inside.push(point);
+      }
+    }
+  }
+  if (!inside.length) return [];
+  const centre: Point = [(x0 + x1) / 2, (y0 + y1) / 2];
+  const distance = (a: Point, b: Point) => Math.hypot(a[0] - b[0], a[1] - b[1]);
+  const chosen = [inside.reduce((best, p) => (distance(p, centre) < distance(best, centre) ? p : best))];
+  while (chosen.length < count && chosen.length < inside.length) {
+    const next = inside
+      .filter((p) => !chosen.includes(p))
+      .reduce((best, p) => {
+        const gap = (q: Point) => Math.min(...chosen.map((c) => distance(q, c)));
+        return gap(p) > gap(best) ? p : best;
+      });
+    chosen.push(next);
+  }
+  return chosen;
+}
+
 /**
  * Head/tail derived independently on each stereo camera can come out flipped;
  * order this pair to run the same way as the other camera's line.
 
@@ -87,6 +87,7 @@ export type NewAnnotationGeometryParams = {
 } & (
   | { source: 'box'; bounds: [number, number, number, number] }
   | { source: 'line'; line: [number, number][] }
+  | { source: 'points'; points: [number, number][] }
   | { source: 'mask'; polygons: SegmentationPolygon[] }
 );
 
 
@@ -188,6 +188,22 @@ it('derives head/tail for a point-segmented mask without predicting again', asyn
   expect(lined.track.getFeature(0)[0]?.head).toEqual([2, 2]);
 });
 
+it('segments from given prompt points, boxes the mask, and reports it even when nothing is stored', async () => {
+  const h = harness();
+  const onMask = vi.fn();
+  h.services.predict.mockResolvedValue({ success: true, polygons: components });
+  expect(await populateAnnotation({
+    camera: 'right', trackId: 1, frameNum: 0, source: 'points', points: [[3, 3], [25, 5]],
+  }, { mask: false, points: false, onMask }, h.services)).toBe('applied');
+  expect(h.services.predict).toHaveBeenCalledWith(expect.objectContaining({
+    points: [[3, 3], [25, 5]], pointLabels: [1, 1], multimaskOutput: false,
+  }));
+  expect(onMask).toHaveBeenCalledWith(components);
+  expect(h.track.getFeature(0)[0]?.bounds).toEqual([0, 0, 30, 10]);
+  expect(h.track.getPolygonFeatures(0)).toHaveLength(0);
+  expect(h.services.keypoints).not.toHaveBeenCalled();
+});
+
 it('extracts points from all components when storing the mask is disabled', async () => {
   const h = harness();
   h.services.predict.mockResolvedValue({ success: true, polygons: components });
 
@@ -23,6 +23,8 @@ export interface AutoPopulateOptions {
   orientLike?: [number, number][] | null;
   /** The box was mapped from the other stereo camera: refit it when the mask disagrees with it. */
   fitBoxToMask?: boolean;
+  /** Receives the mask the annotation was segmented to, whether or not it is stored. */
+  onMask?: (polygons: SegmentationPolygon[]) => void;
 }
 
 async function predictMask(
@@ -62,6 +64,7 @@ export default async function populateAnnotation(
   }
   const target = currentTarget();
   if (!target) return 'changed';
+  options.onMask?.(polygons);
   const { track, feature } = target;
   const features = feature.geometry?.features ?? [];
   const hasPolygon = features.some((f) => f.geometry.type === 'Polygon');
@@ -78,7 +81,7 @@ export default async function populateAnnotation(
     })));
   }
   const maskBounds = polygonBounds(polygons.flatMap((polygon) => polygon.exterior));
-  if (options.points && params.source === 'line') {
+  if ((options.points && params.source === 'line') || params.source === 'points') {
     track.setFeature({ frame: params.frameNum, keyframe: true, bounds: maskBounds });
   } else if (options.fitBoxToMask && params.source === 'box'
     && boundsIoU(params.bounds, maskBounds) < MAPPED_BOX_MIN_IOU) {
 
@@ -16,7 +16,7 @@ import CalibrationMenu from 'dive-common/components/CalibrationMenu.vue';
 import SidebarContext from 'dive-common/components/SidebarContext.vue';
 import context from 'dive-common/store/context';
 import { usePrompt } from 'dive-common/vue-utilities/prompt-service';
-import { SegmentationPredictRequest } from 'dive-common/apispec';
+import { SegmentationPredictRequest, SegmentationPolygon } from 'dive-common/apispec';
 import { clientSettings } from 'dive-common/store/settings';
 import { isStereoscopicDatasetConfig } from 'dive-common/multicamDisplay';
 import type {
@@ -45,6 +45,7 @@ import {
   openLink,
   setScoringAnnotationPreviewFile,
 } from 'platform/desktop/frontend/api';
+import { interiorPromptPoints, polygonBounds } from 'dive-common/use/autoPopulate';
 import populateAnnotation from '../autoPopulate';
 import Export from './Export.vue';
 import JobTab from './JobTab.vue';
@@ -1186,7 +1187,9 @@ export default defineComponent({
 
     // In-flight auto-populate passes for freshly drawn shapes, so the stereo
     // transfer of the same shape can populate its mapped copy afterwards.
-    const pendingAutoPopulate = new Map<string, Promise<void>>();
+    /** Outcome of one auto-populate pass; the mask is reported even when only points were asked for. */
+    type AutoPopulateOutcome = { status: 'applied' | 'changed' | 'failed' | 'skipped'; polygons: SegmentationPolygon[] };
+    const pendingAutoPopulate = new Map<string, Promise<AutoPopulateOutcome>>();
     const autoPopulateKey = (camera: string, trackId: number, frameNum: number) => `${camera}:${trackId}:${frameNum}`;
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -1785,6 +1788,9 @@ export default defineComponent({
               });
             }
           }
+        } else if (params.type === 'box'
+          && sourceAutoPopulate && await mapBoxThroughSourceMask(sourceAutoPopulate, params, otherCamera)) {
+          // The other camera's box came from its own segmentation.
         } else if (params.type === 'box') {
           // Convert box bounds to 4 corner points
           const [x1, y1, x2, y2] = params.bounds;
@@ -2130,18 +2136,21 @@ export default defineComponent({
     async function autoPopulateGeometry(
       params: NewAnnotationGeometryParams,
       stereo?: { orientLike: [number, number][] | null; fitBoxToMask: boolean },
-    ) {
+    ): Promise<AutoPopulateOutcome> {
       const { autoPopulateMask, autoPopulatePoints } = clientSettings.trackSettings.newTrackSettings;
-      if (!autoPopulateMask && !autoPopulatePoints) return;
       const cameraStore = viewerRef.value?.cameraStore;
-      if (!cameraStore) return;
+      if ((!autoPopulateMask && !autoPopulatePoints) || !cameraStore) return { status: 'skipped', polygons: [] };
+      let polygons: SegmentationPolygon[] = [];
       // Resolve the requested camera independently of recipe initialization and
       // whichever camera is selected when asynchronous work finishes.
       const datasetId = params.camera === 'singleCam' ? props.id : `${props.id}/${params.camera}`;
       autoPopulateActive.value += 1;
       try {
         const result = await populateAnnotation(params, {
-          mask: autoPopulateMask, points: autoPopulatePoints, ...stereo,
+          mask: autoPopulateMask,
+          points: autoPopulatePoints,
+          onMask: (mask) => { polygons = mask; },
+          ...stereo,
         }, {
           getTrack: () => cameraStore.getPossibleTrack(params.trackId, params.camera),
           getMedia: async () => {
@@ -2166,10 +2175,12 @@ export default defineComponent({
         if (result === 'changed' && cameraStore.getPossibleTrack(params.trackId, params.camera)) {
           autoPopulateMessage.value = `Auto-populate skipped for track ${params.trackId}: the annotation changed while the request was running.`;
         }
+        return { status: result, polygons };
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         autoPopulateMessage.value = `Auto-populate — track ${params.trackId}, ${params.camera}, frame ${params.frameNum}: ${message}`;
         console.warn('[AutoPopulate] Could not populate the new annotation:', err);
+        return { status: 'failed', polygons };
       } finally {
         autoPopulateActive.value -= 1;
       }
@@ -2181,15 +2192,15 @@ export default defineComponent({
      * so a derived head/tail can follow the source's direction.
      */
     async function autoPopulateOtherCamera(
-      sourceJob: Promise<void>,
+      sourceJob: Promise<unknown>,
       sourceCamera: string,
       mapped: NewAnnotationGeometryParams,
-    ) {
+    ): Promise<AutoPopulateOutcome> {
       await sourceJob;
       const cameraStore = viewerRef.value?.cameraStore;
-      if (!cameraStore) return;
+      if (!cameraStore) return { status: 'skipped', polygons: [] };
       const sourceTrack = cameraStore.getPossibleTrack(mapped.trackId, sourceCamera);
-      await autoPopulateGeometry(mapped, {
+      const outcome = await autoPopulateGeometry(mapped, {
         orientLike: getStereoLineEndpoints(sourceTrack, mapped.frameNum),
         fitBoxToMask: true,
       });
@@ -2200,6 +2211,45 @@ export default defineComponent({
           console.warn('[Stereo] Measurement update failed:', err);
         }
       }
+      return outcome;
+    }
+
+    /**
+     * With auto-segmentation on, a new box reaches the other camera through
+     * its mask rather than its corners: a few points inside the source mask
+     * are warped (their disparities are stable, unlike corners that sit on the
+     * background), the other camera is segmented from them, and its box is
+     * that mask's bounds. False means fall back to warping the corners.
+     */
+    async function mapBoxThroughSourceMask(
+      sourceJob: Promise<AutoPopulateOutcome>,
+      params: { camera: string; trackId: number; frameNum: number },
+      otherCamera: string,
+    ): Promise<boolean> {
+      const source = await sourceJob;
+      const prompts = interiorPromptPoints(source.polygons);
+      if (!prompts.length) return false;
+      const response = await stereoTransferPoints({ points: prompts });
+      const warped = (response.transferredPoints ?? [])
+        .filter((p): p is [number, number] => !!p && Number.isFinite(p[0]) && Number.isFinite(p[1]));
+      const cameraStore = viewerRef.value?.cameraStore;
+      if (!response.success || !warped.length || !cameraStore) return false;
+      const track = getOrCreateStereoTrack(cameraStore, params.trackId, params.camera, otherCamera, params.frameNum);
+      if (!track) return false;
+      // A placeholder for the segmentation to replace; it needs a feature to target.
+      track.setFeature({
+        frame: params.frameNum,
+        flick: 0,
+        bounds: polygonBounds(warped),
+        keyframe: true,
+        interpolate: false,
+      });
+      const outcome = await autoPopulateOtherCamera(Promise.resolve(), params.camera, {
+        camera: otherCamera, trackId: params.trackId, frameNum: params.frameNum, source: 'points', points: warped,
+      });
+      if (outcome.status === 'applied' || outcome.status === 'changed') return true;
+      track.deleteFeature(params.frameNum);
+      return false;
     }
 
     /** A brand-new box or line just got drawn, or a brand-new mask point-segmented. */
@@ -2208,7 +2258,7 @@ export default defineComponent({
       if (!autoPopulateMask && !autoPopulatePoints) return;
       if (params.source === 'mask' && !autoPopulatePoints) return;
       const key = autoPopulateKey(params.camera, params.trackId, params.frameNum);
-      const job: Promise<void> = autoPopulateGeometry(params).finally(() => {
+      const job: Promise<AutoPopulateOutcome> = autoPopulateGeometry(params).finally(() => {
         if (pendingAutoPopulate.get(key) === job) pendingAutoPopulate.delete(key);
       });
       pendingAutoPopulate.set(key, job);