diff --git a/.github/tasks.md b/.github/tasks.md
index 2b7f9ad1..e368a992 100644
--- a/.github/tasks.md
+++ b/.github/tasks.md
@@ -1,724 +1,570 @@
 ## Tasks
 
-Bitmask/segmentation viewer performance work, driven by the model-registry
-integration. Items 1/3/4/5 touch this repo; item 2 is model-registry only.
-
-- [x] 1. Cache the bitmask hover outline on the render object
-  - `draw_bitmask` allocates a canvas and does 8 dilation blits on every draw
-    while hovered. Cache on `_mask_render`, which already invalidates on mask
-    version + color change.
-- [x] 2. (model-registry) Drop `wrapperSize` from `viewerKey`
-  - A container resize currently forces a full ULabel rebuild.
-- [x] 3. Windowed `ULabelMask`
-  - Store pixels for a sub-rectangle instead of the full frame, keeping the
-    public API in image coordinates. Removes the `objects x width x height`
-    memory bound, so model-registry can go back to one annotation per Encord
-    object instead of one merged mask per class.
-  - Accept an optional `box` on the raw payload so callers can hand over an
-    already-cropped buffer with no copy.
-  - Grow the window on paint so editing still works.
-  - Verified in the browser on run #3: GT renders 99 separate objects on the
-    densest item sampled (was 1 merged mask per class), item-to-item switching
-    ~90 ms, heap flat around 1 GB with no OOM.
-- [x] 4. Swap subtasks in place instead of rebuilding the instance
-  - Add `replace_subtasks`, so a GT/Pred/Diff switch reuses the decoded image,
-    listeners and toolbox rather than running `destroy()` + `init()`.
-  - Only the annotation set can change: `replace_subtasks` returns `null` when
-    the subtask shape (keys, allowed modes, class defs) differs, so the caller
-    knows it still has to rebuild.
-  - Verified in the browser on run #3: four consecutive confidence-threshold
-    changes in pred mode produced zero rebuilds (previously one full
-    `destroy()` + `init()` each). Mode switches on that run still rebuild
-    because its GT `Row` class is a polyline while pred renders it as a
-    bitmask, which is a genuine shape change.
-- [x] 5. Decode RLE off the main thread
-  - (model-registry) move `rleRecordToRawMask` into a worker and transfer the
-    cropped buffers back.
-  - Verified in the browser: GT still renders after the move, heap 193 MB on a
-    fresh load, no page errors.
-
-## Architecture: subtask per data set, class as class
-
-The viewer models GT/Pred/Diff as *per-class* subtasks whose set changes with
-the view mode, so a mode switch is a subtask-shape change and forces a rebuild.
-Diff goes further and replaces the class with the outcome (`FP`/`FN`/`TP`), so
-class identity is destroyed and "false negatives for Crop" is inexpressible.
-
-Target: three fixed subtasks (`groundtruth`, `prediction`, `diff`), each with
-the real class defs, present in every mode with only their annotations
-swapping. Outcome moves to annotation metadata. This is also what diff-driven
-groundtruth editing needs, since applying a diff region to a GT mask requires
-both loaded together with class identity intact.
-
-- [x] 6. Per-annotation color resolver
-  - `get_annotation_color` looks up `color_info[class_id]`. Add an optional
-    per-annotation hook so the diff subtask can color by outcome while keeping
-    real classes. Every draw path already funnels through this one function.
-  - Added `annotation_color_resolver` to `Configuration` and the constructor
-    args. Returning `null` falls back to the class color, and the confidence
-    gradient still applies either way.
-- [x] 7. Class-aware annotation canvases
-  - `get_next_available_canvas_id` packs annotations into the first non-full
-    canvas regardless of class, and per-subtask opacity/z-index is what dims
-    inactive layers today. Group canvases by class so the same CSS mechanism
-    gives per-class dimming and bring-to-front once classes share a subtask.
-  - Canvases now nest under a `div.class_canvasses` per class, and
-    `set_active_class_layer(subtask, class_id, inactive_opacity)` mirrors
-    `readjust_subtask_opacities` one level down. Verified: lint clean, 161
-    jest tests and 102 Chromium e2e tests pass.
-- [x] 8. `hidden_by` visibility map
-  - Mirror the keyed composition of `deprecated_by` for view filtering.
-    Separate from `deprecated`, which means "deleted" and is about to start
-    flowing back to Encord.
-  - Added `mark_hidden` plus a public `filter_annotations(hidden_by_key,
-    should_hide, subtask, redraw)`. Keys compose, so class/outcome/confidence
-    controls can be applied in any order. `hidden` gates drawing, edit
-    candidates, and annotation navigation, and also skips bulk polygon delete
-    so it can't remove something the user can't see. Export is untouched.
-- [x] 9. (model-registry) Rebuild subtask construction on the new model
-  - Three fixed subtasks, real class defs, `match_outcome` in
-    `annotation_meta`, Encord object hash carried on GT annotations, and class
-    chips driving filters rather than `set_subtask`.
-  - `buildViewSubtasks` replaces `buildClassSubtasks`/`buildDiffSubtasks`: all
-    three subtasks share one class list and one `allowed_modes` union derived
-    from the ontology, so the subtask shape no longer changes with the data.
-  - Diff layers by outcome instead of class, which class-keyed canvases alone
-    could not express. Added `annotation_canvas_group_resolver` to ULabel and
-    generalized `set_active_class_layer`'s `inactive_opacity` to accept a
-    per-key map, preserving the old fn 0.6 / fp 0.6 / tp 0.4 dim values.
-  - Sharing class ids across subtasks tripped ULabel's duplicate-id warning,
-    which checked the global `valid_class_ids`. Scoped the check to duplicates
-    within a subtask and made `valid_class_ids` a true set. Colors are written
-    idempotently and `findAllClassDefinitions` already de-duplicates by id, so
-    the confidence slider still shows one entry per class.
-  - Verified in browser on eval run #3: all three modes paint with no console
-    warnings; `canvasses__prediction` groups by class id (`0`/`1`/`2`) and
-    `canvasses__diff` by outcome (`tp`/`fp`/`fn`), with the selected layer at
-    opacity 1 / z-index 76 and the rest dimmed. GT shows polyline and bitmask
-    classes together in one subtask. Lint clean, 166 jest tests pass.
-
-## Plan: subtask-per-class + subtask-per-outcome architecture
-
-Supersedes the "three fixed subtasks" model (items 4/6/7/8/9 above). For a job
-with classes {crop, weed, row}: subtasks `crop`/`weed`/`row` hold GT *or* pred
-annotations (swapped on mode change), plus fixed `tp`/`fp`/`fn` subtasks for
-diff whose class defs are the *real* classes. Rationale (from design review):
-
-- Per-class fly-to in gt/pred and per-outcome fly-to in diff fall out of
-  ULabel's existing subtask-scoped `fly_to_next_annotation` — no new nav code.
-- "FN for crop" = crop class inside the `fn` subtask; `ClassCounter` on `fn`
-  shows per-class FN counts natively. No `match_outcome` metadata.
-- Subtask keys are stable across items/modes/thresholds (they change only with
-  the ontology), so annotation swaps never hit a shape change.
-- `viewerKey` in model-registry already encodes the shape, making ULabel-side
-  shape checking redundant; per-subtask memos + reference equality in the
-  frontend make ULabel-side staleness diffing redundant.
-
-Sequencing: 1.1 and 1.4 remove API the current frontend still calls, so those
-removals ship in a ULabel version that model-registry adopts in the same PR as
-its Phase 3 migration (frontend stays pinned until then).
-
-### Phase 0 - confidence card positioning (in progress)
-
-- [x] 0.1 Fix card geometry: include the card's natural flow offset
-  (`offsetTop - margin`) and hug the button ring (`button_half + gap`) in
-  both modes; read-only keeps ring flow space via `visibility: hidden`, so
-  the card lands in the same spot with or without buttons.
-- [x] 0.2 Rewrite the two failing e2e specs to assert flip geometry (card vs
-  anchor) instead of the old literal `-9.5em`/`-1em` margins.
-- [ ] 0.3 Missing card tests (gaps found in audit):
-  - read-only parity: same annotation, `read_only` toggled, card rect equal
-    (protects the visibility-preserves-flow invariant)
-  - ring proximity upper bound: card bottom within
-    `button_half * scale + gap + slack` of the anchor (the "too high" bug
-    passes the current >=5px assertions)
-  - single-class demo variant: card position at the 0.666 dialog scale
-    (only the 0.5 mcm path is exercised today)
-
-### Phase 1 - ULabel removals (this repo)
-
-- [x] 1.1 Remove `replace_subtasks`, `_subtask_shape_matches`,
-  `_subtask_annotations_unchanged` and their `index.d.ts` entries.
-  `set_annotations` becomes the single swap path. (Also moots the mid-yield
-  destroy return-value bug and the `config.subtasks` retention concern from
-  the branch review.) No tests to delete (browser-verified only); add a
-  regression test for the frontend's pattern: N sequential per-subtask
-  `set_annotations` swaps on a live instance.
-- [x] 1.2 Add `skip_toolbox_update = false` param to `set_annotations` so the
-  frontend can batch N per-subtask swaps with one `update_filter_distance` +
-  toolbox redraw at the end (expose a small `refresh_toolbox()` if needed).
-  Unit tests: flag suppresses toolbox/filter updates; `refresh_toolbox()`
-  triggers them once.
-- [x] 1.3 Remove the dead `hidden` machinery: `hidden`/`hidden_by` fields,
-  `mark_hidden`, `filter_annotations`, `HiddenBy`/`ValidHiddenBy` types, and
-  the gates in draw / suggest_edits / fly_to / nav toast / bulk delete.
-  No consumer exists (verified in model-registry) and the new architecture
-  covers visibility with subtask structure + vanish + layer dimming.
-- [x] 1.4 Remove all three resolvers (`annotation_color_resolver`,
-  `annotation_canvas_group_resolver`, `annotation_display_name_resolver`).
-  Every subtask is single-class with its own id, color, and name (outcome
-  subtasks are literally named "True Positive" etc., so the hover card reads
-  the same through the plain class-name path). (Class-grouped canvases +
-  `set_active_class_layer` were initially kept, then removed in 2.3.)
-- [x] 1.5 Remove the per-subtask back canvas. VERIFIED vestigial: write-only
-  since the first commit (Nov 2020) - assigned at init, nulled in destroy,
-  zero draw calls ever; all rendering targets front/annotation/demo contexts
-  and the image is an `<img>`. Not in README/api_spec/index.d.ts; no id
-  references in tests, demos, or model-registry; all src selectors touching
-  it are class-based (no positional/stacking assumptions).
-  IMPLEMENTED: element creation, `canvas_bid_pfx`,
-  `subtask.canvas_bid`, `state.back_context` (init/destroy/types), test
-  fixtures, and stale comments removed; breaking-change CHANGELOG entry added.
-  - [x] Local validation: lint + build + 166 jest pass
-
-### Phase 2 - ULabel changes (this repo)
-
-- [x] 2.1 `ClassCounter` options (config `class_counter_toolbox_item` + a
-  runtime setter, since view mode lives in the host):
-  - `subtasks: string[] | "current"` - which subtasks to count
-  - `layout: "current" | "grouped" | "flat"`
-  ClassCounter has zero tests today - backfill current behavior (per-class
-  counts, deprecated skipped) alongside the new options.
-- [x] 2.2 Public `set_class_color(class_id, color, redraw = true)`: writes
-  `color_info`, syncs the toolbox swatch + id-dialog pie, optional redraw.
-  Refactor `RecolorActive.update_color` (private, does the same steps by
-  hand) to call it; add to `index.d.ts`. Replaces raw `color_info` mutation
-  in model-registry's recolor effect, which currently skips the pie sync.
-  Unit tests: color_info write, swatch/pie sync, redraw flag both ways.
-- [x] 2.3 Remove `set_active_class_layer` and class-grouped canvases entirely
-  (supersedes the 1.4 "keep" decision). With every subtask single-class
-  (3.4), a subtask has exactly one canvas group, so within-subtask layer
-  dimming has nothing to act on; class visibility is expressed with subtasks
-  (vanish / `readjust_subtask_opacities`). Removes: the method + 
-  `active_class_layer` state and its `get_edit_candidates` gate, the
-  `div.class_canvasses` wrappers + CSS, `class_key` bookkeeping in
-  `annotation_contexts`, `get_canvas_class_key` / `get_class_canvasses_id` /
-  `get_annotation_canvas_group`, the class_id params on the canvas-creation
-  path, and the `index.d.ts` entries. Recoverable from git history if a
-  multi-class subtask ever returns.
-
-### Phase 3 - model-registry
-
-- [x] 3.1 `buildViewSubtasks` -> per-class specs (single real class each,
-  narrow allowed_modes) + `tp`/`fp`/`fn` specs (single outcome class each,
-  per 3.4). Keys derived from the run-selection label union via
-  `classSubtaskKeys` (slugified, deduped, never colliding with outcome keys).
-- [x] 3.2 Replace the monolithic `subtasks` memo with per-subtask annotation
-  memos; push changes via `set_annotations(annos, key, skip_toolbox_update)`
-  per changed subtask (annotation-id signature diff in `UlabelCanvas`, since
-  ids are content-derived), final `refresh_toolbox()`.
-- [x] 3.3 Mode switch: gt<->pred swaps class-subtask annotations; diff mode
-  swaps outcome-subtask annotations. Explicit vanish proved unnecessary:
-  fetching is mode-gated, so the non-active mode's subtasks are swapped to
-  empty and render nothing. Inactive-subtask dimming keeps the old 0.4 for
-  class subtasks; outcome subtasks carry `inactive_opacity: 1` so all three
-  outcomes stay at full opacity (preserves item 10's behavior).
-- [x] 3.4 Outcome subtasks are single-class (TP=0, FP=1, FN=2 fixed ids
-  first; real classes at 3..N+2), colors from `useDiffColors`. Dropped
-  `match_outcome` metadata, `outcomeOf`, and all resolver usage; the hover
-  card names outcomes through the plain class-name path.
-- [x] 3.5 Dropped `color` from the `viewerKey` shape (keys/ids/names/modes
-  kept). Recolor effect rewritten on `set_class_color` (2.2): registry
-  classes by name, outcome classes by fixed id -> `useDiffColors`; batched
-  with `redraw = false` + one final `redraw_all_annotations()`.
-- [x] 3.6 Class chips: gt/pred -> `set_subtask(class_key)`; diff -> chip-driven
-  annotation swap (only the active class's outcomes are loaded, per 3.4).
-  The Diff Colors legend rows additionally select the current *outcome*
-  subtask, scoping hover + Tab navigation (hover is subtask-scoped now).
-  ClassCounter runs `layout: "flat"` over class subtasks in gt/pred and over
-  outcome subtasks in diff via `set_class_counter_options`.
-- [x] 3.7 Kept: ConfidenceSlider flow as-is (hidden DOM sliders driven from
-  the sidebar; latent-FN filter override untouched; per-class slider ids and
-  `default_values` moved to the 3..N+2 range with `target_class_ids` so
-  outcome classes never get sliders), segmentation threshold scrubs as
-  per-subtask swaps (only stale subtasks re-import via the signature diff).
-
-### Verification
-
-- [ ] V1 ULabel: lint + jest + e2e green after each phase; each item above
-  carries its own test additions (0.3, 1.1, 1.2, 2.1-2.3).
-- [ ] V2 model-registry on eval run #3: mode switches produce zero rebuilds;
-  threshold scrub swaps only affected subtasks; Tab cycles within
-  class (gt/pred) and outcome (diff); FN-per-class counts visible; heap
-  comparable to the 3-subtask baseline after back-canvas removal.
-
-
-
-- [x] 10. Show every diff outcome at once, and keep the hover card off the annotation
-  - (model-registry) Dropped the TP/FP/FN layer picker: diff mode now calls
-    `set_active_class_layer(key, null, 1)` so all three outcome groups stay at
-    full opacity. A null active layer is also what makes them all hover
-    targets, since `get_edit_candidates` skips groups that aren't active.
-    Passing the opacity explicitly matters: with no active class every group
-    takes the `inactive_opacity` branch, so the default would dim all of them.
-    The sidebar "Diff Colors" rows are now a legend plus recolor.
-  - Added `annotation_display_name_resolver` to ULabel, alongside the existing
-    color and canvas-group resolvers, so the hover card can name the diff
-    outcome instead of the class. Every diff annotation carries the same class,
-    which made the old class name useless there.
-  - The hover card was anchored at the containing box's centre, so it covered
-    whatever was under the cursor. It now clears the box by half its on-screen
-    height plus a gap, flipping below only when there isn't room above.
-    Offsets are divided by the dialog container's CSS scale (0.5 / 0.66666
-    from `.global_edit_suggestion`), which otherwise halves them.
-  - Verified in browser on eval run #3 item 503: `canvasses__diff` holds `fn`,
-    `fp` and `tp` all at opacity 1, each is hover-targetable, the card reads
-    "True Positive" / "False Negative", and it sits a 10 px gap above the
-    hovered box in every sampled position. Lint clean in both repos.
-
-- [x] 11. Hover on the annotation boundary, not its containing box
-  - `get_edit_candidates` already hit-tests exactly (`get_pixel` for bitmasks,
-    point-in-polygon for polygons), so this cost nothing extra. The stray
-    hovers came from the fallback underneath: when nothing contains the
-    cursor, it still picked the smallest annotation whose *containing box*
-    was within `dst_thresh`. That fallback exists so you can grab an
-    annotation to edit it, which a read-only subtask never needs.
-  - Now skipped when the subtask is read-only and the spatial type has an
-    exact test. Types without one (polyline, tbar, contour) keep the box
-    fallback, so they stay hoverable.
-  - Verified on run #3 item 503: across six probes the hover card appeared if
-    and only if the cursor was over a painted mask pixel, comparing against
-    the coordinates ULabel itself received. GT polylines still hover and read
-    "Row". 166 unit tests pass.
-
-## Plan: three fixed subtasks, outcome as class, filter as subtask state
-
-Supersedes the subtask-per-class + subtask-per-outcome plan (phases 0-3).
-Branch `three-fixed-subtasks`, cut from `cropped-bitmasks-prepare`.
-
-The viewer slices three ways - source (GT / a run's predictions), class, and
-diff outcome - but ULabel has two structural slots (subtask, class within
-subtask). Every layout so far is a different way of cramming three into two:
-
-- Per-class subtasks whose set changed with the mode (pre-256), so every mode
-  switch was a `destroy()` + `init()`: flicker, and zoom lost.
-- Three fixed subtasks with outcome in `annotation_meta` (256). The diff
-  subtask told ULabel its annotations were crops and used resolvers to draw
-  them as FPs, so `ClassCounter`, the confidence slider, the colour swatch and
-  the id dialog all disagreed with the canvas.
-- One subtask per class plus `tp`/`fp`/`fn` (257). Every subtask is
-  single-class, so `single_class_mode` disables the reclassify pie, force-
-  overwrites `classification_payloads` after edits, fragments undo into N
-  stacks, and scopes hover to the pre-selected class. Subtask count grows
-  with the ontology.
-
-Target - three subtasks, fixed at construction, never rebuilt:
-
-| key | classes | ids | read_only | contents |
-| --- | --- | --- | --- | --- |
-| `groundtruth` | all real classes | 3..N+2 | no | GT; never swapped |
-| `prediction` | all real classes | 3..N+2 | yes | selected run's predictions |
-| `diff` | TP / FP / FN | 0/1/2 | yes | diff(GT, run), filtered class |
-
-Why this shape:
-
-- `groundtruth` is multi-class, so `single_class_mode` stays false: the
-  reclassify pie works, undo is one stream, and any annotation is grabbable
-  without first selecting its class. Every layout except 256 failed this, and
-  it is the whole point of editing in ULabel rather than a viewer.
-- `diff`'s classes *are* the outcomes, so colour, `ClassCounter`, the id
-  dialog and the hover card agree with the canvas through the plain class
-  path. No resolvers, no `match_outcome`.
-- `groundtruth` is never swapped, because `actions.stream` points into it.
-  Everything else is read-only, so swapping there costs nothing.
-- Diff is always GT vs one run, never run vs run, so one `prediction` and one
-  `diff` slot suffice. Switching runs swaps their contents at fixed zoom - a
-  blink comparator, which beats side-by-side for spotting differences.
-- Three image-sized front canvases regardless of ontology size, which settles
-  the V2 memory question instead of leaving it assumed.
-
-Class focus becomes subtask *state*, not structure and not a per-annotation
-flag. State survives `set_annotations`, so swapped-in annotations are filtered
-the moment they land - the bug `layerEpoch` existed to paper over - and
-changing the filter is a field write rather than a pass over every annotation.
-Do not call it "active class": `get_active_class_id` already means the class
-assigned to newly drawn annotations.
-
-### Phase 4 - ULabel: filtering and layer control
-
-- [x] 4.1 `state.class_filter: number | null` plus
-  `set_class_filter(subtask_key, class_id | null)`. Gate on it in
-  `draw_annotation`, `get_edit_candidates`, `fly_to_annotation`, the
-  visible-count loop, and `annotation_list`. Explicitly *not* in the bitmask
-  geometry paths (`merge/join`, `resolve_bitmask_overlap`): a filtered mask is
-  still real data and must keep acting as a stroke barrier, or painting over
-  hidden pixels silently breaks the no-overlap invariant.
-  - **Superseded by 4.5**: renamed to `set_class_focus` / `focused_class` /
-    `is_annotation_defocused`, and the draw gate dims instead of hiding. The
-    five gate sites and the geometry carve-out are unchanged.
-  - Added `is_annotation_filtered(annotation, subtask_key)` as the single
-    gate, and both methods to `index.d.ts`. Setting a filter drops
-    `hovered_annid` and `fly_to_idx`, which may now point off screen.
-  - Rejects a class id the subtask doesn't declare, so a stale host-side id
-    can't silently blank a layer.
-  - Tests in `tests/class_focus.test.js`, including the property that
-    motivated state over a per-annotation flag: annotations swapped in after
-    the focus is set are scoped on arrival, with no re-application step.
-  - Local validation: lint + build + 196 jest pass.
-- [x] 4.2 `set_subtask_opacity(subtask_key, value)` wrapping
-  `readjust_subtask_opacities`, which already drives `div#canvasses__{key}`
-  from the toolbox slider. Lets the host dim backing layers at runtime and
-  retires the `inactive_opacity: 1` construction hack from 3.3.
-  - Writes `inactive_opacity` as well as the DOM, because `set_subtask`
-    resets every non-current slider from that field; without it a host-set
-    opacity silently reverts on the next subtask switch. 6 tests in
-    `tests/set_subtask_opacity.test.js`, one of which is exactly that.
-- [x] 4.3 `set_annotations_batch(Record<subtask_key, annotations>)` - one
-  loader show/hide, one filter + opacity pass, one toolbox update. Today N
-  subtasks means N spinner cycles and 2N awaits; a run switch swaps
-  `prediction` and `diff` and has to be one atomic, flicker-free update for
-  the blink comparator to work. Removes the host's `pushChainRef`.
-  - Extracted the per-subtask swap body into `_swap_subtask_annotations` so
-    `set_annotations` and the batch share it; `set_annotations` keeps its
-    signature and behaviour.
-  - Unknown subtask keys are dropped with a warning rather than aborting, so
-    one stale key can't lose the whole swap. An all-unknown map does not
-    cycle the loader.
-  - 8 tests in `tests/set_annotations_batch.test.js` covering the batching
-    contract (one loader, one `refresh_toolbox`, destroyed-mid-swap
-    unwinding). The swap body itself stays covered by the bitmask e2e specs.
-- [x] 4.4 `set_class_colors(Record<class_id, color>)` - one
-  `rebuild_id_dialog_pies()` for the whole map. `set_class_color` rebuilds
-  every subtask's pies on each call even with `redraw = false`, so the host's
-  batched recolor loop is O(N^2) DOM churn.
-  - Split the cheap half (`color_info` + toolbox swatch) into
-    `_apply_class_color`; both entry points share it and `set_class_color` is
-    unchanged externally.
-  - Also fixed the same quadratic loop *inside* ULabel:
-    `RecolorActiveItem.read_local_storage` called `set_class_color` per class
-    at construction, rebuilding every subtask's pies once per class.
-  - 5 tests added to `tests/set_class_color.test.js`.
-- [x] 4.5 Class focus dims rather than hides. 4.1 skipped non-focused
-  annotations outright, which was a behaviour regression: the N+3 layout drew
-  every class and only dimmed the inactive ones. Renamed `class_filter` ->
-  `focused_class`, `set_class_filter` -> `set_class_focus`,
-  `is_annotation_filtered` -> `is_annotation_defocused`. Only the
-  `draw_annotation` gate changed meaning; the four input/navigation gates
-  still skip, so hover, Tab and the annotation list stay scoped to one class
-  while the rest remain visible.
-  - `state.defocused_opacity` (default 0.4, settable per subtask at
-    construction or via `set_defocused_opacity`). **0 restores 4.1's skip**,
-    so a wide segmentation ontology can still opt out of the extra draws.
-  - Defocused annotations render to one shared scratch canvas and are blitted
-    back as a single layer. Two reasons, both load-bearing: canvases pack
-    annotations by fill order rather than by class, so a defocused annotation
-    can otherwise composite *over* a focused one; and blitting once means
-    overlapping defocused annotations dim as a group instead of compounding
-    alpha. It also avoids threading an alpha argument through every
-    `draw_*` primitive - several of them assign and reset `globalAlpha`
-    themselves (`draw_bounding_box`, `draw_polygon`, `draw_bitmask`) and
-    would each have had to multiply instead.
-  - `draw_annotation` only draws a defocused annotation inside that pass, so
-    the direct-draw callers (undo/redo, in-progress edits) can't leak one at
-    full alpha.
-  - 9 more tests in `tests/class_focus.test.js` (20 total) covering pass
-    ordering, the blit alpha, the 0 opacity skip, and live-context restore on
-    a throwing draw.
-
-### Phase 5 - ULabel: class to spatial type binding
-
-Motivation: a merged `groundtruth` allows the union of the ontology's modes,
-so nothing stops a user drawing a polyline "Crop". Per-class subtasks enforced
-this structurally - the pre-256 `buildClassSubtasks` even threaded a `modeFor`
-callback - and collapsing to three subtasks gives that up unless ULabel can
-express it. A polyline crop is a data-corruption bug better caught at draw
-time than at save time.
-
-- [x] 5.1 Optional `allowed_modes?: ULabelSpatialType[]` on
-  `ClassDefinition`. Undefined inherits the subtask's list, so every existing
-  consumer is unaffected.
-  - A class can only *narrow*: a mode the subtask doesn't allow is dropped
-    with a warning, and a class whose every declared mode is invalid falls
-    back to the subtask's list rather than being undrawable.
-  - The key is only attached when the class actually narrows, so `class_defs`
-    keeps its existing shape for the common case.
-  - `get_class_allowed_modes(class_id, subtask_key?)` is the single resolver.
-- [x] 5.2 Enforce it both ways: changing class auto-switches to that class's
-  mode, and the modes it disallows are disabled in the toolbox.
-  `set_and_update_annotation_mode` rejects a disallowed mode for callers that
-  bypass the buttons.
-  - `sync_annotation_modes_to_active_class()` does both, called from
-    `set_subtask`, `after_init` (the configured initial mode may not suit the
-    initial class) and the class-button handler.
-  - Delete modes are exempt in both places: they can't create a wrong-typed
-    annotation, and hiding them would make the delete class unreachable.
-  - Re-entrancy guarded, because switching mode can trigger the delete-class
-    toggle, which clicks a class button, which re-enters the sync.
-  - 13 tests in `tests/class_allowed_modes.test.js`.
-- [x] 5.3 Narrow `findAllClassDefinitions`, which filters class defs by
-  *subtask* modes today only because per-class modes were not expressible.
-  - Now asks each class first, falling back to its subtask. The subtask-level
-    early-out is gone: it would have masked the per-class check.
-
-### Phase 6 - ULabel: defects found in review
-
-- [x] 6.1 Unterminated `/**` block in `annotation_operators.ts`, left behind
-  by the 1.3 `mark_hidden` removal.
-- [x] 6.2 Brush strokes no longer interact with other subtasks' masks by
-  default: new `brush_overlap_across_subtasks` config flag (default false)
-  scopes overlap resolution to the active subtask. Supersedes the planned
-  read-only "barrier escape hatch": with the flag off a `prediction` or
-  `diff` mask cannot invisibly clip a GT stroke at all; with it on,
-  read-only masks still act as barriers under overwrite.
-- [ ] 6.3 (only if live GT editing during diff review is required) Apply an
-  edit to a non-current subtask and record it in that subtask's undo stream.
-  `set_subtask` clears hover and `fly_to_idx`, so a review queue cannot
-  resolve into GT without losing its place. Prefer 7.9 and skip this.
-  - Why it is needed at all: currency does triple duty. `record_action` and
-    `undo` both resolve through `get_current_subtask()`, and
-    `get_edit_candidates` and Tab only search the current subtask. So
-    "Tab walks FNs in `diff`" and "my correction lands on `groundtruth`'s
-    undo stream" are not simultaneously expressible - review and edit are
-    separate modes unless this ships.
-  - Note the undo stream is *not* the fragile part: `class_filter` changes
-    swap nothing, and a run switch leaves `groundtruth` untouched, so GT's
-    stream is continuous across both. The fragile part is that `diff` is
-    derived from (GT, run) and goes stale the moment GT is edited - the
-    resolved FN keeps rendering as an FN. That is a repaint problem, which
-    is what 7.9 solves without client-side rematching.
-- [x] 6.4 Two different `get_active_class_id` implementations disagree. The
-  `ULabel` *method* (`index.js`) parses the selected toolbox anchor's id out
-  of the DOM; the *utility* of the same name (`utilities.ts`) reads
-  `state.id_payload`. The method throws outright before the toolbox has
-  rendered, and the two can diverge whenever state changes without a DOM
-  sync. Phase 5 uses the state-based one; the method's four remaining call
-  sites should follow, and one of the two names should go.
-  RESOLVED in Phase 9: the method is now a thin delegate to the state-based
-  utility, so there is a single implementation (the DOM parse is gone).
-- [x] 6.5 Switching subtasks left the Brush toolbox buttons lit: brush state
-  is per-subtask but the buttons are global, and `set_subtask` never tore the
-  outgoing brush down. Button display is now centralized in
-  `update_brush_toolbox_display()` (derived from current-subtask state) and
-  `set_subtask` disables the outgoing brush while it is still current.
-- [x] 6.6 An opacity-0 subtask was still fully interactive (invisible
-  annotations could be created/edited). Vanish mode already encodes
-  "invisible implies non-interactive"; its gates (create, suggest_edits,
-  drag start, resize) now check a shared `is_subtask_hidden()` helper
-  (vanished OR opacity slider at 0). Draw gates deliberately still check
-  only `is_vanished`: opacity is CSS-only, so content must stay drawn for
-  the slider to reveal it without a redraw.
-- [x] 6.7 Class keybinds edited live in the Keybinds toolbox item only wrote
-  the current subtask's class defs, while storage and the init restore are
-  id-keyed across all subtasks — shared-id classes (model-registry GT/pred)
-  showed the bind but didn't respond until a reload. Edits/resets now write
-  every subtask holding the id (`set_class_keybind_in_all_subtasks`). The
-  keypress listener's read-only gate also moved inside the reclass branch,
-  so selection keybinds work on read-only subtasks.
-- [x] 6.8 Optional `show_loader = true` parameter on `set_annotations` /
-  `set_annotations_batch`: hosts pass false when every changed subtask is a
-  background layer, so the loading overlay doesn't flash over an unchanged
-  on-screen view.
-- [x] 6.9 Host callback `on_focus_active_class_change(subtask_key, enabled)`
-  config option, fired from the single writer (`set_focus_active_class`,
-  which the focus keybind also funnels through) only on actual change — the
-  guard is what lets a host re-sync other subtasks from the callback
-  without recursing.
-- [x] 6.10 Review fixes: `get_active_class_id_idx()` returned -1 in delete
-  modes (the active class resolves to DELETE_CLASS_ID, which has no index)
-  and three callers used it as an index — a class keybind press (through the
-  dead gate below) or an API `set_active_class` during a delete mode with an
-  annotation hovered zeroed its classification (class buttons are hidden in
-  delete modes, so no button path). Now falls back to the frozen real
-  selection, and `handle_id_dialog_click` rejects out-of-range indices.
-  Also: the class-keybind delete-mode gate read the never-assigned
-  `state.spatial_type` (now `annotation_mode`), `set_subtask` clears the
-  outgoing subtask's move/edit candidates, and `set_class_counter_options` /
-  `set_class_color(s)` gained `is_destroyed` guards.
-- [x] 6.11 Layer opacity is cached in subtask state (`state.layer_opacity`)
-  instead of read from the slider DOM on every mousemove:
-  `readjust_subtask_opacities` is the DOM-to-state sync point (it already
-  runs on every slider input and at the end of `set_subtask`, covering all
-  slider writers) and `set_subtask_opacity` writes the cache directly. Also
-  removed the never-assigned `state.spatial_type` type field (the 6.10 trap).
-
-### Phase 7 - model-registry (branch `three-fixed-subtasks` off `cropped-bitmasks-trevor`)
-
-- [x] 7.1 `buildViewSubtasks` back to three specs. Deleted `classSubtaskKeys`
-  and its slug/dedup path, and the `classKeys[i]` threading through
-  `ImageViewer`'s call sites. `classAllowedModesFor` **kept**: it is now fed
-  to ULabel as per-class `allowed_modes` (5.1) so a class still narrows the
-  subtask's union to its own geometry. Keys are `groundtruth` / `prediction` /
-  `diff` (`VIEW_SUBTASK_KEYS`), with `SUBTASK_FOR_MODE` mapping the view mode
-  onto the layer.
-- [x] 7.2 `diff` declares TP/FP/FN at ids 0/1/2; real classes keep
-  `REAL_CLASS_ID_OFFSET = 3`, since `color_info` is instance-wide. Real class
-  travels as `annotation_meta.diff_class` on both diff paths (segmentation
-  and matches-doc), which are already scoped to one class.
-- [x] 7.3 Class chips drive `set_class_focus` on `groundtruth` / `prediction`;
-  Diff Colors legend rows drive `set_class_focus("diff", ...)`. One
-  `set_subtask` per *mode*, not per chip. Non-focused classes dim rather than
-  disappear (see 4.5), so this keeps the old layout's visual context while
-  still scoping hover and Tab to one class.
-- [x] 7.4 Run switch swaps `prediction` + `diff` in one
-  `set_annotations_batch`; `groundtruth` is untouched. **Not yet verified in
-  a browser** - zoom/scroll survival and the single-frame read still need a
-  manual pass.
-- [ ] 7.5 **Deliberately not done.** `pushChainRef` is kept. Batching makes a
-  swap one call, but `set_annotations_batch` still yields internally (loader
-  paint + `setTimeout`), so two overlapping batches touching the same subtask
-  can still interleave clear/init and leave duplicate stacked canvases.
-  Batching shrinks the window; it does not close it. Dropping the chain needs
-  a re-entrancy guard inside ULabel, not just fewer calls. `subtaskSig` /
-  `contentKey` re-checked and unchanged - both are per-key and three stable
-  keys only make them cheaper.
-- [x] 7.6 Recolor through one `set_class_colors` call; the per-class
-  `set_class_color` + trailing `redraw_all_annotations` loop is gone.
-- [x] 7.7 `viewerKey` falls back to `[null, annoEvalItemId]` when
-  `effectiveImgDims` is null, so two differently-sized items can no longer
-  share a key.
-- [x] 7.8 `ClassCounter` back to `subtasks: "current"` - the current subtask
-  already carries the right classes in every mode.
-- [ ] 7.9 Resolution overlay for the review queue: record accept / reject /
-  confirm per item app-side and reconcile on save, letting the server
-  recompute the diff. Task-type agnostic, so it removes the segmentation
-  (derived client-side) vs keypoint (fetched per threshold) asymmetry, avoids
-  reimplementing bipartite matching in the worker, and makes 6.3 unnecessary.
-- [ ] 7.10 Unpin the ulabel git SHA to a published `^0.28.x` before merge.
-  Now pinned to `#275509f` on the pushed `three-fixed-subtasks` branch, so a
-  fresh `npm ci` resolves correctly. Still a branch SHA, not a release.
-- [ ] 7.11 `groundtruth` ships `read_only: true` behind an
-  `editableGroundtruth` flag (default off). The shape supports editing - it is
-  multi-class, never swapped on a run switch, and owns its own undo stream -
-  but there is no save path yet, so an editable layer would be a data-loss
-  footgun. Flip the flag when 7.9 lands.
-- [x] 7.12 `classAllowedModesFor` short-circuited to `["bitmask"]` for every
-  class on a segmentation run, discarding the backend's
-  `class_spatial_types`. Weeds-Soybean declares `Row: polyline` and the GT for
-  an item really does load 10 Row polylines alongside 89 Crop bitmasks, so
-  focusing Row would have forced bitmask mode and made those polylines
-  uneditable. Dropped the short-circuit; the general path already unions the
-  class's own geometry with the fallback its diff artifacts render as.
-
-### Phase 7b - review fixes
-
-- [x] 7b.1 `set_class_focus` only called `redraw_all_annotations`, which does
-  not touch the toolbox, but the same change taught
-  `AnnotationListToolboxItem.get_filtered_annotations` to filter on
-  `subtask.state.focused_class`. The list kept showing defocused annotations
-  until some unrelated action refreshed it. Now calls
-  `toolbox?.redraw_update_items` under the existing `redraw` flag -
-  `redraw_update_items` rather than `refresh_toolbox` because a focus change
-  cannot alter filter distances.
-- [x] 7b.2 `destroy()` left `state["defocus_scratch"]` holding an image-sized
-  canvas backing store, the exact leak `front_context = null` exists to
-  prevent. Nulled alongside `last_brush_stroke`.
-- [x] 7b.3 New `LogLevel.WARNING` calls on host-driven APIs
-  (`set_subtask_opacity`, `set_class_focus`, `set_defocused_opacity`,
-  `set_annotations_batch`) omitted `hide_alert`, so an ordinary labels/
-  subtasks race in the host popped a modal `alert()`. All now pass `true`.
-  Same fix on the new per-class check in `set_and_update_annotation_mode`,
-  which is reached from a probe that *expects* false. Init-time config
-  validation keeps alerting.
-
-### Phase 8 - history
-
-- [ ] 8.1 At merge, retarget rather than stack: `gh pr edit 257 --base main`
-  and close 256, likewise 12 and 10. Both branches are linear descendants of
-  main with zero divergence, so retargeting needs no rebase and cancels the
-  add-then-delete churn (resolvers, `hidden`, `replace_subtasks`,
-  class-grouped canvases) out of main's history and `git blame`.
-- [ ] 8.2 Optional, only if the combined diff is too large to review well:
-  re-slice by nature rather than chronology - bitmask perf (items 1/3/5 plus
-  the back-canvas removal) as a PR that can land immediately, architecture as
-  another. Manual work, since `cropped-bitmasks`'s three commits mix both.
-
-## Plan: fold class focus into class selection (edit-mode prep)
-
-Verified starting facts: `focused_class` is written only by `set_class_focus`
-(host API; nothing in ULabel's UI touches it), toolbox class selection
-(`id_payload`) is an independent axis, and model-registry never exercises the
-null-focus state - `activeDiffLabel` falls back to `labels[0]` and
-`activeOutcome` defaults `"tp"`, with no deselect gesture, so exactly one
-class/outcome is focused at all times. Two axes that must always agree is
-drift waiting for edit mode: the user could draw with a class that is
-currently defocused. Fold focus into the selection under a per-subtask
-opt-in, and give "set the active class" a real API instead of DOM clicks.
-
-### Phase 9 - ULabel: `set_active_class` + `focus_active_class`
-
-- [x] 9.1 Public `set_active_class(class_id, subtask_key?)`: extract the body
-  of `handle_soft_id_toolbox_button_click` (the `sel` swap,
-  `set_id_dialog_payload_nopin`, dialog display update, active-annotation
-  reclass, delete re-toggle, and the trailing
-  `sync_annotation_modes_to_active_class`) into the method; the DOM click
-  handler becomes a thin wrapper. Mode buttons stay correct because the sync
-  is the handler's last unconditional statement today. For a non-current
-  subtask, skip the button/DOM sync - `set_subtask` already runs the sync on
-  activation, so state is written now and the DOM reconciles on switch.
-  Subsumes 6.4: the state-based `get_active_class_id` (utilities) becomes
-  canonical and the DOM-parsing method's call sites migrate.
-- [x] 9.2 Migrate the internal DOM-click workarounds to `set_active_class`:
-  `toggle_delete_class_id_in_toolbox` (3 trigger sites: delete-class on
-  entry; first class or hovered annotation's class on exit),
-  `update_id_toolbox_display` (state -> click -> handler -> state round
-  trip), the class keybind handler (`listeners.ts` class_button click), and
-  the soft-id handler's delete re-toggle. model-registry has no workarounds
-  to migrate (verified: zero `toolbox_sel`/`id_payload` references).
-- [x] 9.3 Per-subtask `focus_active_class: boolean` (default false, so no
-  behavior change for vanilla consumers - the defocus gates restrict
-  hover/Tab/list, not just drawing, and must not engage unasked). When true,
-  focus derives from the *persistent* selection: a new
-  `get_selected_class_id(subtask)` resolves from `id_payload` and skips
-  `get_active_class_id`'s delete-mode `DELETE_CLASS_ID` short-circuit, so
-  focus freezes at the selected class during delete modes (no saved/restored
-  state, no dim flicker; precedent: the mode sync already bails on
-  `DELETE_CLASS_ID`). The delete-class button is excluded from the focus
-  path. Remove `set_class_focus` / `focused_class` as an independent axis;
-  migrate the `class_focus` tests to selection-driven focus.
-- [x] 9.4 Focus-gate the bulk-delete collection loop
-  (`delete_polygon`/`delete_bbox`) on `is_annotation_defocused`. Restores
-  the protection the removed `hidden` machinery had, and is what makes
-  freeze-during-delete safe: focus scopes what is legible, interactive,
-  navigable - and deletable. Single-annotation delete is already gated via
-  hover (`get_edit_candidates` skips defocused).
-- [x] 9.5 model-registry: sidebar class rows / outcome legend call
-  `set_active_class` instead of `set_class_focus`; all three subtasks set
-  `focus_active_class: true`. Matches the UI's actual invariant (always
-  exactly one focused class); the null-focus branch was only reachable with
-  an empty ontology.
-- [x] 9.6 Enforce per-class modes on *reclassification*. The id-dialog pie,
-  the class keybind (already-selected branch), and `set_active_class`'s
-  reclass branch all funnel through `handle_id_dialog_click`, so one gate
-  there covers every gesture; `assign_annotation_id` stays ungated so
-  undo/redo replay history faithfully. New predicate
-  `can_annotation_be_class(annotation, class_id)` over
-  `get_class_allowed_modes`. Rejection: `shake_screen()` + quiet warning.
-  The gate checks only the *target* class, so an annotation whose current
-  class/type pairing is already invalid (bad import) can still be
-  reclassified to a valid class.
-- [x] 9.7 The pie only offers classes compatible with the dialog's
-  annotation's spatial type (rebuilt per show when the compatible subset
-  changes; wedge hit-testing runs over the displayed subset and maps back to
-  the full class list). When fewer than two classes are compatible there is
-  nothing to choose, so no dialog appears at all. No shake on rejection -
-  the 9.6 gate stays as a silent backstop for keybind paths.
-- [x] 9.8 Load-time validation: warn (never drop - the data is authoritative
-  and round-trips on export) when an imported annotation's class does not
-  allow its spatial type. NOTE: no subtask-level load check exists either
-  (`process_resume_from` only errors on *missing* type/payload); checking
-  against the class's effective modes covers both levels since class modes
-  are already a subset of the subtask's.
-- [x] 9.9 Host callbacks `on_active_class_change(subtask_key, class_id)` and
-  `on_subtask_change(subtask_key, old_subtask_key)` config options, fired
-  from the single writers (`set_active_class` / `set_subtask`) only on
-  actual change. Needed because the Keybinds toolbox item lets users bind
-  class-select keys at runtime, so ULabel-side class changes are reachable
-  even when the host ships `keybind: null` and no id toolbox.
-
-### Verification
-
-- [ ] V3 ULabel: lint + jest + e2e green after each phase; 4.1-4.4 and
-  5.1-5.3 carry their own tests.
-- [ ] V4 model-registry on eval run #3: run and mode switches produce zero
-  rebuilds and preserve zoom with no visible flicker; Tab in `diff` walks
-  only the filtered outcome; `ClassCounter` reads TP/FP/FN in diff; three
-  front canvases, heap at or below the N+3 baseline.
-- [ ] V5 The edit test, which every layout except 256 failed: a misclassified
-  GT annotation is corrected *in place* by the reclassify pie, keeping its
-  id, `encord_object_hash` and undo coherence - no delete-and-recreate across
-  subtasks. Must pass before the edit path ships.
-- [ ] V6 Phase 9: with `focus_active_class` on, selecting a class (API,
-  toolbox button, or keybind) moves focus, dimming and mode buttons together;
-  entering a delete mode changes none of them; a delete polygon removes only
-  focused-class annotations. Vanilla configs (flag off) show zero behavior
-  change across the whole suite.
+## Plan: v0.29.0 - editing ergonomics for model-registry (CVML-173)
+
+Jira: CVML-228 (body-drag move), CVML-229 (context menu), CVML-230
+(isolate). CVML-236 adopts the tag in model-registry. All three land on
+`release/0.29.0` as one release; order 228 -> 229 -> 230 because 228
+removes the hover ring that 229's list flow and 230's acceptance depend on.
+
+Decisions taken in review (2026-09-28), where they differ from the tickets:
+
+- Body-move covers **every** spatial type, bitmask included: `begin_move` /
+  `finish_move` already translate masks, so the ticket's exclusion was an
+  unverified assumption.
+- Plain left-drag on a *containing* hit moves; a configurable modifier
+  (default Alt, which no mouse path uses today - only Alt+wheel for brush
+  size) forces a draw at that spot. Vertex handle under the cursor still
+  wins.
+- The whole hover ring goes (move, reid, delete buttons) **and** the hover
+  pie thumbnail. Hover leaves the white outline plus the confidence card,
+  now anchored to the containing box. Reclassify and delete move to the
+  context menu (plus existing keybinds).
+- "Change class" reuses the id-dialog pie, which already enforces per-class
+  `allowed_modes` (9.6/9.7). No list submenu.
+- Context menu ships only Change class / Delete / Details. No
+  `context_menu_items` host hook, no per-item disable config. Add when a
+  host needs it.
+- No `on_annotation_change` callback: model-registry reads the annotations
+  once from the Save button.
+- Details shows id, class, spatial type, `last_edited_by` / `last_edited_at`,
+  and `annotation_meta` entries.
+- Isolate hides the others on the **canvas** (per ticket) and ships the
+  programmatic `isolate_annotation()` + `on_isolate_change` too.
+
+Verified facts the tickets get wrong, for the record:
+
+- "Right-drag": button 2 only matters while `active_id != null` (a polyline
+  in progress), where mouseup finishes it. There is no drag to preserve;
+  the rule is simply "no menu while an annotation is in progress".
+- "Annotation list filters by class only": it filters deprecated +
+  defocused (`focus_active_class`). Isolation composes with the defocus
+  gate, not a separate class filter.
+- ULabel has no annotation-change events for hosts to reuse.
+
+### Phase 228 - body-drag move, ring removal
+
+- [x] 228.1 `get_edit_candidates` reports whether `best` is a *containing*
+  hit (exact test passed) vs the near-miss box fallback; `suggest_edits`
+  carries it onto `move_candidate`. Body-move must require a containing
+  hit or clicking near a polygon on empty canvas would drag it.
+- [x] 228.2 `get_drag_key_start`: for button 0 on the canvas of an editable
+  subtask, after the existing ctrl (pan) / shift (zoom) / read-only checks:
+  Alt held -> `"annotation"`; `move_candidate` is a
+  containing hit and `allow_body_move` -> `"move"`; else `"annotation"`.
+  Delete the `.movable` branch. `.editable` (vertex handle) is a different
+  target element, so vertex precedence is unchanged.
+- [x] 228.3 Config: `allow_body_move: boolean = true`. Alt is hardcoded as
+  the draw-over modifier (a `force_draw_modifier` option was dropped:
+  ctrl/meta/shift are claimed by pan/zoom first, and the keybinds toolbox
+  can't record a bare modifier). Listed as a non-configurable
+  "Alt + Click Drag" entry in the Keybinds toolbox item when
+  `allow_body_move` is on.
+- [x] 228.4 Remove the ring: move/reid/delete anchors and their click
+  listeners, the `mcm` / `can_reassign` toggling in
+  `show_global_edit_suggestion`, the ring CSS. Keep
+  `#global_edit_suggestion__{key}` as the zero-height anchor the confidence
+  card is positioned against, so the Phase 0 clamp/flip code survives with
+  a new clearance: half the containing box's on-screen height plus the gap
+  (what item 10 did before the ring hug). Update `confidence_card.test.js`,
+  the two e2e flip specs, and the `class_allowed_modes.test.js` fixture.
+  Also dropped the `force_refresh` param of `suggest_edits` (its only job
+  was the ring-hover guard) and the `gedit-target` class.
+- [x] 228.5 Remove the hover pie thumbnail: drop the
+  `show_id_dialog(..., thumbnail = true)` call and the thumbnail plumbing it
+  fed (`idd_thumbnail` guards in `handle_mouse_down` / `handle_mouse_move` /
+  `handle_wheel`, the annotation-list mouseleave special case). The
+  clicked-open pie stays for 229's Change class. Remove `idd_thumbnail`
+  state only if nothing else reads it after this.
+- [x] 228.6 No-op click: `finish_move` with zero diff pops the `begin_move`
+  **directly** (not via `undo(this, true)`: that would push a no-op onto the
+  redo stack and, via `record_action`, had already wiped the user's redo
+  stack and flipped `state.edited`). `begin_move` snapshots `edited` +
+  `undone_stack` into `state.move_snapshot`; the zero-diff path restores
+  them and the annotation's `last_edited_*`.
+- [x] 228.7 Annotation list hover still calls `show_global_edit_suggestion`
+  for the outline + card; confirm nothing there referenced the buttons.
+- [x] 228.8 Tests: jest `tests/body_move.test.js` for `get_drag_key_start`
+  decisions (containing hit -> move, near-miss -> annotation, modifier ->
+  annotation, read-only -> null, `allow_body_move: false` -> annotation,
+  delete modes -> annotation) and the zero-diff pop; e2e
+  `tests/e2e/body-move.spec.js`: drag a bbox / point / polygon body and
+  assert translated geometry, undo restores, vertex drag still edits one
+  vertex, read-only drag is inert. `read-only.spec.js` asserts no
+  `.movable` / ring elements rendered. E2E runs in CI only (local
+  Playwright blocked).
+- [x] 228.9 Docs: `api_spec.md` (new config, stale hover-dialog mentions;
+  README has no interaction docs), CHANGELOG `[0.29.0]` breaking-change
+  entries.
+- [x] 228.10 Move affordance: `suggest_edits` toggles `movable_hover`
+  (`cursor: move`) on the front canvas when `is_body_move_start` would
+  return true for the hover; cleared in `hide_edits`.
+
+### Phase 229 - right-click context menu
+
+- [x] 229.1 New `src/context_menu.ts` (free functions + thin `ULabel`
+  methods, like `active_class.ts`): `show_context_menu(annid, client_x,
+  client_y)`, `hide_context_menu()`, `is_context_menu_open()`. One
+  fixed-position `div` under the container, z-index above the dialogs.
+  Built with DOM APIs / `textContent`, never `innerHTML` with annotation
+  data. Open state lives in `ulabel.state.context_menu_annid`.
+- [x] 229.2 Trigger: `contextmenu` listener on the annbox. When
+  `active_id != null` (draw in progress) do nothing new - the existing
+  `"right"` mouseup path finishes a polyline. Otherwise, if
+  `edit_candidate` is set open the menu for it; else close any open menu.
+  Same listener on `.annotation-list-item`, keyed off `data-annotation-id`.
+  Note: the preceding mousedown already closed any open menu and cleared
+  the hover, so both listeners re-resolve the target first (annbox via
+  `suggest_edits(event)`, list via a new private `highlight_from_list`).
+- [x] 229.3 Items and visibility: Change class (hidden when read-only or
+  `_get_compatible_class_ids(ann).length < 2`), Delete (hidden when
+  read-only), Details (always). On a read-only subtask only Details shows.
+- [x] 229.4 Actions: Change class -> hide menu, `show_id_dialog(cx, cy,
+  annid, false)` at the containing-box centre (goes through
+  `handle_id_dialog_click`, so undo + the 9.6 mode gate come for free).
+  Delete -> `delete_annotation(annid)`. Details -> 229.5.
+- [x] 229.5 Details panel: replaces the menu content in place; rows for id,
+  class name (+ id), spatial type, `last_edited_by`, `last_edited_at`, then
+  one row per `annotation_meta` key (non-primitive values
+  `JSON.stringify`'d). Read-only, no inputs.
+- [x] 229.6 Close on: any action, Escape (first branch of the keydown
+  handler), mousedown outside the menu, wheel / rezoom, `set_subtask`,
+  `_swap_subtask_annotations`, `delete_annotation` of the target,
+  `destroy()`. Implemented as: `handle_mouse_down` closes the menu and
+  swallows that click; document `mousedown.ulabel`; `rezoom`;
+  `reset_interaction_state` (covers swap + destroy); `set_subtask`;
+  `delete_annotation`. Scope expansion: Escape now also closes a
+  clicked-open id dialog, which previously had no dismissal path.
+- [x] 229.7 Keep the target highlighted while the menu is open: the list's
+  `mouseleave` and the annbox `mouseleave` currently clear
+  `edit_candidate` and hide the outline; guard both on
+  `is_context_menu_open()`, and clear on menu close instead. Also guarded
+  the list `mouseenter` and the non-drag `handle_mouse_move` branch.
+- [x] 229.8 Tests: jest for visibility rules, close conditions, delete via
+  menu records an undoable action, details escapes text; e2e on a
+  two-class demo: right-click -> Change class -> pie -> class changes and
+  `get_annotations()` reflects it, undo reverts; right-click list entry ->
+  Delete removes from canvas and list, undo restores; right-click mid
+  polyline still finishes it and opens no menu.
+  (`tests/context_menu.test.js`, `tests/e2e/context-menu.spec.js`; e2e
+  verified locally on chromium.)
+- [x] 229.9 Docs: README section, CHANGELOG, `index.d.ts` for the three
+  methods. README has no interaction docs, so the shortcut and the three
+  methods went into `api_spec.md` instead.
+
+### Phase 230 - isolate one annotation from the list
+
+- [x] 230.1 `state.isolated_annid: string | null` per subtask (type in
+  `subtask.ts`, initialised alongside `focused` state).
+- [x] 230.2 Public `isolate_annotation(annotation_id | null, subtask_key?)`
+  + `index.d.ts`: rejects unknown / deprecated ids with a quiet warning,
+  writes the state, drops `hovered_annid` and `fly_to_idx`, redraws and
+  `toolbox.redraw_update_items()`, fires `config.on_isolate_change?.(
+  subtask_key, annotation_id | null)` only on actual change.
+  Lives in new `src/isolate.ts` (like `active_class.ts`). Also drops
+  `edit_candidate` / `move_candidate` and closes the context menu; added
+  `get_isolated_annotation_id(subtask_key?)` for the list UI and hosts.
+- [x] 230.3 Gates: extend `is_annotation_defocused` to also return true for
+  "isolated-out" (another annotation is isolated in that subtask), which
+  covers hover, Tab, fly-to, the list, active-class hover and bulk delete
+  in one place. Drawing must *hide* rather than dim: early-return in
+  `draw_annotation` and skip in the defocused-pass collection. Explicitly
+  not in the bitmask geometry paths (same carve-out as focus).
+- [x] 230.4 Clears: `set_subtask` (outgoing subtask),
+  `_swap_subtask_annotations`, `delete_annotation` of the isolated id,
+  Escape (after the context-menu branch, before the in-progress ones).
+  View-only: no `record_action`, `state.edited` untouched.
+  Added: creating a new annotation (`begin_annotation`, `create_annotation`,
+  `create_nonspatial_annotation`, `create_bitmask_annotation`) also clears,
+  otherwise the new annotation would be drawn hidden. Escape branch sits
+  after the id-dialog dismissal.
+- [x] 230.5 Annotation list UI: per-entry isolate icon button
+  (`stopPropagation` so click-to-fly is intact; active state styled), and a
+  "Show all" button in the header while isolated. While isolated the list
+  shows only that entry (falls out of the 230.3 gate). Eye SVG icon;
+  clicking the active button clears.
+- [x] 230.6 Tests: `tests/isolate.test.js` for state write, draw skip,
+  hover skip, each clear path, callback fires only on change,
+  `get_annotations()` length unchanged, isolated + defocused class draws
+  nothing; e2e on a 20+ annotation demo per the ticket's acceptance list
+  (isolate -> only it drawn -> delete via context menu -> isolation clears).
+  `tests/e2e/isolate.spec.js` loads a 24-box grid via `set_annotations`
+  on multi-class.html and checks painted-pixel counts; the `set_subtask`
+  and `set_annotations` clears are covered there (need full init), the
+  rest in jest. Verified locally on chromium.
+- [x] 230.7 Docs: README (control, method, callback), CHANGELOG. README has
+  no interaction docs; went into `api_spec.md` (AnnotationList section,
+  methods, `on_isolate_change`) and CHANGELOG.
+
+### PR review fixes (PR_REVIEW_0.29.0.md, all four findings confirmed)
+
+- [x] F1 Zero-diff `finish_move` vs `undo()`: `undo()` pops `begin_move`,
+  pushes it back, `finish_action` -> `finish_move` pops it again (zero diff)
+  and swaps `actions.undone_stack`; `undo()` then pops the *previous* action
+  (or `undefined` -> TypeError) into a detached redo array. Fix: have
+  `finish_action` report whether the action was dropped and bail out of
+  `undo()`; restore the snapshot's redo stack in place rather than by
+  reference swap. Tests: Ctrl+Z mid stationary click with and without
+  prior history, redo still works. Done: `undo()` bails when the
+  top-of-stack action is no longer the undo candidate; `finish_move`
+  restores `undone_stack` in place.
+- [x] F2 Body move for `contour`, `tbar`, `bbox3`: `get_edit_candidates`
+  has no exact test for them, so `containing` is never true and
+  `is_body_move_start` refuses. Add: contour -> near-stroke like polyline;
+  tbar -> near either segment; bbox3 -> inside x/y box. Tests in
+  `tests/body_move.test.js`. Done (`GeometricUtils.tbar_cross_segment`
+  shared with `draw_tbar`).
+- [x] F3 Stale `isolated_annid` after undoing creation: only
+  `delete_annotation` clears it; `create_annotation__undo` and
+  `begin_annotation__undo` go through `remove_annotation_from_access_and_ordering`.
+  Clear there (with `on_isolate_change(null)` + full redraw). Test:
+  create -> isolate -> undo -> others visible, callback got null. Done
+  (jest + e2e).
+- [x] F4 Details panel: re-run `position_menu` after `render_details` and
+  add `max-height` + `overflow-y: auto` to `.ulabel-context-menu`. Tests:
+  details near the bottom edge stays in the viewport; tall metadata scrolls.
+  Done (`box-sizing: border-box` needed so the border fits in `max-height`).
+- [x] F5 lint + build + jest + affected e2e; CHANGELOG bullet for F2
+  (contour/tbar/bbox3 move) - F1/F3/F4 are fixes to unreleased code.
+  Done: lint clean, jest 341/341, context-menu + isolate e2e 17/17.
+- [x] F6 (re-review) `finish_annotation__undo` deprecates rather than
+  removes, so isolation outlived an undone polygon/polyline. Clear it
+  there too. Tests: jest + e2e (draw polygon -> isolate -> Ctrl+Z).
+- [x] F7 (re-review) `rebuild_containing_box` now includes the tbar
+  crossbar endpoints so the preliminary gate no longer rejects crossbar
+  hits. Tbar unit test builds the box through production code and hits
+  the crossbar well outside the stem padding. jest 342/342.
+- [x] F8 (re-review) Bitmask paths deprecate without `delete_annotation`
+  (first-stroke undo, full erasure in `finish_bitmask`, erasure redo,
+  overwrite victims incl. other subtasks). New
+  `release_isolation_if_deprecated(annotation_id, subtask_key)` called at
+  each `mark_deprecated(..., true)` site. Tests: 4 jest cases in
+  `tests/isolate.test.js`; e2e "Bitmask isolation lifecycle" in
+  `tests/e2e/bitmask.spec.js` with real brush dabs + Ctrl+Z / Ctrl+Shift+Z.
+  jest 346/346, bitmask e2e 15/15.
+- [x] F9 GHA e2e "shift-hover on an existing polygon starts a new complex
+  layer" failed on every browser: the `handle_mouse_move` branch required
+  `idd_visible`, which only the removed hover-ring thumbnail set. Now
+  gated on `edit_candidate` pointing at a polygon. keybind e2e 16/16.
+
+### Release
+
+- [x] R1 CHANGELOG `[0.29.0]` section covering 228/229/230 plus the
+  confidence-card fix already on the branch.
+- [x] R2 `package.json` version bump to 0.29.0 (done by user).
+- [ ] R3 lint + build + jest + e2e green; PR `release/0.29.0` -> `main`,
+  tag `v0.29.0`.
+- [x] R4 Update CVML-228 / 229 / 230 descriptions to match the decisions
+  above (bitmask in scope, ring removed, no host hook, no change events).
+  Done 2026-09-28; CVML-236 still says "details-only on read-only layers"
+  and mentions the ring-less hover only implicitly - revisit when adopting.
+
+## Plan: submit-button filtering for model-registry (CVML-248, ships in 0.29.0)
+
+Two optional fields on `ULabelSubmitButton`, per button:
+
+- `subtasks?: string[]` whitelist of subtask keys in the payload (mirrors
+  `ClassCounterConfig.subtasks`). Default all.
+- `edits_only?: boolean` reduce each subtask to what differs from what the
+  host loaded: (1) new and not deprecated, (2) loaded and now deprecated,
+  (3) loaded and any submitted field changed (incl. un-deprecation).
+
+Design decisions (verified against `release/0.29.0`, audit 2026-09-29):
+
+- "Loaded" = `resume_from` **and** `set_annotations` /
+  `set_annotations_batch`; all go through `process_resume_from`.
+- Modification is detected via `last_edited_at`. `record_action` stamps
+  the named annotation and `undo_action` restores `prev_timestamp`; every
+  single-annotation edit already routes through it. Audit found three
+  mutations that bypass the stamp and must be fixed first (S0):
+  1. `delete_annotations_in_polygon` / `_in_bbox` victims
+     (`deprecated_ids`, `modified_annotations`); the action names the
+     delete polygon, which is then removed, so redo stamps nothing.
+  2. `resolve_bitmask_overlap` overwrite victims (`other_edits`), possibly
+     in other subtasks, incl. `bitmask_stroke__undo/__redo`.
+  3. Non-spatial note textarea writes `text_payload` directly
+     (`listeners.ts`), no action, not undoable.
+  Filter deprecation (confidence slider, `distance_from_row`) is not a
+  human edit and stays unstamped on purpose.
+- Fix shape: optional `affected: {annotation_id, subtask_key}[]` on the
+  raw action. `record_action` stamps each (any subtask) and stores their
+  prev edit info on the action; `undo_action` restores them. Text notes
+  get an `edit_text_payload` action (old -> new) on `change`.
+- `process_resume_from` records each loaded id's `last_edited_at` in a
+  subtask-level `annotations.loaded_edited_at` map (a non-enumerable
+  per-annotation property was rejected: undo paths replace annotation
+  objects). In-session creations have no entry.
+- Single inclusion rule in `SubmitButtons.build_submit_payload`:
+  `loaded_at === undefined ? !deprecated : last_edited_at !== loaded_at`.
+  Yields exactly the three categories; a loaded annotation left alone or
+  hidden only by a filter is omitted; undone edits drop out because undo
+  restores the loaded stamp.
+- Open: a button-less accessor for the same payload (autosave). Not until
+  model-registry asks.
+- Note: non-spatial annotations are skipped from the submit payload by
+  pre-existing code, so text-note edits are undoable/stamped but never
+  reach the hook.
+
+- [x] S0 timestamp audit fixes: `affected` on `record_action`/`undo_action`
+  + use in `bitmask_stroke` and `delete_annotations_in_polygon` (incl.
+  redo); `edit_text_payload` action; jest: victims stamped on do/redo and
+  restored on undo across subtasks, text note stamped and undoable.
+- [x] S1 `loaded_edited_at` in `process_resume_from`; jest: set for
+  resume_from and set_annotations, absent for in-session creations.
+- [x] S2 `subtasks` whitelist in `SubmitButtons` (unknown keys warn).
+- [x] S3 `edits_only` inclusion rule in `SubmitButtons`.
+- [x] S4 jest (`tests/submit_payload.test.js`): legacy payload, whitelist,
+  none / new / delete / reclassify / undo / redo / delete-polygon carve /
+  cross-subtask bitmask carve / filter-hidden / set_annotations rebaseline.
+- [x] S5 e2e (`demo/submit-payload.html`, `tests/e2e/submit-payload.spec.js`):
+  two subtasks, one button per option, payload asserted through the hook.
+- [x] S6 `index.d.ts`, `api_spec.md` submit-button section, CHANGELOG.
+- [x] Test infra: `PORT` env var for demo.js/Playwright; demo image served
+  locally (`demo/cs-demo-0.png`) so e2e no longer depends on S3/Zscaler.
+- [x] R1 review: `edit_type`/`deprecated` in `edits_only` derive from
+  `deprecated_by.human`, not the filter aggregate (`classify_edit`).
+- [x] R2 review: a loaded annotation erased to empty geometry still yields
+  a `"deleted"` record (legacy payload unchanged).
+- [x] R3 review: `finish_annotation` carries `prev_timestamp`/`prev_user`
+  from the collapsed `begin_brush`/`start_complex_polygon` action so undo
+  restores the loaded stamp.
+- [x] R4 review: shift-hover complex-layer start gated on read-only.
+  Jest for R1–R3 in `tests/submit_payload.test.js`; e2e for R4 in
+  `tests/e2e/read-only.spec.js`.
+- [x] R5 review: nonspatial/delete-mode skip moved before geometry access
+  (null `spatial_payload` crashed legacy submit). Jest legacy + edits_only
+  note cases; e2e legacy Submit on read-only demo.
+- [x] R6 review: `record_action` treats an explicit `prev_timestamp: null`
+  as an override (null loaded baseline), only `undefined` falls through.
+  Jest collapsed-layer undo now parameterized over string/null baseline.
+- [x] Fix `set_id_dialog_payload_nopin` 0/0 → NaN pie radius when the
+  delete class (index -1) is selected in a single-class subtask. Jest in
+  `tests/class_focus.test.js`.
+
+## Plan: copy/cut annotations between subtasks (CVML-261, ships in 0.29.0)
+
+Decisions (agreed with the user, see the ticket for the full spec):
+
+- Eligible target: any other subtask that is not read-only and has at
+  least one class whose allowed modes include the annotation's
+  `spatial_type`. Spatial annotations only. Copy from a read-only source
+  is allowed; cut is not.
+- Context menu: "Copy to" / "Move to" list the eligible targets. One
+  target collapses to "Copy to <name>". No targets → items hidden. The
+  list opens as an in-place drill-down (same pattern as Details), not a
+  hover submenu.
+- Keybinds: native `copy` / `cut` / `paste` DOM events (not remappable),
+  ignored while focus is in an input/textarea. Copy/cut act on the hovered
+  `edit_candidate`; paste goes to the current subtask. Same-subtask paste
+  offsets by `PASTE_OFFSET_PX` (20 image px) so the copy is visible.
+- Class: same class id if compatible, else the target's active class, else
+  the first compatible class. With more than one compatible class the
+  pasted annotation gets the class pie (switching to the target subtask
+  first when needed). No compatible class → warn, no paste.
+- Copy carries everything except `id`, `subtask_key`, class payload,
+  deprecation, stamps and `edit_type`; bitmasks are re-encoded to RLE.
+- Undo: cut = `delete_annotation` on the source stream; paste = new
+  `paste_annotation` action recorded on the TARGET stream (undo removes
+  the copy, redo re-adds it from the stored annotation). `record_action`
+  gains an optional `subtask_key` for that.
+- System clipboard envelope `{ ulabel_annotation: 1, image_width,
+  image_height, annotation }`; paste prefers `clipboardData` when the
+  dimensions match, else the in-memory clipboard; mismatch warns.
+
+- [x] S1 core: `paste_annotation` / `copy_annotation_to_subtask` in
+  `index.js`, `__undo` / `__redo`, `record_action` subtask targeting,
+  `ULabelActionType` in `index.d.ts`.
+- [x] S2 context menu "Copy to" / "Move to" drill-down.
+- [x] S3 `copy` / `cut` / `paste` listeners + class-pie flow.
+- [x] S4 public API `copy_annotation(annid, target_subtask_key, class_id?)`
+  + `index.d.ts`.
+- [x] S5 jest (`tests/copy_annotation.test.js`) + e2e
+  (`tests/e2e/copy-annotation.spec.js`).
+- [x] S6 `api_spec.md`, CHANGELOG.
+- [x] R1 review: `move_annotation__undo` prunes the target's stream and
+  undone stack of the copy's actions (`remove_recorded_events_for_annotation`
+  takes a subtask key); `delete_annotations_in_polygon__undo` skips missing ids.
+- [x] R2 review: `_insert_pasted_annotation` releases the target's isolation
+  like other creation paths.
+- [x] R3 review: `_discard_moved_copy` follows later `move_annotation`
+  actions on the copy recursively so chained moves leave no orphan.
+- [x] Repeat pastes cascade: envelope `paste_counts` per target subtask
+  scales `PASTE_OFFSET_PX`; reset by a new copy/cut. Envelope `copy_id`
+  keys the in-memory count cache.
+- [x] Delegated click handler on `#container a[href="#"]` calls
+  `preventDefault` so ULabel's anchor buttons never navigate to `#`.
+- [x] Paste class: `match_paste_class_id` matches by id then name (envelope
+  `source_class_name`); the class pie only opens when neither matched and no
+  explicit class was given.
+- [x] `assign_annotation_id` returns early (hides the pie, clears suggestions)
+  when the picked payload equals the current one, so no no-op action is
+  recorded.
+
+## CVML-283: cross-subtask paste follow-ups (0.29.0)
+
+- [x] `paste_class_choice` config (default true): off, menu copy and ctrl+v
+  never open the pie; `resolve_paste_class_id` picks the class.
+- [x] `paste_switch_to_target` config (default false) + `set_/get_` API:
+  menu copy/move calls `set_subtask(target)` after the paste (and after a
+  move is recorded on the source).
+- [x] Provenance: `paste_annotation(..., source_key)` stamps
+  `annotation_meta.copied_from`; `find_pasted_copy` scans the target for a
+  live copy. Context menu `confirm()`s a repeat copy/move; ctrl+v is exempt.
+- [x] Menu copy/move also arms the clipboard (in-memory + `navigator.clipboard`)
+  with `paste_counts[target] = 1`.
+- [x] Tests (jest + e2e), api_spec, index.d.ts, CHANGELOG.
+- [x] Review: envelope `copied_at`; paste picks the newer of system vs
+  in-memory when `copy_id`s differ (failed `writeText` left a stale system
+  payload). `find_pasted_copy` skips only `deprecated_by.human`, not
+  filter-hidden copies.
+
+## CVML-286: on_annotation_change host callback (0.29.0)
+
+Agreed deviations from ticket: single object arg (not 4 positional), one call
+per action with `affected` list (no fan-out), `begin_*` suppressed on "do",
+`edit_text_payload` excluded, `previous_classification_payloads` for id changes.
+
+- [x] Config: `on_annotation_change` (null) and
+  `on_annotation_change_in_progress` (false); `ULabelAnnotationChange` type.
+- [x] `actions.ts`: `emit_annotation_change` at end of `record_action`
+  ("do"/"redo") and after the undo listener ("undo"); try/catch →
+  `log_message(WARNING)`. `continue_*` only with the flag; `begin_*`,
+  `start_complex_polygon`, `begin_brush`, `create_nonspatial_annotation`
+  skipped on "do" only; `edit_text_payload` never. Off-stream recordings
+  (the delete inside a move) are sub-steps and skipped, except
+  `finish_edit`/`finish_move`.
+- [x] Jest (`tests/on_annotation_change.test.js`): do/undo/redo for
+  create/delete/id-change (previous payloads oriented per kind); edit and
+  move flows (begin_* silent on do, fire on undo/redo; zero-diff click
+  silent); affected for paste/move/bitmask; continue_* gated;
+  edit_text_payload and set_annotations silent; callback exception logged.
+- [x] Docs: index.d.ts, api_spec, CHANGELOG.
+- [x] Full jest + chromium e2e pass.
+- [x] Review: off-stream `finish_annotation` (bbox/point/contour/tbar) is
+  reported; polygon `simplify`/`merge` are silent on "do" (the collapsed
+  `finish_annotation` carries the final geometry). A redone
+  `begin_annotation` passes `redoing` into `finish_annotation` so its
+  off-stream finish is not reported twice. Tests drive real
+  begin/continue/finish flows and assert geometry seen inside the callback.
+
+## CVML-287: runtime read-only toggle + enforcement gaps (0.29.0)
+
+- [x] `set_subtask_read_only(subtask_key, read_only)`: unknown key warns,
+  same value no-ops; going read-only on the current subtask completes an
+  active drag, discards in-progress work, disables the brush, closes the
+  ID dialog/context menu and clears edit/move candidates; re-renders the
+  subtask's non-spatial rows. No action, no edited flag, no callbacks.
+- [x] Gates: `toggle_brush_mode`/`toggle_erase_mode`, brush-circle drag key,
+  user undo/redo (current subtask or any `affected` subtask read-only),
+  non-spatial row change/delete/reclf handlers.
+- [x] Docs: index.d.ts, api_spec, CHANGELOG.
+- [x] Jest (`tests/read_only_toggle.test.js`).
+- [x] Playwright: brush bypass, toggle round-trip, mid-polygon toggle,
+  non-spatial rows follow the toggle. Demo gained Brush + a toggle button.
+- [x] Lint + build; targeted tests; browser check via demo; full suite.
+
+## Linked counterparts: Delete/Erase from <subtask> + duplicate warning (0.29.0)
+
+Decisions: link by a host meta key (no geometry matching). Value is a string
+or string[]; any shared value links. "Erase from" for bitmask sources,
+"Delete from" otherwise; any writable target; copy warns when linked.
+
+- [x] Config `annotation_link_meta_key` (null); `find_counterparts(annid,
+  source_key, target_key)` = `copied_from` copies + shared link values,
+  live (not human-deprecated) only.
+- [x] Copies drop the link key from `annotation_meta`.
+- [x] `delete_counterparts(annid, source_key, target_key)`: delete linked
+  vector annotations, or subtract a bitmask source from linked bitmasks
+  (emptied → deprecated); one action recorded on the target stream with
+  `affected`; undo/redo.
+- [x] Context menu "Delete from" / "Erase from" for writable targets with
+  counterparts; copy/move `confirm()` when counterparts exist.
+- [ ] Jest + e2e (new e2e test not yet run).
+- [x] Docs: index.d.ts, api_spec, CHANGELOG.
+- [ ] Lint + build; targeted tests; full jest + chromium e2e (full suites skipped for now).
+
+## Edit focus: "Edited Only" (no ticket yet, branch `edit-focus`)
+
+Replaces the outline-highlight experiment (branch `test-highlight`). Per-subtask
+`focus_edited` flag feeds `is_annotation_defocused()`: unchanged annotations
+(`SubmitButtons.classify_edit()` null against `loaded_edited_at`) dim like
+class focus and drop out of input, navigation, bulk delete and the list.
+Composes with class focus; isolation still wins.
+
+- [x] `ULabelSubtask.focus_edited` (+ subtask json option); defocus check;
+  focus-pass gate in `draw_context_in_focus_passes`.
+- [x] `set_focus_edited(subtask_key, enabled, redraw)` + `on_focus_edited_change`.
+- [x] `toggle_edit_focus_keybind` (`h`): keypress handler + Keybinds entry.
+- [x] Annotation list "Edited Only" checkbox mirrors the current subtask's flag
+  (not persisted).
+- [x] `record_action`: redraw annotations whose defocus flipped on stamping.
+- [x] Jest + e2e.
+- [x] Docs: index.d.ts, api_spec, CHANGELOG.
+- [x] Lint + build; full jest + chromium e2e.
+
+## Deprecated focus + Restore (no ticket yet, branch `edit-focus`)
+
+"Show Deprecated" becomes a per-subtask `focus_deprecated` flag: deprecated
+annotations (any source) are drawn and in focus, live ones dim. Composes with
+Edited Only (→ this session's deletions) and class focus.
+
+- [x] `focus_deprecated` flag + `set_focus_deprecated()` + callback; in
+  `is_annotation_defocused` (deprecated in focus iff flag on); drop the
+  localStorage key; checkbox mirrors the current subtask.
+- [x] Draw in-focus deprecated annotations; fly-to / Tab / isolate accept them.
+- [x] Canvas hover + context menu on deprecated (outline, card); block edit,
+  move, reclassify, delete, vertex handles, brush/erase.
+- [x] List row icon with deprecated-by tooltip; Details "Deprecated by" row.
+- [x] `restore_annotation` action (human deletes, writable subtasks, not empty
+  bitmasks): restores the pre-delete stamp from the latest stream action that
+  touched it, else stamps now. Undo re-deprecates. Context menu "Restore".
+- [x] Verify every deletion path records the annotation (target or affected).
+- [x] Jest + e2e; docs; lint + build; full jest + chromium e2e.
+
+### Review fixes
+
+- [x] `delete_vertex` keeps the original geometry when it deletes the annotation.
+- [x] Polygon brush erase-all collapses `begin_brush` into the `delete_annotation`
+  (pre-stroke geometry and stamp; one undo step).
+- [x] `cancel_annotation` removes the drawing from access; undo re-inserts it.
+- [x] `can_restore_annotation` rejects delete modes and empty/degenerate geometry.
+- [x] `record_action` redraws deprecated annotations whose focus flips on stamping.
+- [x] Tests; CHANGELOG + api_spec; lint, build, full jest + chromium e2e; live check.
+  jest 502/502, chromium e2e 163/163. Not fixed (pre-existing): cancelling a
+  complex layer snapshots the annotation after the layer was popped, so its
+  undo does not bring the layer back.
+- [x] Polygon brush target selection skips defocused polygons (`begin_brush`).
+- [x] Bitmask brush target selection skips defocused masks (`find_bitmask_under_brush`).
+
+### Deprecated focus edit lock
+
+- [x] `is_subtask_edit_locked` (read-only or deprecated focus) gates user input;
+  Restore and undo/redo stay allowed; API not gated.
+- [x] Enabling discards in-progress input (`discard_in_progress_input`).
+- [x] `not-allowed` cursor (`edit_locked` canvas class) and banner with Exit.
+- [x] Tests, docs, lint, build, jest, e2e. jest 506/506, chromium e2e 164/164.
+- [x] `toggle_deprecated_focus_keybind` (`shift+d`): keypress handler + Keybinds entry.
+
+### Origin-gated undo from a read-only subtask
+
+- [x] Actions record `origin_subtask_key` (`undo_redo_from_subtask` or current subtask).
+- [x] `run_on_edit_subtask` only runs when the top action's origin is the current read-only subtask.
+- [x] Tests, docs, lint, build, jest, e2e. jest 509/509, chromium e2e 164/164.
+- [x] `on_undo_redo_blocked(kind, subtask_key, from_subtask_key, origin_subtask_key)` host callback. jest 510/510.
+
+### Fly to undo/redo changes
+
+- [x] `fly_to_on_undo` (default true): user undo/redo centers on the changed annotations
+  (own + `affected`, before and after) only when none is in view; keeps zoom unless they don't fit.
+- [x] Tests, docs, lint, build, jest 512/512, chromium e2e 166/166.
+- [x] Fly after the action listeners (rebuilt boxes); target the after boxes, before boxes
+  only when none remain. Live-checked all types and ops.
+
+### Polyline body move: midpoint insert handles
+
+- [x] Snap the segment insert handle to the hovered segment's midpoint, so dragging
+  the rest of a polyline stroke moves it.
+- [x] Tests, docs, lint, build, jest 513/513, chromium e2e 168/168.
+- [x] Review fixes: take the segment index from the nearest-point search (an endpoint
+  projection no longer indexes past the last segment); `delete_counterparts` flies to
+  affected counterparts only. Jest 515/515, chromium e2e 168/168.
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8a624fc8..21a35384 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,45 @@
 
 All notable changes to this project will be documented here.
 
+## [0.29.0] - Oct 12th, 2026
+#### Breaking Changes
+- **Drag a body to move it.** A left-drag that starts inside a spatial annotation moves it (now including `contour`, `tbar`, and `bbox3`). A drag on a vertex handle edits the vertex, and a drag anywhere else draws. Hold `Alt` to draw over an annotation. Set `allow_body_move: false` for the old draw-everywhere behavior.
+- **The hover edit ring is gone.** Hovering shows only the outline and the confidence card. To reclassify or delete, use the class and delete keybinds or the new context menu. `show_id_dialog()` lost `thumbnail` and `suggest_edits()` lost `force_refresh`. `ULabelActionCandidate` gained `containing`.
+
+#### Added
+- **Context menu.** Right-click a hovered annotation or an `AnnotationList` entry for Change class, Delete, Isolate / Show all, Details, and the items below. New `show_context_menu()`, `hide_context_menu()`, and `is_context_menu_open()`.
+- **Copy and move between subtasks** with Copy to / Move to or `ctrl+c` / `ctrl+x` / `ctrl+v`. The system clipboard holds JSON, so copies can be pasted into another ULabel instance whose image is the same size. A copy keeps its geometry, takes the target class matching its own (by id, then name), and records `annotation_meta.copied_from`. Both are undoable (`paste_annotation` / `move_annotation`). New config options `paste_class_choice` and `paste_switch_to_target`. New `copy_annotation()`, `copy_annotation_to_clipboard()`, `paste_annotation_from_clipboard()`, `find_pasted_copy()`, `set_paste_switch_to_target()` / `get_paste_switch_to_target()`, and the `ULabelClipboardEnvelope` type.
+- **Cross-subtask counterparts:** annotations linked by `copied_from` or by the new `annotation_link_meta_key` config option. New `find_counterparts()`. The menu offers Delete from `<subtask>` (and Erase from `<subtask>` for bitmasks) via `delete_counterparts()`, recorded as one undoable action. Copy to / Move to ask before duplicating a counterpart; `hide_copy_to_linked` hides those targets instead.
+- **Isolate:** an `AnnotationList` eye button (or the menu) hides all other annotations from the canvas and input until cleared. It is view-only. New `isolate_annotation()`, `get_isolated_annotation_id()`, and `on_isolate_change`.
+- **Edit focus:** a per-subtask `focus_edited` option dims annotations not edited since load. Toggle it with the **Edited Only** checkbox, `toggle_edit_focus_keybind` (`h`), or `set_focus_edited()`. New `on_focus_edited_change`.
+- **Deprecated focus:** **Show Deprecated** is now a per-subtask `focus_deprecated` option and is no longer persisted. Deprecated annotations are shown and in focus while live ones dim. Edits are locked except Restore and undo/redo, and a banner offers an Exit link. Toggle it with `toggle_deprecated_focus_keybind` (`shift+d`) or `set_focus_deprecated()`. New `on_focus_deprecated_change`.
+- **Restore** menu item and `restore_annotation()` for human-deleted annotations.
+- **Submit buttons** have two optional fields: `subtasks` (a whitelist of subtask keys) and `edits_only` (only annotations created, deleted, or modified since load, tagged with `edit_type`). New `has_edits(subtasks?)` reports whether an `edits_only` submit would send anything.
+- **`on_annotation_change`** callback: fires for each action that changes annotations, or its undo/redo, with the other annotations it changed in `affected`. Set `on_annotation_change_in_progress` to also report `continue_*` actions.
+- `fly_to_on_undo` (default `true`): an undo or redo whose changes are out of view centers the view on them.
+- `set_subtask_read_only(subtask_key, read_only)` toggles read-only at runtime.
+- Undo/redo in a read-only subtask now applies to the only writable subtask, for actions triggered from the read-only subtask (e.g. Copy to, Delete from). Actions record `origin_subtask_key`. New `on_undo_redo_blocked` callback.
+
+#### Changed
+- The polygon/polyline vertex-insert handle now sits at the hovered segment's midpoint, so dragging elsewhere on a polyline moves it.
+- Editing a non-spatial note is now an undoable `edit_text_payload` action.
+- `last_edited_at` / `last_edited_by` are now stamped on annotations an action changes indirectly (delete-mode victims, carved masks) and restored on undo.
+- Cancelling an in-progress drawing removes it instead of deprecating it.
+- Annotations deleted by erasing their vertices or by a polygon brush stroke keep their original geometry. A polygon brush stroke that deletes a polygon is one undo step.
+- Brushes only affect annotations in focus.
+- Read-only is enforced on the brush, undo/redo, and non-spatial rows.
+- `Escape` closes the class pie.
+- A click without a drag no longer records `begin_move`. Picking an annotation's current class no longer records `assign_annotation_id`.
+- `demo.js` honors `PORT`, and demos load their image locally.
+
+#### Fixed
+- The hover confidence card overflowing the canvas near the image edges.
+- A `TypeError` on the first brush stroke after a subtask switch or `set_annotations()`.
+- Undoing a brush stroke or a new layer on a loaded annotation leaving the session's edit stamp in place.
+- Shift-hover in a read-only subtask starting a complex layer.
+- A `NaN` circle radius error when entering a delete mode in a single-class subtask.
+- Anchor buttons navigating the host page to `#`.
+
 ## [0.28.0] - Sept 10th, 2026
 - New `set_active_class(class_id, subtask_key?, redraw?)` and `get_selected_class_id(subtask_key?)` public API methods; all internal class-selection paths (toolbox clicks, keybinds, delete-mode toggles) route through `set_active_class`.
 - New per-subtask `focus_active_class` option (default `false`): the selected class is the focused class — other classes dim to `defocused_opacity` and drop out of hover, Tab navigation, the annotation list, and bulk delete. Toggleable via `set_focus_active_class()` or `toggle_class_focus_keybind` (default `shift+f`).
diff --git a/api_spec.md b/api_spec.md
index ab8f91b5..7a8df0b6 100644
--- a/api_spec.md
+++ b/api_spec.md
@@ -6,6 +6,8 @@ This should eventually be replaced with a more comprehensive approach to documen
 
 - `ctrl+z` or `cmd+z`: Undo
 - `ctrl+shift+z` or `cmd+shift+z`: Redo
+
+In a read-only subtask, undo and redo act on the only writable subtask, if there is exactly one, and only when the action on top of its undo (or redo) history was triggered from that read-only subtask (such as **Copy to** or **Delete from**); otherwise they do nothing. They run in place, or after switching to the writable subtask when [`paste_switch_to_target`](#paste_switch_to_target) is set. Each action records the subtask it was triggered from as `origin_subtask_key`; a redo issued from the writable subtask takes it over.
 - `scroll`: Zoom -- up for in, down for out
 - `ctrl+scroll` or `shift+scroll` or `cmd+scroll`: Change frame -- down for next, up for previous
 - `scrollclick+drag`: Pan
@@ -15,6 +17,9 @@ This should eventually be replaced with a more comprehensive approach to documen
 - Press `Escape` to exit brush/erase mode.
 - Press `Tab` to set the zoom to focus on the next annotation
 - Press `Shift+Tab` to set the zoom to focus on the previous annotation
+- Right-click a hovered annotation (or its entry in the `AnnotationList` toolbox item) to open a context menu with `Change class`, `Copy to`, `Move to`, `Delete`, `Isolate` / `Show all`, and `Details`. `Change class` opens the class pie for that annotation; `Copy to` / `Move to` clone the annotation into another subtask at the same image coordinates (see [`copy_annotation`](#copy_annotationannotation_id-target_subtask_key-class_id-source_subtask_key)) -- a single eligible subtask is named on the item, several open a list to pick from, and `Move to` also deletes the source (one undoable action on the source subtask that also removes the copy and the target's history about it). Both also arm `ctrl+v` with the annotation, and when the target already has a counterpart of it (see [`find_counterparts`](#find_counterpartsannotation_id-source_key-target_key)) a confirm dialog asks before copying again. `Delete from` appears for every other writable subtask holding counterparts and deletes them there, reading `Delete <n> from <subtask>` (or `<subtask> (<n>)` in the list) when there is more than one; a bitmask also offers `Erase from`, which only subtracts its mask (see [`delete_counterparts`](#delete_counterpartsannotation_id-source_key-target_key-erase)). The view stays on the source subtask unless the class pie opens or [`paste_switch_to_target`](#paste_switch_to_target) is on; `Isolate` hides every other annotation in the subtask (see [`isolate_annotation`](#isolate_annotationannotation_id-subtask_key-redraw)) and reads `Show all` while that annotation is isolated; `Details` lists its id, class, spatial type, last editor/edit time, what deprecated it (deprecated annotations only), and `annotation_meta` entries. Read-only subtasks only offer `Copy to`, `Delete from` / `Erase from`, `Isolate`, and `Details`. A deprecated annotation (hoverable only under deprecated focus, see **Show Deprecated** in the `AnnotationList` toolbox item) offers `Restore`, `Isolate` / `Show all`, and `Details`; `Restore` appears only for annotations deleted by a human and nothing else, on writable subtasks, and not for a bitmask erased to nothing (see [`restore_annotation`](#restore_annotationannotation_id)). Press `Escape` or click anywhere to close it. A right-click while drawing a polyline still finishes the polyline and opens no menu.
+- Press `Escape` to close an open class pie or context menu.
+- `ctrl+c` / `cmd+c` copies the hovered annotation, `ctrl+x` / `cmd+x` cuts it (deletes it after copying; not in read-only subtasks), and `ctrl+v` / `cmd+v` pastes into the current subtask (see [`paste_annotation_from_clipboard`](#paste_annotation_from_clipboardenvelope)). The copy is placed on the system clipboard as JSON, so it can be pasted into another ULabel instance showing an image of the same dimensions; a paste back into the subtask it was copied from keeps its class; the first paste into another subtask keeps the coordinates, and every repeat paste into the same subtask (or any paste back into the source) is offset by a further 20 pixels. These shortcuts are not remappable and are ignored while a text field has focus.
 
 ## ULabel Constructor
 
@@ -72,6 +77,11 @@ class ULabel({
     mask_annotation_opacity: number,
     default_brush_overlap_mode: BrushOverlapMode,
     brush_overlap_across_subtasks: boolean,
+    allow_body_move: boolean,
+    paste_class_choice: boolean,
+    paste_switch_to_target: boolean,
+    annotation_link_meta_key: string | null,
+    hide_copy_to_linked: boolean,
     set_brush_overlap_none_keybind: string,
     set_brush_overlap_exclude_keybind: string,
     set_brush_overlap_overwrite_keybind: string,
@@ -83,13 +93,22 @@ class ULabel({
     annotation_size_minus_keybind: string,
     annotation_vanish_keybind: string,
     toggle_class_focus_keybind: string,
+    toggle_edit_focus_keybind: string,
+    toggle_deprecated_focus_keybind: string,
     fly_to_max_zoom: number,
+    fly_to_on_undo: boolean,
     min_zoom_fit_ratio: number,
     n_annos_per_canvas: number,
     auto_destroy_on_detach: boolean,
     on_active_class_change: function,
     on_subtask_change: function,
-    on_focus_active_class_change: function
+    on_focus_active_class_change: function,
+    on_focus_edited_change: function,
+    on_focus_deprecated_change: function,
+    on_isolate_change: function,
+    on_undo_redo_blocked: function,
+    on_annotation_change: function,
+    on_annotation_change_in_progress: boolean
 })
 ```
 
@@ -146,6 +165,26 @@ If either more than one submit button or more button customization is desired, t
     // Buttons with lower row numbers will be higher in the toolbox
     // If row_number is not provided, it will default to 0
     // Buttons will be arranged left to right in the order they are provided in the array
+    /**
+     * Only include these subtask keys in the payload's `annotations` object.
+     * Unknown keys are ignored with a warning. Defaults to every subtask.
+     */
+    subtasks?: string[]
+    /**
+     * If true, each subtask's list is reduced to the annotations that differ from
+     * what the host loaded (via `resume_from`, `set_annotations()`, or
+     * `set_annotations_batch()`): created this session and not deleted, loaded and
+     * now deleted, or loaded and edited (moved, reclassified, brushed, carved by a
+     * delete polygon or an overlapping bitmask stroke, un-deleted...). Undoing an
+     * edit removes the annotation from the list again. Annotations hidden only by
+     * a filter (confidence slider, row distance) are not edits. Each included
+     * annotation carries `edit_type: "created" | "deleted" | "modified"`, and its
+     * `deprecated` flag reflects only human deletion (a filter hiding a modified
+     * annotation does not make it `deprecated` in this payload). A loaded
+     * annotation whose geometry was fully erased is still reported as `"deleted"`.
+     * Defaults to false.
+     */
+    edits_only?: boolean
 }
 ```
 
@@ -162,7 +201,7 @@ The argument to the hook is an object with the format:
 }
 ```
 
-Where `<subtask n>` refers to the nth key in the object provided as the `subtasks` argument to the constructor.
+Where `<subtask n>` refers to the nth key in the object provided as the `subtasks` argument to the constructor. With `subtasks` set on the button, only those keys appear; with `edits_only`, each list contains only the annotations that changed since they were loaded (see above), each tagged with an `edit_type` of `"created"`, `"deleted"`, or `"modified"`.
 
 As you can see, each subtask will have a corresponding list of annotation objects. Each annotation object has the following format:
 
@@ -287,6 +326,8 @@ Every annotation session requires at least one subtask. Each subtask has its own
 ```
 The `"keybind"` argument allows the user to select a class for existing annotations (when hovered), for new annotations, or for annotations that are actively being drawn.
 
+With `"read_only": true`, the subtask's annotations can be viewed but not created, edited, moved, deleted, reclassified, or undone/redone by the user. Toggle it at runtime with [`set_subtask_read_only`](#set_subtask_read_onlysubtask_key-read_only).
+
 The full list of `"allowed_modes"` that are currently supported is:
 
 - `"bbox"`: A simple single-frame bounding box
@@ -310,7 +351,7 @@ The `"bitmask"` mode enables raster (per-pixel) segmentation. Each bitmask annot
 
 - Painting uses the brush, shared with the `polygon` brush. Toggle the brush with `toggle_brush_mode_keybind` (default `g`) or the Brush toolbox item, erase with `toggle_erase_mode_keybind` (default `e`), and resize the brush with `increase_brush_size_keybind` / `decrease_brush_size_keybind` (defaults `]` / `[`) or `alt+scroll`.
 - Starting a paint stroke over an existing bitmask of the **currently-selected class** adds to that mask; otherwise (a different class is selected, or you start over empty space) a new bitmask annotation of the selected class is created. Erasing is class-agnostic — it removes from whichever mask is under the brush. (This class-aware joining differs from the `polygon` brush, which joins any polygon under the brush.)
-- With the brush off, hovering a mask surfaces the usual edit dialogs: change its class via the ID dialog, or move/delete it like any other spatial annotation. Erasing a mask entirely deprecates the annotation (ULabel's delete semantics).
+- With the brush off, a mask behaves like any other spatial annotation: hover it for the outline and confidence card, drag its body to move it (see [`allow_body_move`](#allow_body_move)), press a class keybind while hovering to reclassify it, or delete it with the delete keybind. Erasing a mask entirely deprecates the annotation (ULabel's delete semantics).
 - Requires the `Brush` toolbox item (`AllowedToolboxItem.Brush`) to be present.
 
 **Overlap modes**
@@ -494,7 +535,7 @@ The `AnnotationList` toolbox item displays all annotations in the current subtas
 - Collapsible interface to maximize canvas space
 
 **Filtering Options:**
-- **Show Deprecated**: Toggle to show/hide deprecated annotations (default: hidden)
+- **Show Deprecated**: Turns on deprecated focus for the current subtask (`focus_deprecated`, default off; also a subtask option at load and `set_focus_deprecated(subtask_key, enabled, redraw = true)` at runtime). Deprecated annotations, whatever deprecated them, are drawn and become the only ones in focus: live annotations dim to `defocused_opacity` and drop out of hover, navigation, the list, and bulk delete. Deprecated annotations can be hovered, isolated, navigated to, and restored from the context menu, but not edited, moved, reclassified, or deleted. While it is on, the subtask's user input is locked like `read_only`, except that Restore and undo/redo still work: no drawing, brushing, pasting, deleting, or reclassifying. Turning it on discards any drawing in progress. The canvas shows a `not-allowed` cursor, and a banner over the image reads "Showing deleted annotations · editing disabled" with an Exit link that turns the mode off. API methods are not locked. Composes with **Edited Only** (leaving this session's deletions of loaded annotations) and class focus. Deprecated entries carry a marker whose tooltip names what deprecated them. Non-spatial deprecated annotations are listed but not drawn.
 - **Group by Class**: Organize annotations by their classification for easier management
 
 **Navigation:**
@@ -502,9 +543,14 @@ The `AnnotationList` toolbox item displays all annotations in the current subtas
 - Toast notification appears showing current position (e.g., "3 / 10") when navigating
 
 **Bidirectional Highlighting:**
-- Hover over an annotation in the list to highlight it on the canvas with the ID dialog
+- Hover over an annotation in the list to highlight it on the canvas (outline and confidence card)
 - Hover over an annotation on the canvas to highlight its corresponding entry in the list
 
+**Isolation:**
+- Each entry has an eye button that isolates that annotation: every other annotation in the subtask is hidden from the canvas and from hover, Tab, fly-to, the list, and bulk delete. The list shows only the isolated entry and a **Show all** button appears in the header.
+- Clear it with **Show all**, the active eye button, `Escape`, or programmatically with [`isolate_annotation(null)`](#isolate_annotationannotation_id-subtask_key-redraw). It also clears when the isolated annotation is deleted, when a new annotation is created, on subtask switch, and on `set_annotations()`.
+- Isolation is a view-only state: nothing is recorded in the action stream and `get_annotations()` is unaffected.
+
 This toolbox item requires no configuration and can be added to the `toolbox_order` array using `AllowedToolboxItem.AnnotationList`.
 
 ### `confidence_slider_toolbox_item`
@@ -616,6 +662,21 @@ The initial [brush overlap mode](#overlap-modes) for bitmask painting: `"none"`
 ### `brush_overlap_across_subtasks`
 When `true`, [brush overlap resolution](#overlap-modes) also reaches undeprecated bitmask annotations in *other* subtasks: `"exclude"` clips the stroke against them, and `"overwrite"` carves them — except masks in `read_only` subtasks, which act as barriers (the stroke is clipped around them instead). Default is `false`: a stroke only interacts with masks in the active subtask.
 
+### `allow_body_move`
+When `true` (the default), a plain left-drag that starts inside a spatial annotation's body moves that annotation. The cursor must actually be inside the shape (a polygon's fill, a bbox, a point's handle, a polyline's stroke, a bitmask's pixels) — being merely near its bounding box still starts a new annotation. A vertex edit handle under the cursor takes precedence and edits that vertex. On polygons and polylines the handle for inserting a new vertex sits at the midpoint of the hovered segment, so dragging the rest of a polyline's stroke moves it. Hold `Alt` to start a new annotation on top of an existing body instead. Delete modes and read-only subtasks are unaffected. Set to `false` to make every canvas drag start a new annotation.
+
+### `paste_class_choice`
+When `true` (the default), a context-menu `Copy to` / `Move to` or a `ctrl+v` paste whose source class has no counterpart in the target subtask (by id, then by name) opens the class pie on the pasted annotation when several classes could take it. Set to `false` to never open the pie: the copy silently takes the target's active class (else its first compatible class). Useful when the source subtask's classes (e.g. `True Positive` / `False Negative`) can never match the target's and the host keeps the target's active class in sync with its own class picker.
+
+### `paste_switch_to_target`
+When `true`, a context-menu `Copy to` / `Move to` / `Delete from` / `Erase from` makes the target the current subtask afterwards (firing [`on_subtask_change`](#on_subtask_change)), whether or not the class pie opens; an undo/redo from a read-only subtask likewise switches to the writable subtask it acts on. Default is `false`: the view only switches when the class pie opens on the copy. Toggle at runtime with [`set_paste_switch_to_target`](#set_paste_switch_to_targetenabled). `ctrl+v` pastes into the current subtask and is unaffected.
+
+### `annotation_link_meta_key`
+An `annotation_meta` key whose value, a string or an array of strings, links annotations across subtasks: two annotations are counterparts when they share any value (see [`find_counterparts`](#find_counterpartsannotation_id-source_key-target_key)). Every copy and paste drops this entry from the copy's `annotation_meta`, so a copy never claims its source's identity. Default is `null` (only `copied_from` links).
+
+### `hide_copy_to_linked`
+When `true`, the context menu leaves out `Copy to` / `Move to` for every subtask that already holds a counterpart of the annotation (see [`find_counterparts`](#find_counterpartsannotation_id-source_key-target_key)), instead of asking before copying again. `ctrl+v` is unaffected. Default is `false`.
+
 ### `set_brush_overlap_none_keybind`
 Keybind to set the brush overlap mode to `none`. Default is `shift+n`.
 
@@ -652,6 +713,15 @@ Keybind to toggle vanish mode for all subtasks. Default is `shift+v`
 ### `toggle_class_focus_keybind`
 Keybind to toggle `focus_active_class` on the current subtask: with it on, classes other than the active one dim to `defocused_opacity` and drop out of hover, navigation, the annotation list, and bulk delete. Default is `shift+f`.
 
+### `toggle_edit_focus_keybind`
+Keybind to toggle `focus_edited` on the current subtask (also the **Edited Only** checkbox in the `AnnotationList` toolbox item): with it on, annotations not created or modified since load (the `edits_only` submit rule) dim to `defocused_opacity` and drop out of hover, navigation, the annotation list, and bulk delete. Composes with class focus. Set per subtask at load with a subtask's `focus_edited: true`, or at runtime with `set_focus_edited(subtask_key, enabled, redraw = true)`. Default is `h`.
+
+### `toggle_deprecated_focus_keybind`
+Keybind to toggle `focus_deprecated` on the current subtask, the same as the **Show Deprecated** checkbox in the `AnnotationList` toolbox item. Default is `shift+d`.
+
+### `fly_to_on_undo`
+After a user undo or redo, center the view on the annotations it changed (the action's annotation plus any `affected` ones, in any subtask) when none of them is in view after the change. It targets where the change left them (e.g. a move's original position on undo), or where they were if none remain (e.g. undoing a create). The zoom is kept unless their combined box does not fit, in which case it zooms out to fit. Internal undos, in-progress steps, and non-spatial annotations never move the view. Default is `true`.
+
 ### `fly_to_max_zoom`
 Maximum zoom factor used when flying-to an annotation. Default is `10`, value must be > `0`. 
 
@@ -681,6 +751,42 @@ When `true` (the default), ULabel installs a `MutationObserver` on the container
 ### `on_focus_active_class_change`
 *(subtask_key: string, enabled: boolean) => void* -- Called after a subtask's `focus_active_class` flag actually changes, whatever the writer: `set_focus_active_class` or the `toggle_class_focus_keybind`. Not called when the flag is already at the target value, so a host may re-sync other subtasks from the callback without recursing. Default is `null`.
 
+### `on_focus_edited_change`
+*(subtask_key: string, enabled: boolean) => void* -- Called after a subtask's `focus_edited` flag actually changes, whatever the writer: `set_focus_edited`, the `toggle_edit_focus_keybind`, or the annotation list's **Edited Only** checkbox. Not called when the flag is already at the target value. Default is `null`.
+
+### `on_focus_deprecated_change`
+*(subtask_key: string, enabled: boolean) => void* -- Called after a subtask's `focus_deprecated` flag actually changes, whatever the writer: `set_focus_deprecated`, the `toggle_deprecated_focus_keybind`, or the annotation list's **Show Deprecated** checkbox. Not called when the flag is already at the target value. Default is `null`.
+
+### `on_isolate_change`
+*(subtask_key: string, annotation_id: string | null) => void* -- Called after a subtask's isolated annotation actually changes, whatever the writer: `isolate_annotation`, the list's eye button, `Show all`, `Escape`, or one of the automatic clears (deletion, creation, subtask switch, `set_annotations`). `annotation_id` is `null` when the isolation clears. Default is `null`.
+
+### `on_undo_redo_blocked`
+*(kind: "undo" | "redo", subtask_key: string, from_subtask_key: string, origin_subtask_key: string | null) => void* -- Called when an undo or redo issued from read-only subtask `from_subtask_key` does nothing because the action on top of the sole writable subtask `subtask_key`'s history was triggered from `origin_subtask_key`, not from `from_subtask_key` (see [Keyboard Shortcuts](#keyboard-shortcuts)). Not called when that history is empty. Default is `null`.
+
+### `on_annotation_change`
+*(change: ULabelAnnotationChange) => void* -- Called once per recorded, undone, or redone action that changes committed annotation state (geometry, position, deprecation, or class), so a host can recompute derived data (e.g. a live diff against fixed predictions) without polling the action stream. Default is `null`. Exceptions thrown by the callback are caught and logged as warnings.
+
+```javascript
+{
+    subtask_key: string,                 // subtask whose action stream holds the action
+    annotation_id: string | null,
+    act_type: ULabelActionType,
+    kind: "do" | "undo" | "redo",
+    affected: { subtask_key, annotation_id }[],  // other annotations the action edited
+    previous_classification_payloads: ULabelClassificationPayload[] | null,
+    from_subtask_key: string | null,     // read-only subtask an undo/redo was issued from
+}
+```
+
+- One call per action, never per annotation. Cross-subtask actions record on one stream and list the other side in `affected`: `paste_annotation` records on the target; `move_annotation` records on the source with the target copy in `affected`; a `bitmask_stroke` that resolves overlap lists the other masks. A host interested in one subtask checks both `subtask_key` and `affected`.
+- `previous_classification_payloads` is set for `assign_annotation_id` only and is always what the annotation had immediately before this event (for every `kind`); the annotation itself already holds the new payloads.
+- `from_subtask_key` is set on an `"undo"` / `"redo"` issued from a read-only subtask and run on the sole writable one (see [Keyboard Shortcuts](#keyboard-shortcuts)), with or without `paste_switch_to_target`; otherwise `null`.
+- Not reported: `continue_*` (in-progress draw/edit/move/brush) unless `on_annotation_change_in_progress` is `true`; `begin_annotation`, `begin_edit`, `begin_move`, `begin_brush`, `start_complex_polygon`, and `create_nonspatial_annotation` on `"do"` (nothing is committed until the matching `finish_*`/`create_annotation`; their `"undo"`/`"redo"` do fire since that is what reverts or re-applies the change); the internal `simplify_polygon_complex_layer` / `merge_polygon_complex_layer` steps of finishing a polygon (the `finish_annotation` that follows reports the final geometry); `edit_text_payload`; a zero-distance move; re-picking an annotation's current class.
+- Not fired by `set_annotations`, `set_annotations_batch`, `set_saved`, or `resume_from` on init: those replace state without recording actions.
+
+### `on_annotation_change_in_progress`
+*boolean* -- Also report `continue_annotation`, `continue_edit`, `continue_move`, `continue_brush`, and `continue_bitmask` to `on_annotation_change`. These fire on every mouse move during a drag. Default is `false`.
+
 
 ## Display Utility Functions
 
@@ -734,6 +840,10 @@ When batching several per-subtask swaps, prefer [`set_annotations_batch()`](#set
 
 *(bool) => void* -- Allows js script implementing the ULabel class to set saved status, e.g., during callback.
 
+### `has_edits(subtasks?)`
+
+*(subtasks?: string[] | null) => boolean* -- Whether a submit button with `edits_only` (and this `subtasks` list; default all subtasks) would send any annotation. Unlike `state.edited`, which stays set until [`set_saved(true)`](#set_savedsaved), this turns `false` again when every edit is undone. It compares against what was loaded via `resume_from` / `set_annotations()`, not the last save. Builds the payload on each call.
+
 ### `remove_listeners()`
 
 *() => void* -- Removes persistent event listeners from the document and window. Listeners attached directly to html elements are not explicitly removed.
@@ -765,6 +875,62 @@ Sets the zoom to focus on the provided annotation id, and switches to its subtas
 ### `fly_to_annotation(annotation, subtask_key, max_zoom)`
 Sets the zoom to focus on the provided annotation, and switches to its subtask if provided. Returns `true` on success and `false` on failure (eg, annotation doesn't exist in subtask, is not a spatial annotation, or is deprecated).
 
+### `show_context_menu(annotation_id, client_x, client_y)`
+
+*(annotation_id: string, client_x: number, client_y: number) => boolean* -- Opens the right-click context menu for the given annotation in the current subtask at the given viewport position (clamped to stay on screen). Returns `false` and opens nothing if the annotation is unknown or deprecated. Any open menu is replaced.
+
+### `hide_context_menu()`
+
+*() => void* -- Closes the context menu if open and clears the hover highlight it was holding. No-op otherwise. Called internally on Escape, any mousedown, zoom, `set_subtask`, and when the target annotation is deleted.
+
+### `is_context_menu_open()`
+
+*() => boolean* -- Whether the context menu is currently open.
+
+### `copy_annotation(annotation_id, target_subtask_key, class_id?, source_subtask_key?)`
+
+*(annotation_id: string, target_subtask_key: string, class_id?: number | null, source_subtask_key?: string | null) => string | null* -- Clones a spatial annotation from one subtask (default: the current one) into another at the same image coordinates and returns the new annotation's id, or `null` when the target is read-only, does not allow the annotation's spatial type, or has no class that accepts it. The class defaults to the target class matching the source class by id, else by name, else the target's active class, else its first compatible class. The copy's `annotation_meta.copied_from` is set to `{ subtask_key, annotation_id }` of the source (merged into the source's `annotation_meta` when that is an object), so the copy's origin survives serialization and `edits_only` payloads. The paste is recorded on the target subtask's action stream (`paste_annotation`) and can be undone there.
+
+### `find_pasted_copy(annotation_id, source_key, target_key)`
+
+*(annotation_id: string, source_key: string, target_key: string) => string | null* -- Id of an annotation in `target_key` whose `annotation_meta.copied_from` names `annotation_id` in `source_key` and that has not been deleted by a human (copies hidden by a confidence/distance filter still count), or `null`. Undoing the paste (or deleting the copy) clears it; redo re-arms it. The context menu uses this to ask before copying the same annotation into a subtask twice; `ctrl+v` does not check (a repeat paste there is deliberate and offset).
+
+### `find_counterparts(annotation_id, source_key, target_key)`
+
+*(annotation_id: string, source_key: string, target_key: string) => string[]* -- Ids of the spatial annotations in `target_key` linked to `annotation_id` in `source_key`: copies of it, the annotation it was copied from (both via `annotation_meta.copied_from`), and annotations sharing a value under [`annotation_link_meta_key`](#annotation_link_meta_key). Human-deleted annotations are skipped; filter-hidden ones count. Empty when `source_key === target_key`. The context menu uses this for the copy confirm and for `Delete from` / `Erase from`.
+
+### `delete_counterparts(annotation_id, source_key, target_key, erase?)`
+
+*(annotation_id: string, source_key: string, target_key: string, erase?: boolean | null) => string[]* -- Removes the counterparts (see [`find_counterparts`](#find_counterpartsannotation_id-source_key-target_key)) from `target_key`, which must not be read-only; the source may be. With `erase` (default: whether the source is a bitmask; only a bitmask source can erase), the source mask is subtracted from its bitmask counterparts (a mask erased to nothing is deleted) and other counterparts are left alone; otherwise every counterpart is deleted. Recorded as one `delete_counterparts` action on the target subtask's stream (undo there restores every mask and deletion) and reported to [`on_annotation_change`](#on_annotation_change) with the target as `subtask_key` and the changed counterparts as `affected`. Returns the changed ids; nothing is recorded when none changed. When something changed and [`paste_switch_to_target`](#paste_switch_to_target) is on, the target becomes the current subtask.
+
+### `set_paste_switch_to_target(enabled)` / `get_paste_switch_to_target()`
+
+*(enabled: boolean) => void* / *() => boolean* -- Read or change [`paste_switch_to_target`](#paste_switch_to_target) at runtime.
+
+### `copy_annotation_to_clipboard(annotation_id?, cut?)`
+
+*(annotation_id?: string | null, cut?: boolean) => ULabelClipboardEnvelope | null* -- Stores a copy of an annotation in the current subtask (default: the hovered one) on the in-memory clipboard and returns the envelope `{ ulabel_annotation: 1, copy_id, copied_at, image_width, image_height, source_subtask_key, source_class_name, annotation }`. With `cut`, the source is deleted afterwards (refused in read-only subtasks). Returns `null` for deprecated, non-spatial, or delete-mode annotations.
+
+### `paste_annotation_from_clipboard(envelope?)`
+
+*(envelope?: ULabelClipboardEnvelope | null) => string | null* -- Pastes an envelope (default: the in-memory clipboard) into the current subtask and returns the new annotation's id. When the given envelope and the in-memory clipboard hold different copies, the newer `copied_at` wins (so a menu copy whose system clipboard write failed still pastes). Refused with a warning when the envelope's image dimensions differ from the current image or when no class in the current subtask accepts the annotation. A paste back into `source_subtask_key` keeps its class. The first paste into another subtask keeps the coordinates; each repeat paste into the same subtask, and any paste back into the source, is offset by a further 20 pixels (`paste_counts`, per target subtask, tracked per `copy_id`). When the source class has no counterpart in the target (by id, then by name; the envelope's `source_class_name`) and several classes could take the annotation, the class pie opens on the pasted annotation unless [`paste_class_choice`](#paste_class_choice) is `false`. The copy's `annotation_meta.copied_from` records the envelope's `source_subtask_key` and the source annotation id.
+
+### `set_subtask_read_only(subtask_key, read_only)`
+
+*(subtask_key: string, read_only: boolean) => void* -- Make a subtask read-only or editable without recreating ULabel. Making the current subtask read-only first completes an active mouse drag, then discards other in-progress work as `Escape` would (a complex polygon layer being started, an unfinished annotation), turns the brush off, and closes the class pie and context menu. Non-spatial rows are re-rendered with or without their controls. Zoom, isolation, class focus, active class, and the undo history are kept; user undo/redo is blocked while any subtask the action touched is read-only (from a read-only current subtask it goes to the sole writable subtask, see [Keyboard Shortcuts](#keyboard-shortcuts)). Unknown subtask keys log a warning; setting the current value does nothing. Not recorded and does not mark the session edited; the toggle itself fires no callback, but the completed drag and discarded work are recorded and reported to [`on_annotation_change`](#on_annotation_change) exactly as the mouse-up or `Escape` would be.
+
+### `isolate_annotation(annotation_id, subtask_key?, redraw?)`
+
+*(annotation_id: string | null, subtask_key?: string | null, redraw?: boolean) => boolean* -- Isolate one annotation in a subtask (default: the current one): every other annotation is hidden from the canvas and from input until cleared by passing `null`. Returns `false` and changes nothing for an unknown subtask or an unknown annotation, or a deprecated one outside deprecated focus (turning deprecated focus off releases a deprecated isolation). View-only: not recorded, does not mark the session edited. Fires [`on_isolate_change`](#on_isolate_change) on an actual change.
+
+### `get_isolated_annotation_id(subtask_key?)`
+
+*(subtask_key?: string | null) => string | null* -- The isolated annotation id in a subtask (default: the current one), or `null`.
+
+### `restore_annotation(annotation_id)`
+
+*(annotation_id: string) => boolean* -- Undeletes an annotation in the current subtask, as the context menu's `Restore` does. Refused (returns `false`) unless `can_restore_annotation(annotation_id)`: deleted by a human and by nothing else (filter-deprecated annotations stay deprecated), a writable subtask, and geometry that can stand alone (not a delete shape, an empty polygon or bitmask, or a polyline / contour with fewer than 2 points). A vertex delete or brush stroke that removes an annotation keeps its original shape, so restoring it brings that shape back. The edit stamp (`last_edited_at` / `last_edited_by`) reverts to what it was before the recorded action that deleted it, so restoring an unedited loaded annotation leaves it unedited for `edits_only` and Edited Only; when no recorded action deleted it (it was loaded deprecated) it is stamped now. Recorded as a `restore_annotation` action (undo deletes it again) and reported to [`on_annotation_change`](#on_annotation_change).
+
 ### `get_keypoint_slider_value()`
 
 *() => number | null* -- Returns the current keypoint slider value as a number between 0 and 1. Returns `null` if the KeypointSlider toolbox item is not active or the slider element is not found.
diff --git a/demo.js b/demo.js
index 6c497ab1..4a7554be 100644
--- a/demo.js
+++ b/demo.js
@@ -1,21 +1,45 @@
 const express = require('express');
 const app = express();
-const port = 8080;
+// Override with PORT=... (Playwright reads the same variable). Falls through to the next
+// free port when the requested one is busy, unless PORT was set explicitly.
+const requested_port = Number(process.env.PORT) || 8080;
+const port_is_explicit = Boolean(process.env.PORT);
+const max_port_attempts = 20;
 
 app.use(express.static('demo'));
 app.use(express.static('dist'));
-app.listen(port);
 
-// Show URLs for the various demos
-console.log(`http://localhost:${port}/single-class.html`);
-console.log(`http://localhost:${port}/multi-class.html`);
-console.log(`http://localhost:${port}/frames.html`);
-console.log(`http://localhost:${port}/box-roi.html`);
-console.log(`http://localhost:${port}/resume-from.html`);
-console.log(`http://localhost:${port}/read-only.html`);
-console.log(`http://localhost:${port}/row-filtering-example.html`);
-console.log(`http://localhost:${port}/bitmask-example.html`);
-console.log(`http://localhost:${port}/set-annotations.html`);
-console.log(`http://localhost:${port}/class-focus.html`);
-console.log(`http://localhost:${port}/live_demo.html`);
-console.log(`http://localhost:${port}/offset-container.html`);
\ No newline at end of file
+function show_demo_urls(port) {
+    console.log(`http://localhost:${port}/single-class.html`);
+    console.log(`http://localhost:${port}/multi-class.html`);
+    console.log(`http://localhost:${port}/frames.html`);
+    console.log(`http://localhost:${port}/box-roi.html`);
+    console.log(`http://localhost:${port}/resume-from.html`);
+    console.log(`http://localhost:${port}/read-only.html`);
+    console.log(`http://localhost:${port}/row-filtering-example.html`);
+    console.log(`http://localhost:${port}/bitmask-example.html`);
+    console.log(`http://localhost:${port}/set-annotations.html`);
+    console.log(`http://localhost:${port}/class-focus.html`);
+    console.log(`http://localhost:${port}/live_demo.html`);
+    console.log(`http://localhost:${port}/offset-container.html`);
+    console.log(`http://localhost:${port}/submit-payload.html`);
+}
+
+function listen(port, attempts_left) {
+    const server = app.listen(port, () => {
+        if (port !== requested_port) {
+            console.log(`Port ${requested_port} is in use; using ${port} instead.`);
+        }
+        show_demo_urls(port);
+    });
+    server.on('error', (err) => {
+        if (err.code === 'EADDRINUSE' && !port_is_explicit && attempts_left > 0) {
+            listen(port + 1, attempts_left - 1);
+        } else {
+            console.error(`Could not start demo server on port ${port}: ${err.message}`);
+            process.exit(1);
+        }
+    });
+}
+
+listen(requested_port, max_port_attempts);
\ No newline at end of file
diff --git a/demo/bitmask-example.html b/demo/bitmask-example.html
index 76eb2a4a..e91229fa 100644
--- a/demo/bitmask-example.html
+++ b/demo/bitmask-example.html
@@ -71,7 +71,7 @@
                 // Initial ULabel configuration
                 let ulabel = new ULabel({
                     "container_id": "container",
-                    "image_data": "https://ulabel.s3.us-east-2.amazonaws.com/cs-demo-0.png",
+                    "image_data": "/cs-demo-0.png",
                     "username": "DemoUser",
                     "submit_buttons": on_submit,
                     "subtasks": subtasks
diff --git a/demo/box-roi.html b/demo/box-roi.html
index 15ca7527..d7084d8f 100644
--- a/demo/box-roi.html
+++ b/demo/box-roi.html
@@ -125,7 +125,7 @@
                 // Initial ULabel configuration
                 let ulabel = new ULabel({
                     "container_id": "container",
-                    "image_data": "https://ulabel.s3.us-east-2.amazonaws.com/cs-demo-0.png",
+                    "image_data": "/cs-demo-0.png",
                     "username": "DemoUser",
                     "submit_buttons": on_submit,
                     "subtasks": subtasks,
diff --git a/demo/class-focus.html b/demo/class-focus.html
index 694e0f1b..ff799a18 100644
--- a/demo/class-focus.html
+++ b/demo/class-focus.html
@@ -214,7 +214,7 @@
             const AllowedToolboxItem = ULabel.get_allowed_toolbox_item_enum();
             let ulabel = new ULabel({
                 "container_id": "container",
-                "image_data": "https://ulabel.s3.us-east-2.amazonaws.com/cs-demo-0.png",
+                "image_data": "/cs-demo-0.png",
                 "username": "DemoUser",
                 "submit_buttons": [
                     {
diff --git a/demo/cs-demo-0.png b/demo/cs-demo-0.png
new file mode 100644
index 00000000..8a832e57
Binary files /dev/null and b/demo/cs-demo-0.png differ
diff --git a/demo/live_demo.html b/demo/live_demo.html
index 5ab839a1..4aa090d2 100644
--- a/demo/live_demo.html
+++ b/demo/live_demo.html
@@ -776,7 +776,7 @@
                 // Initial ULabel configuration
                 let ulabel = new ULabel({
                     "container_id": "container",
-                    "image_data": "https://ulabel.s3.us-east-2.amazonaws.com/cs-demo-0.png",
+                    "image_data": "/cs-demo-0.png",
                     "username": "DemoUser",
                     "submit_buttons": on_submit,
                     "subtasks": subtasks
diff --git a/demo/multi-class.html b/demo/multi-class.html
index dc75865c..51bdb6d8 100644
--- a/demo/multi-class.html
+++ b/demo/multi-class.html
@@ -84,7 +84,7 @@
             // Initial ULabel configuration
             let ulabel = new ULabel({
                 "container_id": "container",
-                "image_data": "https://ulabel.s3.us-east-2.amazonaws.com/cs-demo-0.png",
+                "image_data": "/cs-demo-0.png",
                 "username": "DemoUser",
                 "submit_buttons": [
                     {
diff --git a/demo/offset-container.html b/demo/offset-container.html
index 3575f9e2..1eca881c 100644
--- a/demo/offset-container.html
+++ b/demo/offset-container.html
@@ -48,7 +48,7 @@
 
                 let ulabel = new ULabel({
                     "container_id": "container",
-                    "image_data": "https://ulabel.s3.us-east-2.amazonaws.com/cs-demo-0.png",
+                    "image_data": "/cs-demo-0.png",
                     "username": "DemoUser",
                     "submit_buttons": on_submit,
                     "subtasks": subtasks
diff --git a/demo/read-only.html b/demo/read-only.html
index cee297a0..e35da51a 100644
--- a/demo/read-only.html
+++ b/demo/read-only.html
@@ -114,13 +114,14 @@
                 const AllowedToolboxItem = ULabel.get_allowed_toolbox_item_enum();
                 let ulabel = new ULabel({
                     "container_id": "container",
-                    "image_data": "https://ulabel.s3.us-east-2.amazonaws.com/cs-demo-0.png",
+                    "image_data": "/cs-demo-0.png",
                     "username": "DemoUser",
                     "submit_buttons": on_submit,
                     "subtasks": subtasks,
                     "toolbox_order": [
                         AllowedToolboxItem.ModeSelect,
                         AllowedToolboxItem.ZoomPan,
+                        AllowedToolboxItem.Brush,
                         AllowedToolboxItem.AnnotationID,
                         AllowedToolboxItem.ClassCounter,
                         AllowedToolboxItem.AnnotationResize,
@@ -133,6 +134,11 @@
                 });
                 // Expose the instance for e2e tests
                 window.ulabel = ulabel;
+
+                $("#toggle-read-only").on("click", function() {
+                    const key = ulabel.get_current_subtask_key();
+                    ulabel.set_subtask_read_only(key, !ulabel.is_current_subtask_read_only());
+                });
             });
         </script>
         <style>
@@ -154,6 +160,7 @@ <h2>Read-Only Demo</h2>
                 All subtasks are <code>read_only: true</code>. Hover shows the confidence card and hover outline, but
                 move/reclassify/delete buttons, vertex handles, and the id color-wheel are suppressed. Creation drags,
                 brush/erase mode, delete keybinds, and class-reassign keybinds are all blocked.
+                <button id="toggle-read-only">Toggle read-only (current subtask)</button>
             </p>
         </div>
         <div id="wrapper">
diff --git a/demo/resume-from.html b/demo/resume-from.html
index ba506d29..d52288a5 100644
--- a/demo/resume-from.html
+++ b/demo/resume-from.html
@@ -278,7 +278,7 @@
                 const AllowedToolboxItem = ULabel.get_allowed_toolbox_item_enum();
                 let ulabel = new ULabel({
                     "container_id": "container",
-                    "image_data": "https://ulabel.s3.us-east-2.amazonaws.com/cs-demo-0.png",
+                    "image_data": "/cs-demo-0.png",
                     "username": "DemoUser",
                     "submit_buttons": on_submit,
                     "subtasks": subtasks,
diff --git a/demo/row-filtering-example.html b/demo/row-filtering-example.html
index 76da73fc..4c382885 100644
--- a/demo/row-filtering-example.html
+++ b/demo/row-filtering-example.html
@@ -736,7 +736,7 @@
             // Initial ULabel configuration
             let ulabel = new ULabel({
                 "container_id": "container",
-                "image_data": "https://ulabel.s3.us-east-2.amazonaws.com/cs-demo-0.png",
+                "image_data": "/cs-demo-0.png",
                 "username": "DemoUser",
                 "submit_buttons": on_submit,
                 "subtasks": subtasks,
diff --git a/demo/set-annotations.html b/demo/set-annotations.html
index 3fedefda..8357f3a2 100644
--- a/demo/set-annotations.html
+++ b/demo/set-annotations.html
@@ -136,7 +136,7 @@
 
             const ulabel = new ULabel({
                 container_id: "container",
-                image_data: "https://ulabel.s3.us-east-2.amazonaws.com/cs-demo-0.png",
+                image_data: "/cs-demo-0.png",
                 username: "DemoUser",
                 submit_buttons: [{ name: "Submit", hook: on_submit }],
                 subtasks: subtasks,
diff --git a/demo/single-class.html b/demo/single-class.html
index 0f78d296..7752feb1 100644
--- a/demo/single-class.html
+++ b/demo/single-class.html
@@ -49,7 +49,7 @@
                 // Initial ULabel configuration
                 let ulabel = new ULabel({
                     "container_id": "container",
-                    "image_data": "https://ulabel.s3.us-east-2.amazonaws.com/cs-demo-0.png",
+                    "image_data": "/cs-demo-0.png",
                     "username": "DemoUser",
                     "submit_buttons": on_submit,
                     "subtasks": subtasks
diff --git a/demo/submit-payload.html b/demo/submit-payload.html
new file mode 100644
index 00000000..ae670a1f
--- /dev/null
+++ b/demo/submit-payload.html
@@ -0,0 +1,111 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <title>ULabel - Submit Payload Demo</title>
+
+        <!-- ULabel Library -->
+        <script src="/ulabel.js"></script>
+
+        <!-- JQuery Library -->
+        <script src="https://code.jquery.com/jquery-3.5.1.min.js" integrity="sha256-9/aliU8dGd2tb6OSsuzixeV4y/faTqgFtohetphbbj0=" crossorigin="anonymous"></script>
+
+        <!-- ULabel Usage -->
+        <script>
+            /* global $ */
+            /* global ULabel */
+
+            $(window).on("load", function() {
+                // Each button stores the payload it received so tests (and humans in devtools)
+                // can inspect exactly what a host application would be handed.
+                window.submitted_payloads = {};
+                function record_payload(button_name) {
+                    return function(payload) {
+                        window.submitted_payloads[button_name] = payload;
+                    };
+                }
+
+                let gt_annotations = [
+                    {
+                        "id": "gt-bbox-1",
+                        "spatial_type": "bbox",
+                        "spatial_payload": [[100, 100], [300, 250]],
+                        "classification_payloads": [{ "class_id": 10, "confidence": 1.0 }],
+                        "last_edited_at": "2026-01-01T00:00:00.000Z",
+                        "last_edited_by": "host",
+                    },
+                    {
+                        "id": "gt-bbox-2",
+                        "spatial_type": "bbox",
+                        "spatial_payload": [[400, 150], [600, 320]],
+                        "classification_payloads": [{ "class_id": 11, "confidence": 1.0 }],
+                        "last_edited_at": "2026-01-01T00:00:00.000Z",
+                        "last_edited_by": "host",
+                    },
+                ];
+
+                let pred_annotations = [
+                    {
+                        "id": "pred-bbox-1",
+                        "spatial_type": "bbox",
+                        "spatial_payload": [[700, 400], [900, 600]],
+                        "classification_payloads": [{ "class_id": 10, "confidence": 0.7 }],
+                        "last_edited_at": "2026-01-01T00:00:00.000Z",
+                        "last_edited_by": "model",
+                    },
+                ];
+
+                const classes = [
+                    { "name": "Sedan", "color": "blue", "id": 10, "keybind": "1" },
+                    { "name": "SUV", "color": "green", "id": 11, "keybind": "2" },
+                    { "name": "Truck", "color": "orange", "id": 12, "keybind": "3" },
+                ];
+
+                let subtasks = {
+                    "ground_truth": {
+                        "display_name": "Ground Truth",
+                        "classes": classes,
+                        "allowed_modes": ["bbox", "polygon", "point", "delete_polygon"],
+                        "resume_from": gt_annotations,
+                        "task_meta": null,
+                        "annotation_meta": null,
+                    },
+                    "predictions": {
+                        "display_name": "Predictions",
+                        "classes": classes,
+                        "allowed_modes": ["bbox"],
+                        "resume_from": pred_annotations,
+                        "task_meta": null,
+                        "annotation_meta": null,
+                    },
+                };
+
+                let ulabel = new ULabel({
+                    "container_id": "container",
+                    "image_data": "/cs-demo-0.png",
+                    "username": "DemoUser",
+                    "submit_buttons": [
+                        // Legacy behavior: every subtask, every annotation.
+                        { "name": "Submit All", "hook": record_payload("all") },
+                        // Only the ground truth subtask.
+                        { "name": "Submit GT", "hook": record_payload("gt"), "subtasks": ["ground_truth"] },
+                        // Only annotations created, deleted, or modified since load, across all subtasks.
+                        { "name": "Submit Edits", "hook": record_payload("edits"), "edits_only": true },
+                    ],
+                    "subtasks": subtasks,
+                    "task_meta": { "job": 7 },
+                });
+                ulabel.init(function() {
+                    // ULabel is now ready for use
+                });
+                // Expose the instance for e2e tests
+                window.ulabel = ulabel;
+            });
+        </script>
+        <style>
+            body { margin: 0; padding: 0; }
+        </style>
+    </head>
+    <body>
+        <div id="container" style="width: 100%; height: 100vh; position: absolute; top: 0; left: 0;"></div>
+    </body>
+</html>
diff --git a/index.d.ts b/index.d.ts
index 0590a943..2b5aacac 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -188,6 +188,21 @@ export type ULabelSubmitButton = {
     set_saved?: boolean;
     size_factor?: number;
     row_number?: number;
+    /**
+     * Subtask keys to include in `submit_data.annotations`.
+     * Defaults to every subtask.
+     */
+    subtasks?: string[];
+    /**
+     * When true, each subtask's list holds only annotations that differ from
+     * what the host loaded (`resume_from` / `set_annotations`): created
+     * in-session and not deprecated, or loaded and since edited (including
+     * deletion). Detected via `last_edited_at`; undo restores the loaded
+     * stamp, and filter-driven deprecation is not an edit. Each included
+     * annotation carries `edit_type: "created" | "deleted" | "modified"`.
+     * Defaults to false.
+     */
+    edits_only?: boolean;
 };
 
 export type ULabelAnnotations = { [key: string]: ULabelAnnotation[] };
@@ -248,6 +263,9 @@ export type BrushOverlapMode = "none" | "exclude" | "overwrite";
 
 export type ULabelActionType = "create_nonspatial_annotation" |
     "create_annotation" |
+    "paste_annotation" |
+    "move_annotation" |
+    "delete_counterparts" |
     "begin_annotation" |
     "continue_annotation" |
     "finish_annotation" |
@@ -259,6 +277,7 @@ export type ULabelActionType = "create_nonspatial_annotation" |
     "finish_move" |
     "cancel_annotation" |
     "delete_annotation" |
+    "restore_annotation" |
     "delete_vertex" |
     "delete_annotations_in_polygon" |
     "start_complex_polygon" |
@@ -269,7 +288,46 @@ export type ULabelActionType = "create_nonspatial_annotation" |
     "continue_bitmask" |
     "bitmask_stroke" |
     "finish_modify_annotation" |
-    "assign_annotation_id";
+    "assign_annotation_id" |
+    "edit_text_payload";
+
+// An annotation, possibly in another subtask, that an action also edits
+export type ULabelActionAffected = {
+    annotation_id: string;
+    subtask_key: string;
+};
+
+// Payload of `on_annotation_change`: one recorded, undone, or redone action
+export type ULabelAnnotationChange = {
+    // Subtask whose action stream holds the action
+    subtask_key: string;
+    annotation_id: string | null;
+    act_type: ULabelActionType;
+    kind: "do" | "undo" | "redo";
+    // Other annotations the action edited (paste/move target copy, bitmask overlap)
+    affected: ULabelActionAffected[];
+    // `assign_annotation_id` only: what the annotation had immediately before this event
+    previous_classification_payloads: ULabelClassificationPayload[] | null;
+    // Undo/redo only: the read-only subtask it was issued from, when routed to this writable one
+    from_subtask_key: string | null;
+};
+
+// Clipboard payload written by copy/cut and read by paste (also as JSON on the system clipboard)
+export type ULabelClipboardEnvelope = {
+    ulabel_annotation: 1;
+    // Unique per copy/cut; tells a repeat paste of one copy from a newer copy of the same annotation
+    copy_id: string;
+    // Epoch ms of the copy; when the system and in-memory clipboards hold different copies, the newer one is pasted
+    copied_at?: number;
+    image_width: number;
+    image_height: number;
+    source_subtask_key: string;
+    // Name of the source class, so a target without the same class id can match by name
+    source_class_name?: string | null;
+    annotation: ULabelAnnotation;
+    // Pastes of this envelope so far, per target subtask; repeats are offset further
+    paste_counts?: Record<string, number>;
+};
 
 export type ULabelActionRaw = {
     act_type: ULabelActionType;
@@ -277,6 +335,12 @@ export type ULabelActionRaw = {
     frame: number;
     redo_payload: object;
     undo_payload: object;
+    affected?: ULabelActionAffected[];
+    // Override the recorded pre-action edit info (used when collapsing actions)
+    prev_timestamp?: string | null;
+    prev_user?: string;
+    // Stamp the touched annotations with this instead of now/username (restore)
+    stamp_override?: { at: string; by: string };
 };
 
 export type ULabelAction = {
@@ -287,6 +351,13 @@ export type ULabelAction = {
     undo_payload: string; // Stringified object
     prev_timestamp: string;
     prev_user: string;
+    affected?: ULabelActionAffected[];
+    // Parallel to `affected`: their edit info before the action
+    affected_prev?: { prev_timestamp: string; prev_user: string }[];
+    // The edit stamp this action wrote to the annotations it touched
+    stamped_at?: string;
+    // Subtask the user was in when the action was triggered (or last redone)
+    origin_subtask_key?: string;
     is_internal_undo?: boolean;
 };
 
@@ -302,6 +373,7 @@ export type ULabelActionCandidate = {
     spatial_type: ULabelSpatialType;
     offset?: Offset; // Optional offset for move actions
     is_vertex?: boolean; // True if hovering over an actual vertex, false if hovering over a segment
+    containing?: boolean; // True if the cursor is inside the annotation's real boundary, not just near its box
 };
 
 export type ULabelSubtasks = { [key: string]: ULabelSubtask };
@@ -323,12 +395,34 @@ export type ULabelConstructorArgs = {
     class_counter_toolbox_item?: ClassCounterConfig;
     /** Let bitmask brush overlap resolution reach masks in other subtasks. Default false. */
     brush_overlap_across_subtasks?: boolean;
+    /** Left-drag inside a spatial annotation's body moves it; Alt+drag draws instead. Default true. */
+    allow_body_move?: boolean;
+    /** Open the class pie on a paste whose source class has no id/name match in the target. Default true; false takes the target's active class. */
+    paste_class_choice?: boolean;
+    /** Make the target the current subtask after a copy/move or `delete_counterparts`, and the writable subtask on undo/redo from a read-only one. Default false. */
+    paste_switch_to_target?: boolean;
+    /** `annotation_meta` key whose value (string or string[]) links annotations across subtasks; any shared value links. Copies drop it. Default null. */
+    annotation_link_meta_key?: string | null;
+    /** Context menu hides Copy to / Move to for subtasks that already hold a counterpart (instead of confirming). Default false. */
+    hide_copy_to_linked?: boolean;
     /** Fired after a subtask's active class changes, from any writer (API, toolbox click, class keybind). */
     on_active_class_change?: (subtask_key: string, class_id: number) => void;
     /** Fired after the current subtask changes, from any writer (API, tab click, switch keybind). */
     on_subtask_change?: (subtask_key: string, old_subtask_key: string) => void;
     /** Fired after a subtask's `focus_active_class` flag changes, from any writer (API, focus keybind). */
     on_focus_active_class_change?: (subtask_key: string, enabled: boolean) => void;
+    /** Fired after a subtask's `focus_edited` flag changes, from any writer (API, edit focus keybind, annotation list checkbox). */
+    on_focus_edited_change?: (subtask_key: string, enabled: boolean) => void;
+    /** Fired after a subtask's `focus_deprecated` flag changes, from any writer (API, toggle keybind, annotation list checkbox). */
+    on_focus_deprecated_change?: (subtask_key: string, enabled: boolean) => void;
+    /** Fired after a subtask's isolated annotation changes (`null` when cleared), from any writer (API, list button, Escape). */
+    on_isolate_change?: (subtask_key: string, annotation_id: string | null) => void;
+    /** Fired when an undo/redo from a read-only subtask does nothing because the writable subtask's top action was triggered elsewhere. */
+    on_undo_redo_blocked?: (kind: "undo" | "redo", subtask_key: string, from_subtask_key: string, origin_subtask_key: string | null) => void;
+    /** Fired once per recorded, undone, or redone action that changes committed annotation state. Not fired by `set_annotations`/`set_annotations_batch`/`resume_from`. */
+    on_annotation_change?: (change: ULabelAnnotationChange) => void;
+    /** Also report `continue_*` (in-progress draw/edit/move/brush) actions to `on_annotation_change`. Default false. */
+    on_annotation_change_in_progress?: boolean;
     /** @deprecated Use top-level properties instead. */
     config_data?: object;
 };
@@ -345,6 +439,7 @@ export class ULabel {
         current_frame: number;
         // Global annotation state
         current_subtask: string;
+        undo_redo_from_subtask: string | null;
         last_brush_stroke: [number, number];
         line_size: number;
         anno_scaling_mode: AnnoScalingMode;
@@ -358,6 +453,10 @@ export class ULabel {
         demo_canvas_context: CanvasRenderingContext2D;
         edited: boolean;
         all_subtasks_vanished: boolean;
+        /** Annotation the right-click context menu is open for, if any. */
+        context_menu_annid: string | null;
+        /** Last copied/cut annotation envelope, see `copy_annotation_to_clipboard`. */
+        clipboard: ULabelClipboardEnvelope | null;
     };
 
     config: Configuration;
@@ -430,6 +529,10 @@ export class ULabel {
     public get_current_subtask_key(): string;
     public get_current_subtask(): ULabelSubtask;
     public is_current_subtask_read_only(): boolean;
+    /** Whether user input may not edit a subtask: read-only or under deprecated focus. Public API methods are unaffected. */
+    public is_subtask_edit_locked(subtask_key?: string | null): boolean;
+    public update_edit_lock_display(): void;
+    public discard_in_progress_input(): void;
     /** Whether a subtask's annotations are hidden: vanished, or layer opacity 0. Hidden implies non-interactive. */
     public is_subtask_hidden(subtask_key?: string): boolean;
     public readjust_subtask_opacities(): void;
@@ -451,18 +554,54 @@ export class ULabel {
     public is_annotation_defocused(annotation: ULabelAnnotation, subtask_key: string): boolean;
     /** Turn focus-follows-active-class on or off for a subtask at runtime. */
     public set_focus_active_class(subtask_key: string, enabled: boolean, redraw?: boolean): void;
+    /**
+     * Turn edit focus on or off for a subtask at runtime: annotations unchanged
+     * since load dim to `defocused_opacity` and drop out of input like class focus.
+     */
+    public set_focus_edited(subtask_key: string, enabled: boolean, redraw?: boolean): void;
+    /**
+     * Turn deprecated focus on or off for a subtask at runtime: deprecated
+     * annotations are drawn and in focus (view-only; restorable from the
+     * context menu), live ones dim and drop out of input like class focus.
+     */
+    public set_focus_deprecated(subtask_key: string, enabled: boolean, redraw?: boolean): void;
     /**
      * Opacity for annotations outside the focused class. 0 skips drawing them
      * entirely, which is cheaper but loses them as visual context.
      */
     public set_defocused_opacity(subtask_key: string, opacity: number, redraw?: boolean): void;
+    /**
+     * Isolate one annotation in a subtask: every other annotation is hidden
+     * from the canvas and from input until cleared with `null`. View-only
+     * state (not recorded, does not mark edited). Returns whether the request
+     * was accepted (unknown ids, and deprecated ids outside deprecated focus, are rejected).
+     */
+    public isolate_annotation(annotation_id: string | null, subtask_key?: string | null, redraw?: boolean): boolean;
+    /** The isolated annotation id in a subtask, if any. */
+    public get_isolated_annotation_id(subtask_key?: string | null): string | null;
     /**
      * Set a subtask's layer opacity. Also writes `inactive_opacity` so the value
      * survives a subtask switch.
      */
     public set_subtask_opacity(subtask_key: string, opacity: number): void;
+    /**
+     * Make a subtask read-only or editable at runtime. Making the current
+     * subtask read-only completes an active drag and discards other
+     * in-progress work as Escape would. Not recorded, does not mark edited.
+     */
+    public set_subtask_read_only(subtask_key: string, read_only: boolean): void;
     /** The spatial types a class may be drawn as; falls back to the subtask's list. */
     public get_class_allowed_modes(class_id: number, subtask_key?: string | null): ULabelSpatialType[];
+    /** Class ids in the current subtask that can take an annotation's spatial type. */
+    public _get_compatible_class_ids(annotation?: ULabelAnnotation | null, subtask_key?: string | null): number[];
+    /**
+     * Open the right-click context menu (Change class / Delete / Details) for an
+     * annotation in the current subtask at a viewport position. Returns whether
+     * the menu was shown.
+     */
+    public show_context_menu(annotation_id: string, client_x: number, client_y: number): boolean;
+    public hide_context_menu(): void;
+    public is_context_menu_open(): boolean;
     /**
      * Hide the mode buttons the active class disallows and switch off a mode it
      * disallows. Delete modes are exempt.
@@ -485,6 +624,8 @@ export class ULabel {
     /** Deferred half of a batched `set_annotations` sequence: filter distances + toolbox redraw. */
     public refresh_toolbox(): void;
     public set_saved(saved: boolean): void;
+    /** Whether an `edits_only` submit limited to `subtasks` (default all) would send anything. */
+    public has_edits(subtasks?: string[] | null): boolean;
     public draw_annotation_from_id(id: string, offset?: Offset, subtask?: string): void;
     public redraw_annotation(annotation_id: string, subtask?: string, offset?: Offset): void;
     public render_bitmask_move(annotation_id: string, subtask: string, offset: Offset): void;
@@ -524,6 +665,7 @@ export class ULabel {
     public fly_to_next_annotation(increment: number, max_zoom?: number): boolean;
     public fly_to_annotation_id(annotation_id: string, subtask_key?: string | null, max_zoom?: number): boolean;
     public fly_to_annotation(annotation: ULabelAnnotation, subtask_key?: string, max_zoom?: number): boolean;
+    public fly_to_boxes_if_offscreen(boxes: ULabelContainingBox[]): boolean;
 
     // Brush
     // TODO (joshua-dean): should these actually be optional?
@@ -577,7 +719,16 @@ export class ULabel {
         annotation_id: string,
         redoing?: boolean,
         should_record_action?: boolean,
+        prev_stamp?: { prev_timestamp: string | null; prev_user: string } | null,
     ): void;
+    /** Whether Restore applies: deleted by a human only, editable subtask, restorable geometry. */
+    public can_restore_annotation(annotation_id: string): boolean;
+    /**
+     * Undelete a human-deleted annotation in the current subtask. Its edit stamp
+     * reverts to before the deletion when the action stream still knows it,
+     * else it is stamped now. Returns whether it was restored.
+     */
+    public restore_annotation(annotation_id: string, redoing?: boolean): boolean;
     public delete_vertex(
         annotation_id: string,
         access_str: string | number | [number, number],
@@ -596,6 +747,70 @@ export class ULabel {
     public create_nonspatial_annotation(
         annotation_id?: string, redo_payload?: object,
     ): void;
+    /** Whether `annotation` (spatial) may be pasted into a writable subtask with a compatible class. */
+    public can_paste_into_subtask(annotation: ULabelAnnotation | object, subtask_key: string): boolean;
+    /** Keys of the other subtasks `annotation` can be copied into. */
+    public get_copy_target_subtask_keys(annotation: ULabelAnnotation | object, source_key?: string | null): string[];
+    /** Compatible target class matching the source class by id, else by `source_class_name`; null when none. */
+    public match_paste_class_id(annotation: ULabelAnnotation | object, target_key: string, source_class_name?: string | null): number | null;
+    /** Matched source class (id, then name), else the target's active class, else the first compatible class. */
+    public resolve_paste_class_id(annotation: ULabelAnnotation | object, target_key: string, source_class_name?: string | null): number | null;
+    /** Name of a class in a subtask, or null. */
+    public get_class_name(class_id: number, subtask_key: string): string | null;
+    /**
+     * Insert a copy of `annotation` into `target_key` with a fresh id and stamps.
+     * Records a `paste_annotation` action on the target subtask unless `record` is false. Returns the new id, or null.
+     * With `source_key`, the copy's `annotation_meta.copied_from` is `{ subtask_key, annotation_id }`.
+     * The `annotation_link_meta_key` entry is dropped from the copy's `annotation_meta`.
+     */
+    public paste_annotation(
+        annotation: ULabelAnnotation | object,
+        target_key: string,
+        class_id?: number | null,
+        offset?: [number, number],
+        record?: boolean,
+        source_key?: string | null,
+    ): string | null;
+    /**
+     * Copy (or cut) an annotation from `source_key` into `target_key` at the same coordinates.
+     * A cut from the current, writable subtask is one `move_annotation` action on the source's stream.
+     * With `choose_class`, several compatible classes and `config.paste_class_choice`, switches to the target and opens the class pie.
+     * With `config.paste_switch_to_target`, always switches to the target.
+     */
+    public copy_annotation_to_subtask(
+        annotation_id: string,
+        source_key: string,
+        target_key: string,
+        class_id?: number | null,
+        cut?: boolean,
+        choose_class?: boolean,
+        offset?: [number, number],
+    ): string | null;
+    /** Copy an annotation into another subtask. Returns the new id, or null when nothing was copied. */
+    public copy_annotation(
+        annotation_id: string,
+        target_subtask_key: string,
+        class_id?: number | null,
+        source_subtask_key?: string | null,
+    ): string | null;
+    /** Copy (or cut) the hovered annotation to the in-memory clipboard; returns the envelope or null. */
+    public copy_annotation_to_clipboard(annotation_id?: string | null, cut?: boolean): ULabelClipboardEnvelope | null;
+    /** Paste an envelope (default: the in-memory clipboard) into the current subtask; returns the new id or null. */
+    public paste_annotation_from_clipboard(envelope?: ULabelClipboardEnvelope | null): string | null;
+    /** Id of an annotation in `target_key` pasted from `annotation_id` in `source_key` and not human-deleted, or null. */
+    public find_pasted_copy(annotation_id: string, source_key: string, target_key: string): string | null;
+    /** Live spatial annotations in `target_key` linked to the source by `copied_from` (either way) or a shared `annotation_link_meta_key` value. */
+    public find_counterparts(annotation_id: string, source_key: string, target_key: string): string[];
+    /**
+     * Delete the counterparts from a writable `target_key`, or with `erase` (default: source is a bitmask)
+     * subtract a bitmask source from its bitmask counterparts.
+     * One `delete_counterparts` action on the target's stream. Returns the changed ids.
+     * With `config.paste_switch_to_target`, switches to the target when anything changed.
+     */
+    public delete_counterparts(annotation_id: string, source_key: string, target_key: string, erase?: boolean | null): string[];
+    /** Whether a context-menu copy/move/delete-from makes the target the current subtask. */
+    public set_paste_switch_to_target(enabled: boolean): void;
+    public get_paste_switch_to_target(): boolean;
     public start_complex_polygon(annotation_id?: string): void;
     public merge_polygon_complex_layer(
         annotation_id: string,
@@ -614,17 +829,25 @@ export class ULabel {
     public get_active_class_id_idx(): number;
 
     // Undo
+    /** From a read-only subtask, undoes on the sole writable subtask (if exactly one). */
     public undo(): void;
+    public run_on_edit_subtask(stack: "stream" | "undone_stack", fn: () => void): void;
     public begin_annotation__undo(annotation_id: string): void;
     public continue_annotation__undo(annotation_id: string): void;
     public finish_annotation__undo(annotation_id: string): void;
     public begin_edit__undo(annotation_id: string, undo_payload: object): void;
     public begin_move__undo(annotation_id: string, undo_payload: object): void;
     public delete_annotation__undo(annotation_id: string): void;
+    public restore_annotation__undo(annotation_id: string): void;
     public delete_vertex__undo(annotation_id: string, undo_payload: object): void;
     public cancel_annotation__undo(annotation_id: string, undo_payload: object): void;
     public assign_annotation_id__undo(annotation_id: string, undo_payload: object): void;
+    public edit_text_payload(annotation_id: string, new_text: string, redoing?: boolean): void;
+    public edit_text_payload__undo(annotation_id: string, undo_payload: object): void;
     public create_annotation__undo(annotation_id: string): void;
+    public paste_annotation__undo(annotation_id: string): void;
+    public move_annotation__undo(annotation_id: string, undo_payload: object): void;
+    public delete_counterparts__undo(undo_payload: object): void;
     public create_nonspatial_annotation__undo(annotation_id: string): void;
     public start_complex_polygon__undo(annotation_id: string): void;
     public merge_polygon_complex_layer__undo(annotation_id: string, undo_payload: object): void;
@@ -635,14 +858,20 @@ export class ULabel {
     public finish_modify_annotation__undo(annotation_id: string, undo_payload: object): void;
 
     // Redo
+    /** From a read-only subtask, redoes on the sole writable subtask (if exactly one). */
     public redo(): void;
     public finish_annotation__redo(annotation_id: string): void;
     public bitmask_stroke__redo(annotation_id: string, redo_payload: object): void;
+    public edit_text_payload__redo(annotation_id: string, redo_payload: object): void;
     public begin_edit__redo(annotation_id: string, redo_payload: object): void;
     public begin_move__redo(annotation_id: string, redo_payload: object): void;
     public delete_annotation__redo(annotation_id: string): void;
+    public restore_annotation__redo(annotation_id: string): void;
     public delete_vertex__redo(annotation_id: string, redo_payload: object): void;
     public create_annotation__redo(annotation_id: string, redo_payload: object): void;
+    public paste_annotation__redo(annotation_id: string, redo_payload: object): void;
+    public move_annotation__redo(annotation_id: string, redo_payload: object): void;
+    public delete_counterparts__redo(annotation_id: string, redo_payload: object): void;
     public finish_modify_annotation__redo(annotation_id: string, redo_payload: object): void;
 
     // Mouse event handlers
@@ -668,7 +897,6 @@ export class ULabel {
     public suggest_edits(
         mouse_event?: JQuery.TriggeredEvent | null,
         nonspatial_id?: string | null,
-        force_refresh?: boolean,
     ): void;
     public show_global_edit_suggestion(
         annid: string,
@@ -724,7 +952,6 @@ export class ULabel {
         gbx: number,
         gby: number,
         active_ann: string, // annotation id
-        thumbnail?: boolean,
         nonspatial?: boolean,
     ): void;
     public hide_id_dialog(): void;
diff --git a/package-lock.json b/package-lock.json
index 17e7f478..06317313 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "ulabel",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "ulabel",
-      "version": "0.28.0",
+      "version": "0.29.0",
       "license": "MIT",
       "devDependencies": {
         "@eslint/config-inspector": "^1.3.0",
diff --git a/package.json b/package.json
index bda50be3..f231cca2 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "ulabel",
   "description": "An image annotation tool.",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "main": "dist/ulabel.min.js",
   "module": "dist/ulabel.min.js",
   "types": "dist/index.d.ts",
diff --git a/playwright.config.js b/playwright.config.js
index 72dcce77..31494528 100644
--- a/playwright.config.js
+++ b/playwright.config.js
@@ -1,5 +1,9 @@
 import { defineConfig, devices } from "@playwright/test";
 
+// Override with PORT=... when 8080 is taken by something else; demo.js reads the same variable.
+const port = Number(process.env.PORT) || 8080;
+const base_url = `http://localhost:${port}`;
+
 export default defineConfig({
     testDir: "./tests/e2e",
     fullyParallel: false, // Run tests sequentially for more stable results
@@ -8,7 +12,7 @@ export default defineConfig({
     workers: 3,
     reporter: "list",
     use: {
-        baseURL: "http://localhost:8080",
+        baseURL: base_url,
         trace: "on-first-retry",
         screenshot: "only-on-failure",
         video: "retain-on-failure",
@@ -66,7 +70,7 @@ export default defineConfig({
 
     webServer: {
         command: "npm run demo",
-        url: "http://localhost:8080/multi-class.html",
+        url: `${base_url}/multi-class.html`,
         reuseExistingServer: !process.env.CI,
     },
 });
diff --git a/src/actions.ts b/src/actions.ts
index 9583f1d2..27e17ca1 100644
--- a/src/actions.ts
+++ b/src/actions.ts
@@ -3,6 +3,9 @@ import type {
     ULabelAction,
     ULabelActionRaw,
     ULabelActionType,
+    ULabelAnnotation,
+    ULabelAnnotationChange,
+    ULabelContainingBox,
 } from "../index";
 import { ULabel } from "../src/index";
 import { FilterPointDistanceFromRow } from "./toolbox";
@@ -22,10 +25,17 @@ import { log_message, LogLevel } from "./error_logging";
  * @param raw_action action to record
  * @param is_redo whether ulabel action is a redo or not
  * @param add_to_action_stream whether to add the action to the action stream
+ * @param subtask_key subtask whose stream receives the action; defaults to the current subtask
  */
-export function record_action(ulabel: ULabel, raw_action: ULabelActionRaw, is_redo: boolean = false, add_to_action_stream: boolean = true) {
+export function record_action(
+    ulabel: ULabel,
+    raw_action: ULabelActionRaw,
+    is_redo: boolean = false,
+    add_to_action_stream: boolean = true,
+    subtask_key: string | null = null,
+) {
     ulabel.set_saved(false);
-    const current_subtask = ulabel.get_current_subtask();
+    const current_subtask = ulabel.subtasks[subtask_key ?? ulabel.get_current_subtask_key()];
     const annotation = current_subtask.annotations.access[raw_action.annotation_id!];
 
     // After a new action, you can no longer redo old actions
@@ -35,32 +45,144 @@ export function record_action(ulabel: ULabel, raw_action: ULabelActionRaw, is_re
 
     // Stringify the undo/redo payloads
     const act_type = raw_action.act_type;
+    // A collapsed action inherits the stamp of the action it replaces; null is a valid loaded baseline
+    let prev_timestamp: string | null = annotation?.last_edited_at || null;
+    if (raw_action.prev_timestamp !== undefined) {
+        prev_timestamp = raw_action.prev_timestamp;
+    }
+    let prev_user: string = annotation?.last_edited_by || "unknown";
+    if (raw_action.prev_user !== undefined) {
+        prev_user = raw_action.prev_user;
+    }
     const action: ULabelAction = {
         act_type: act_type,
         annotation_id: raw_action.annotation_id,
         frame: raw_action.frame,
         undo_payload: JSON.stringify(raw_action.undo_payload),
         redo_payload: JSON.stringify(raw_action.redo_payload),
-        prev_timestamp: annotation?.last_edited_at || null,
-        prev_user: annotation?.last_edited_by || "unknown",
+        prev_timestamp: prev_timestamp,
+        prev_user: prev_user,
+        origin_subtask_key: ulabel.state.undo_redo_from_subtask ?? ulabel.get_current_subtask_key(),
     } as ULabelAction;
 
+    const affected = raw_action.affected ?? [];
+    const affected_annotations = affected.map(
+        ({ annotation_id, subtask_key }) => ulabel.subtasks[subtask_key]?.annotations.access[annotation_id],
+    );
+    if (affected.length > 0) {
+        action.affected = affected;
+        action.affected_prev = affected_annotations.map((ann) => ({
+            prev_timestamp: ann?.last_edited_at || null,
+            prev_user: ann?.last_edited_by || "unknown",
+        })) as ULabelAction["affected_prev"];
+    }
+
     // Add to stream
     if (add_to_action_stream) {
         current_subtask.actions.stream.push(action);
 
         // For some redo actions the annotation may no longer exist
-        if (annotation !== undefined) {
-            // Update annotation edit info
-            annotation.last_edited_at = ULabel.get_time();
-            annotation.last_edited_by = ulabel.config.username;
+        const now = raw_action.stamp_override !== undefined ? raw_action.stamp_override.at : ULabel.get_time();
+        const username = raw_action.stamp_override !== undefined ? raw_action.stamp_override.by : ulabel.config.username;
+        action.stamped_at = now;
+        const main_key = subtask_key ?? ulabel.get_current_subtask_key();
+        const stamped = [
+            { ann: annotation, key: main_key },
+            ...affected_annotations.map((ann, i) => ({ ann, key: affected[i].subtask_key })),
+        ].filter((entry): entry is { ann: ULabelAnnotation; key: string } => entry.ann !== undefined);
+        // Stamping can move an annotation into edit focus; only a redraw shows it
+        const defocused_before = stamped.map(({ ann, key }) => ulabel.is_annotation_defocused(ann, key));
+        for (const { ann } of stamped) {
+            ann.last_edited_at = now;
+            ann.last_edited_by = username;
         }
+        stamped.forEach(({ ann, key }, i) => {
+            if (ulabel.is_annotation_defocused(ann, key) !== defocused_before[i]) {
+                ulabel.redraw_annotation(ann.id!, key);
+            }
+        });
     }
 
     // Trigger any listeners for the action
     trigger_action_listeners(ulabel, action, false, is_redo);
+    // Off-stream recordings are sub-steps of a compound action (the delete inside a
+    // move), which reports itself; finish_* are the exception since begin_* is silent.
+    // A redone begin_annotation re-runs finish_annotation itself and is already reported.
+    const is_substep = !add_to_action_stream &&
+        !(FINISH_OFF_STREAM.includes(action.act_type) && !is_redo) &&
+        !IN_PROGRESS.includes(action.act_type);
+    if (!is_substep) {
+        emit_annotation_change(ulabel, action, is_redo ? "redo" : "do", subtask_key ?? ulabel.get_current_subtask_key());
+    }
 };
 
+// Actions that touch nothing committed until a later action; reported only on undo/redo.
+// Polygon simplify/merge only ever run inside finish_annotation, which collapses
+// them off the stream and reports the final geometry itself.
+const UNCOMMITTED_ON_DO: ULabelActionType[] = [
+    "begin_annotation",
+    "begin_edit",
+    "begin_move",
+    "begin_brush",
+    "start_complex_polygon",
+    "create_nonspatial_annotation",
+    "simplify_polygon_complex_layer",
+    "merge_polygon_complex_layer",
+];
+const IN_PROGRESS: ULabelActionType[] = [
+    "continue_annotation",
+    "continue_edit",
+    "continue_move",
+    "continue_brush",
+    "continue_bitmask",
+];
+// bbox/point/etc. finish off-stream (the begin_annotation is what gets collapsed)
+const FINISH_OFF_STREAM: ULabelActionType[] = ["finish_annotation", "finish_edit", "finish_move"];
+
+/**
+ * Notify the host's `on_annotation_change` callback of a recorded, undone, or redone action.
+ *
+ * @param ulabel ULabel instance
+ * @param action the action
+ * @param kind whether the action was done, undone, or redone
+ * @param subtask_key subtask whose stream holds the action
+ */
+function emit_annotation_change(
+    ulabel: ULabel,
+    action: ULabelAction,
+    kind: ULabelAnnotationChange["kind"],
+    subtask_key: string,
+) {
+    const callback = ulabel.config.on_annotation_change;
+    if (callback === null) return;
+    const act_type = action.act_type;
+    if (act_type === "edit_text_payload") return;
+    if (IN_PROGRESS.includes(act_type) && !ulabel.config.on_annotation_change_in_progress) return;
+    if (kind === "do" && UNCOMMITTED_ON_DO.includes(act_type)) return;
+
+    let previous_classification_payloads = null;
+    if (act_type === "assign_annotation_id") {
+        // Undo removes the new payload; do/redo remove the old one
+        previous_classification_payloads = kind === "undo" ?
+            JSON.parse(action.redo_payload).new_id_payload :
+            JSON.parse(action.undo_payload).old_id_payload;
+    }
+    const change: ULabelAnnotationChange = {
+        subtask_key,
+        annotation_id: action.annotation_id,
+        act_type,
+        kind,
+        affected: action.affected ?? [],
+        previous_classification_payloads,
+        from_subtask_key: kind === "do" ? null : ulabel.state.undo_redo_from_subtask,
+    };
+    try {
+        callback(change);
+    } catch (err) {
+        log_message(`on_annotation_change callback threw: ${err}`, LogLevel.WARNING, true);
+    }
+}
+
 /**
  * Finish an action in the action stream.
  *
@@ -255,6 +377,10 @@ function trigger_action_listeners(
             action: on_annotation_deletion,
             undo: on_finish_annotation_spatial_modification,
         },
+        restore_annotation: {
+            action: on_finish_annotation_spatial_modification,
+            undo: on_annotation_deletion,
+        },
         delete_vertex: {
             action: on_finish_annotation_spatial_modification,
             undo: on_finish_annotation_spatial_modification,
@@ -263,6 +389,10 @@ function trigger_action_listeners(
             action: on_annotation_id_change,
             undo: on_annotation_id_change,
         },
+        edit_text_payload: {
+            action: on_text_payload_change,
+            undo: on_text_payload_change,
+        },
         begin_edit: {
             undo: on_finish_annotation_spatial_modification,
             redo: on_finish_annotation_spatial_modification,
@@ -291,6 +421,19 @@ function trigger_action_listeners(
             // No listener for this action.
             // It handles the re-rendering of the affected annotations itself.
         },
+        paste_annotation: {
+            // The paste redraws itself (its target may not be the current subtask);
+            // undo always runs on the current subtask
+            undo: on_annotation_deletion,
+        },
+        move_annotation: {
+            // Deleting the source triggers the deletion listener itself; the copy is
+            // drawn/removed directly in its own subtask
+            undo: on_finish_annotation_spatial_modification,
+        },
+        delete_counterparts: {
+            // Redraws its target subtask itself
+        },
     };
 
     // Call the appropriate listener
@@ -380,7 +523,7 @@ function on_finish_annotation_spatial_modification(
     ulabel.rebuild_containing_box(action.annotation_id!);
     ulabel.redraw_annotation(action.annotation_id!);
     // Update dialogs
-    ulabel.suggest_edits(null, null, true);
+    ulabel.suggest_edits(null);
     // Update the toolbox
     ulabel.update_filter_distance(action.annotation_id!);
     ulabel.toolbox.redraw_update_items(ulabel);
@@ -422,11 +565,19 @@ function on_annotation_deletion(
     // Ensure there are no lingering enders
     ulabel.destroy_polygon_ender(action.annotation_id!);
     // Update dialogs
-    ulabel.suggest_edits(null, null, true);
+    ulabel.suggest_edits(null);
     // Update the toolbox
     ulabel.toolbox.redraw_update_items(ulabel);
 }
 
+/**
+ * Triggered when a non-spatial annotation's text payload is changed.
+ * Redrawing refreshes the note textarea.
+ */
+function on_text_payload_change(ulabel: ULabel, action: ULabelAction) {
+    ulabel.redraw_annotation(action.annotation_id!);
+}
+
 /**
  * Triggered when an annotation ID is changed.
  *
@@ -449,7 +600,7 @@ function on_annotation_id_change(
         // Hide the large ID dialog after the user has made a selection
         ulabel.hide_id_dialog();
     }
-    ulabel.suggest_edits(null, null, true);
+    ulabel.suggest_edits(null);
 
     // Determine if we need to update the filter distance
     // If the filter_distance_toolbox_item exists,
@@ -491,6 +642,17 @@ function on_annotation_revert(
 
 // ================= Undo / Redo =================
 
+/**
+ * Whether user undo/redo of an action would mutate a read-only subtask.
+ *
+ * @param ulabel ULabel instance
+ * @param action action at the top of the stack
+ */
+function is_blocked_by_read_only(ulabel: ULabel, action: ULabelAction): boolean {
+    if (ulabel.is_current_subtask_read_only()) return true;
+    return (action.affected ?? []).some(({ subtask_key }) => ulabel.subtasks[subtask_key]?.read_only === true);
+}
+
 /**
  * Undo the last action in the action stream.
  *
@@ -505,10 +667,9 @@ export function undo(ulabel: ULabel, is_internal_undo: boolean = false) {
 
     // If the action_steam is empty, then there are no actions to undo
     if (action_stream.length === 0) return;
+    if (!is_internal_undo && is_blocked_by_read_only(ulabel, action_stream[action_stream.length - 1])) return;
 
-    if (!current_subtask.state.idd_thumbnail) {
-        ulabel.hide_id_dialog();
-    }
+    ulabel.hide_id_dialog();
 
     let undo_candidate = action_stream.pop()!;
 
@@ -518,16 +679,23 @@ export function undo(ulabel: ULabel, is_internal_undo: boolean = false) {
         // TODO: better way of doing this?
         action_stream.push(undo_candidate);
         finish_action(ulabel, undo_candidate);
+        // A zero-diff move drops its own begin_move on finish; there is
+        // nothing left to undo
+        if (action_stream[action_stream.length - 1] !== undo_candidate) return;
         undo_candidate = action_stream.pop()!;
     }
 
     // Set internal undo status
     undo_candidate.is_internal_undo = is_internal_undo;
     undone_stack.push(undo_candidate);
+    const boxes_before = is_internal_undo ? [] : get_action_boxes(ulabel, undo_candidate);
     undo_action(ulabel, undo_candidate);
 
     // Trigger any listeners for the action
     trigger_action_listeners(ulabel, undo_candidate, true);
+    emit_annotation_change(ulabel, undo_candidate, "undo", ulabel.get_current_subtask_key());
+    // After the listeners, which rebuild containing boxes (e.g. for a move)
+    if (!is_internal_undo) fly_to_action_change(ulabel, undo_candidate, boxes_before);
 }
 
 /**
@@ -542,10 +710,50 @@ export function redo(ulabel: ULabel) {
 
     // If the action_steam is empty, then there are no actions to redo
     if (undone_stack.length === 0) return;
+    if (is_blocked_by_read_only(ulabel, undone_stack[undone_stack.length - 1])) return;
 
     // Redo the action
     const redo_candidate = undone_stack.pop()!;
+    const boxes_before = get_action_boxes(ulabel, redo_candidate);
     redo_action(ulabel, redo_candidate);
+    fly_to_action_change(ulabel, redo_candidate, boxes_before);
+}
+
+/**
+ * Containing boxes of the annotations an action touches, in image coordinates.
+ *
+ * @param ulabel ULabel instance
+ * @param action the action
+ */
+function get_action_boxes(ulabel: ULabel, action: ULabelAction): ULabelContainingBox[] {
+    // A counterpart action's own id is its source annotation, in another subtask
+    const own = action.act_type === "delete_counterparts" ?
+            [] :
+            [{ annotation_id: action.annotation_id, subtask_key: ulabel.get_current_subtask_key() }];
+    const targets = [...own, ...(action.affected ?? [])];
+    const boxes: ULabelContainingBox[] = [];
+    for (const { annotation_id, subtask_key } of targets) {
+        if (annotation_id === null) continue;
+        const annotation = ulabel.subtasks[subtask_key]?.annotations.access[annotation_id];
+        if (annotation === undefined || NONSPATIAL_MODES.includes(annotation.spatial_type!)) continue;
+        const box = annotation.containing_box;
+        if (box != null && [box.tlx, box.tly, box.brx, box.bry].every(Number.isFinite)) boxes.push({ ...box });
+    }
+    return boxes;
+}
+
+/**
+ * After a user undo/redo, fly to where its annotations ended up (or were, if
+ * none remain) when none of them is in view.
+ *
+ * @param ulabel ULabel instance
+ * @param action the undone/redone action
+ * @param boxes_before boxes of its annotations before the undo/redo
+ */
+function fly_to_action_change(ulabel: ULabel, action: ULabelAction, boxes_before: ULabelContainingBox[]) {
+    if (!ulabel.config.fly_to_on_undo || IN_PROGRESS.includes(action.act_type)) return;
+    const boxes_after = get_action_boxes(ulabel, action);
+    ulabel.fly_to_boxes_if_offscreen(boxes_after.length > 0 ? boxes_after : boxes_before);
 }
 
 /**
@@ -568,6 +776,12 @@ function undo_action(ulabel: ULabel, action: ULabelAction) {
         annotation.last_edited_at = action.prev_timestamp;
         annotation.last_edited_by = action.prev_user;
     }
+    (action.affected ?? []).forEach(({ annotation_id: aid, subtask_key }, i) => {
+        const affected = ulabel.subtasks[subtask_key]?.annotations.access[aid];
+        if (affected === undefined) return;
+        affected.last_edited_at = action.affected_prev![i].prev_timestamp;
+        affected.last_edited_by = action.affected_prev![i].prev_user;
+    });
 
     switch (action.act_type) {
         case "begin_annotation":
@@ -588,6 +802,9 @@ function undo_action(ulabel: ULabel, action: ULabelAction) {
         case "delete_annotation":
             ulabel.delete_annotation__undo(annotation_id);
             break;
+        case "restore_annotation":
+            ulabel.restore_annotation__undo(annotation_id);
+            break;
         case "delete_vertex":
             ulabel.delete_vertex__undo(annotation_id, undo_payload);
             break;
@@ -597,9 +814,21 @@ function undo_action(ulabel: ULabel, action: ULabelAction) {
         case "assign_annotation_id":
             ulabel.assign_annotation_id__undo(annotation_id, undo_payload);
             break;
+        case "edit_text_payload":
+            ulabel.edit_text_payload__undo(annotation_id, undo_payload);
+            break;
         case "create_annotation":
             ulabel.create_annotation__undo(annotation_id);
             break;
+        case "paste_annotation":
+            ulabel.paste_annotation__undo(annotation_id);
+            break;
+        case "move_annotation":
+            ulabel.move_annotation__undo(annotation_id, undo_payload);
+            break;
+        case "delete_counterparts":
+            ulabel.delete_counterparts__undo(undo_payload);
+            break;
         case "create_nonspatial_annotation":
             ulabel.create_nonspatial_annotation__undo(annotation_id);
             break;
@@ -669,6 +898,9 @@ export function redo_action(ulabel: ULabel, action: ULabelAction) {
         case "delete_annotation":
             ulabel.delete_annotation__redo(annotation_id);
             break;
+        case "restore_annotation":
+            ulabel.restore_annotation__redo(annotation_id);
+            break;
         case "delete_vertex":
             ulabel.delete_vertex__redo(annotation_id, redo_payload);
             break;
@@ -678,9 +910,21 @@ export function redo_action(ulabel: ULabel, action: ULabelAction) {
         case "assign_annotation_id":
             ulabel.assign_annotation_id(annotation_id, redo_payload);
             break;
+        case "edit_text_payload":
+            ulabel.edit_text_payload__redo(annotation_id, redo_payload);
+            break;
         case "create_annotation":
             ulabel.create_annotation__redo(annotation_id, redo_payload);
             break;
+        case "paste_annotation":
+            ulabel.paste_annotation__redo(annotation_id, redo_payload);
+            break;
+        case "move_annotation":
+            ulabel.move_annotation__redo(annotation_id, redo_payload);
+            break;
+        case "delete_counterparts":
+            ulabel.delete_counterparts__redo(annotation_id, redo_payload);
+            break;
         case "create_nonspatial_annotation":
             ulabel.create_nonspatial_annotation(annotation_id, redo_payload);
             break;
diff --git a/src/active_class.ts b/src/active_class.ts
index 0306adad..afb73a4d 100644
--- a/src/active_class.ts
+++ b/src/active_class.ts
@@ -145,6 +145,90 @@ export function set_focus_active_class(
     }
 }
 
+/**
+ * Turn edit focus on or off for a subtask at runtime: annotations unchanged
+ * since load dim and drop out of input like class focus.
+ *
+ * @param ulabel ULabel instance
+ * @param subtask_key subtask to toggle
+ * @param enabled whether only created/modified annotations stay in focus
+ * @param redraw whether the change repaints immediately
+ */
+export function set_focus_edited(
+    ulabel: ULabel,
+    subtask_key: string,
+    enabled: boolean,
+    redraw: boolean = true,
+): void {
+    const subtask = ulabel.subtasks[subtask_key];
+    if (subtask === undefined) {
+        log_message(`set_focus_edited: unknown subtask key ${subtask_key}`, LogLevel.WARNING, true);
+        return;
+    }
+    const previous = subtask.focus_edited === true;
+    subtask.focus_edited = enabled === true;
+
+    subtask.state.hovered_annid = null;
+    subtask.state.fly_to_idx = null;
+
+    if (redraw) {
+        ulabel.redraw_all_annotations(subtask_key);
+        ulabel.toolbox?.redraw_update_items(ulabel);
+    }
+
+    if (previous !== subtask.focus_edited) {
+        ulabel.config.on_focus_edited_change?.(subtask_key, subtask.focus_edited);
+    }
+}
+
+/**
+ * Turn deprecated focus on or off for a subtask at runtime: deprecated
+ * annotations are drawn and in focus, live ones dim and drop out of input.
+ *
+ * @param ulabel ULabel instance
+ * @param subtask_key subtask to toggle
+ * @param enabled whether only deprecated annotations stay in focus
+ * @param redraw whether the change repaints immediately
+ */
+export function set_focus_deprecated(
+    ulabel: ULabel,
+    subtask_key: string,
+    enabled: boolean,
+    redraw: boolean = true,
+): void {
+    const subtask = ulabel.subtasks[subtask_key];
+    if (subtask === undefined) {
+        log_message(`set_focus_deprecated: unknown subtask key ${subtask_key}`, LogLevel.WARNING, true);
+        return;
+    }
+    const previous = subtask.focus_deprecated === true;
+    if (enabled === true && !previous && subtask_key === ulabel.get_current_subtask_key()) {
+        ulabel.discard_in_progress_input();
+    }
+    subtask.focus_deprecated = enabled === true;
+
+    // A deprecated target must not outlive the flag that made it visible
+    subtask.state.hovered_annid = null;
+    subtask.state.edit_candidate = null;
+    subtask.state.move_candidate = null;
+    subtask.state.fly_to_idx = null;
+    if (subtask_key === ulabel.get_current_subtask_key()) ulabel.hide_context_menu();
+    const isolated_annid = subtask.state.isolated_annid;
+    if (isolated_annid != null && subtask.annotations.access[isolated_annid]?.deprecated && !subtask.focus_deprecated) {
+        ulabel.isolate_annotation(null, subtask_key, false);
+    }
+
+    if (redraw) {
+        ulabel.redraw_all_annotations(subtask_key);
+        ulabel.toolbox?.redraw_update_items(ulabel);
+    }
+    ulabel.update_edit_lock_display();
+
+    if (previous !== subtask.focus_deprecated) {
+        ulabel.config.on_focus_deprecated_change?.(subtask_key, subtask.focus_deprecated);
+    }
+}
+
 /**
  * Opacity for annotations outside the focused class. 0 skips drawing them
  * entirely, which is cheaper but loses them as visual context.
@@ -227,8 +311,8 @@ function apply_active_class_to_dom(ulabel: ULabel, subtask_key: string, class_id
     ulabel.update_id_dialog_display();
 
     // Update the class of the active annotation,
-    // except when toggling on the delete class or in a read-only subtask
-    if (class_id !== DELETE_CLASS_ID && !ulabel.is_current_subtask_read_only()) {
+    // except when toggling on the delete class or in an edit-locked subtask
+    if (class_id !== DELETE_CLASS_ID && !ulabel.is_subtask_edit_locked()) {
         let target_id: string | null = null;
         if (subtask.state.active_id !== null) {
             target_id = subtask.state.active_id;
diff --git a/src/annotation.ts b/src/annotation.ts
index 8793b374..bbc2cb5c 100644
--- a/src/annotation.ts
+++ b/src/annotation.ts
@@ -33,6 +33,8 @@ const SPATIAL_TYPE_SET: Record<ULabelSpatialType, true> = {
 // Every ULabelSpatialType (spatial and non-spatial modes) as a runtime array.
 export const ALL_SPATIAL_TYPES = Object.keys(SPATIAL_TYPE_SET) as ULabelSpatialType[];
 
+export type ULabelEditType = "created" | "deleted" | "modified";
+
 export type PolygonSpatialData = {
     // TODO (joshua-dean): validate this type
     spatial_payload: [number[]][];
@@ -70,6 +72,8 @@ export class ULabelAnnotation {
         // Lineage tracking fields
         public last_edited_by?: string,
         public last_edited_at?: string,
+        // Only set on copies handed to an `edits_only` submit hook
+        public edit_type?: ULabelEditType,
     ) {}
 
     public ensure_compatible_classification_payloads(ulabel_class_ids: [number]) {
diff --git a/src/blobs.js b/src/blobs.js
index 4da4358f..d081c836 100644
--- a/src/blobs.js
+++ b/src/blobs.js
@@ -1732,6 +1732,37 @@ div#${prntid} canvas.canvas_cls {
    top: 0;
    left: 0;
 }
+div#${prntid} canvas.canvas_cls.movable_hover {
+   cursor: move;
+}
+div#${prntid} canvas.canvas_cls.edit_locked {
+   cursor: not-allowed;
+}
+div#${prntid} canvas.canvas_cls.edit_locked.context_menu_hover {
+   cursor: context-menu;
+}
+div#${prntid} div.deprecated-focus-banner {
+   position: absolute;
+   top: 8px;
+   left: calc((100% - 320px) / 2);
+   transform: translateX(-50%);
+   z-index: 110;
+   padding: 4px 12px;
+   border-radius: 14px;
+   background-color: rgba(160, 30, 30, 0.85);
+   color: white;
+   font-size: 13px;
+   white-space: nowrap;
+   pointer-events: none;
+}
+div#${prntid} div.toolbox-collapsed div.deprecated-focus-banner {
+   left: 50%;
+}
+div#${prntid} div.deprecated-focus-banner a {
+   color: white;
+   margin-left: 8px;
+   pointer-events: auto;
+}
 div#${prntid} canvas.annotation_canvas {
    pointer-events: none;
 }
@@ -1933,53 +1964,78 @@ div#${prntid} div.global_edit_suggestion {
    display: none;
    position: absolute;
    width: 150px;
-   /*height: 75px;*/
    height: 0px;
    text-align: center;
    z-index: 1;
-   /* background-color: white; */
    transform: scale(0.66666);
    overflow: visible;
 }
-div#${prntid} div.global_edit_suggestion.mcm {
-   width: 225px;
-   transform: scale(0.5);
-}
-div#${prntid} a.global_sub_suggestion {
-   width: 60px;
-   height: 60px;
-   margin-left: 7.5px;
-   margin-right: 7.5px;
-   display: inline-block;
-   border-radius: 37.5px;
+
+div#${prntid} div.ulabel-context-menu {
+   display: none;
+   position: fixed;
+   z-index: 3000;
+   min-width: 0;
+   max-width: 320px;
+   max-height: calc(100vh - 8px);
+   overflow-y: auto;
+   box-sizing: border-box;
+   padding: 2px 0;
    background-color: white;
-   overflow: hidden;
-   transform: translateY(-50%);
+   color: #222;
+   border: 1px solid rgba(0, 0, 0, 0.2);
+   border-radius: 4px;
+   box-shadow: 0 2px 8px rgba(0, 0, 0, 0.25);
+   font-family: sans-serif;
+   font-size: 13px;
+   line-height: 1.2;
+   user-select: none;
 }
-div#${prntid} a.global_sub_suggestion img {
-   display: block;
-   width: 40px;
-   height: 40px;
-   padding: 10px;
+div#${prntid}.ulabel-night div.ulabel-context-menu {
+   background-color: #2b2b2b;
+   color: #eee;
+   border-color: rgba(255, 255, 255, 0.2);
 }
-div#${prntid} a.global_sub_suggestion span.bigx {
-   position: absolute;
-   display: block;
-   font-size: 4em;
-   text-align: center;
-   width: 60px;
-   top: 50%;
-   -ms-transform: translateY(-50%);
-   transform: translateY(-50%);
-   color: black;
-   text-decoration: none;
+div#${prntid} div.ulabel-context-menu-item {
+   display: flex;
+   align-items: center;
+   justify-content: flex-start;
+   gap: 6px;
+   padding: 4px 8px;
+   cursor: pointer;
+   white-space: nowrap;
 }
-div#${prntid} a.global_sub_suggestion.reid_suggestion {
-   opacity: 0.3;
-   background-color: black;
+div#${prntid} span.ulabel-context-menu-item-icon {
+   display: inline-flex;
+   width: 14px;
+   height: 14px;
+   opacity: 0.75;
 }
-div#${prntid} a.global_sub_suggestion.reid_suggestion:hover {
-   opacity: 0; 
+div#${prntid} span.ulabel-context-menu-item-icon svg {
+   width: 100%;
+   height: 100%;
+}
+div#${prntid} div.ulabel-context-menu-item:hover {
+   background-color: rgba(0, 128, 255, 0.15);
+}
+div#${prntid} div.ulabel-context-menu-detail {
+   display: flex;
+   gap: 8px;
+   padding: 2px 8px;
+   font-size: 12px;
+}
+div#${prntid} span.ulabel-context-menu-detail-key {
+   flex: 0 0 auto;
+   color: #777;
+}
+div#${prntid}.ulabel-night span.ulabel-context-menu-detail-key {
+   color: #aaa;
+}
+div#${prntid} span.ulabel-context-menu-detail-value {
+   flex: 1 1 auto;
+   font-family: monospace;
+   word-break: break-all;
+   text-align: right;
 }
 
 div#${prntid} a.tbid-opt {
diff --git a/src/configuration.ts b/src/configuration.ts
index ef085411..d56453cf 100644
--- a/src/configuration.ts
+++ b/src/configuration.ts
@@ -9,6 +9,7 @@ import type {
     ULabelSubmitButton,
     AnnoScalingMode,
     BrushOverlapMode,
+    ULabelAnnotationChange,
 } from "../index";
 import {
     ModeSelectionToolboxItem,
@@ -145,6 +146,16 @@ export class Configuration {
     // Whether stroke overlap resolution reaches masks in other subtasks; off, a
     // stroke only interacts with masks in the active subtask.
     public brush_overlap_across_subtasks: boolean = false;
+    // Left-dragging an annotation's body moves it; Alt forces a new draw at
+    // that spot instead (ctrl/shift already mean pan/zoom on the canvas).
+    public allow_body_move: boolean = true;
+    // Whether a paste whose source class has no counterpart in the target
+    // (by id or name) opens the class pie; off, the target's active class wins.
+    public paste_class_choice: boolean = true;
+    // Whether a context-menu copy/move/delete-from makes the target the current subtask.
+    public paste_switch_to_target: boolean = false;
+    // Whether the context menu hides Copy to / Move to for subtasks holding a counterpart.
+    public hide_copy_to_linked: boolean = false;
     // Configuration for the annotation task itself
     public image_data: ImageData | null = null;
     public allow_soft_id: boolean = false;
@@ -165,6 +176,14 @@ export class Configuration {
     public on_active_class_change: ((subtask_key: string, class_id: number) => void) | null = null;
     public on_subtask_change: ((subtask_key: string, old_subtask_key: string) => void) | null = null;
     public on_focus_active_class_change: ((subtask_key: string, enabled: boolean) => void) | null = null;
+    public on_focus_edited_change: ((subtask_key: string, enabled: boolean) => void) | null = null;
+    public on_focus_deprecated_change: ((subtask_key: string, enabled: boolean) => void) | null = null;
+    public on_isolate_change: ((subtask_key: string, annotation_id: string | null) => void) | null = null;
+    public on_undo_redo_blocked: ((kind: "undo" | "redo", subtask_key: string, from_subtask_key: string, origin_subtask_key: string | null) => void) | null = null;
+    // Fired once per recorded/undone/redone action that changes committed annotation state
+    public on_annotation_change: ((change: ULabelAnnotationChange) => void) | null = null;
+    // Whether continue_* (in-progress) actions are also reported
+    public on_annotation_change_in_progress: boolean = false;
 
     // Passthrough
     public task_meta: object = {};
@@ -277,12 +296,18 @@ export class Configuration {
 
     public toggle_class_focus_keybind: string = "shift+f";
 
+    public toggle_edit_focus_keybind: string = "h";
+
+    public toggle_deprecated_focus_keybind: string = "shift+d";
+
     public fly_to_next_annotation_keybind: string = "tab";
 
     public fly_to_previous_annotation_keybind: string = "shift+tab";
 
     public fly_to_max_zoom: number = 10;
 
+    public fly_to_on_undo: boolean = true;
+
     public min_zoom_fit_ratio: number = 0;
 
     public n_annos_per_canvas: number = DEFAULT_N_ANNOS_PER_CANVAS;
diff --git a/src/context_menu.ts b/src/context_menu.ts
new file mode 100644
index 00000000..b260f7ac
--- /dev/null
+++ b/src/context_menu.ts
@@ -0,0 +1,302 @@
+/**
+ * Right-click context menu for annotations.
+ *
+ * One fixed-position element per ULabel instance, mounted under the container
+ * and rebuilt on every open. Actions route through the same `ULabel` methods
+ * the keybinds use (`show_id_dialog`, `delete_annotation`) so undo and the
+ * per-class mode gate are unchanged. While the menu is open the target stays
+ * the hover candidate; closing clears it.
+ */
+
+import type { ULabel } from "../index";
+import { ULabelAnnotation } from "./annotation";
+import { get_annotation_class_id } from "./annotation_operators";
+
+const MENU_CLASS = "ulabel-context-menu";
+const VIEWPORT_MARGIN = 4;
+
+// Static 16x16 stroke icons; `currentColor` follows the menu's text color
+const SVG_ATTRS = `xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"`;
+const ICON_CHANGE_CLASS = `<svg ${SVG_ATTRS}><path d="M2 2h5.5l6.5 6.5-5.5 5.5L2 7.5z"/><circle cx="5" cy="5" r="1"/></svg>`;
+const ICON_DELETE = `<svg ${SVG_ATTRS}><path d="M2.5 4h11M6 4V2.5h4V4M3.5 4l.8 9.5h7.4l.8-9.5M6.5 7v4M9.5 7v4"/></svg>`;
+const ICON_DETAILS = `<svg ${SVG_ATTRS}><circle cx="8" cy="8" r="6"/><path d="M8 7.5v4M8 5v.01"/></svg>`;
+const ICON_ISOLATE = `<svg ${SVG_ATTRS}><path d="M1.5 8s2.5-4.5 6.5-4.5S14.5 8 14.5 8s-2.5 4.5-6.5 4.5S1.5 8 1.5 8z"/><circle cx="8" cy="8" r="2"/></svg>`;
+const ICON_COPY = `<svg ${SVG_ATTRS}><rect x="5.5" y="5.5" width="8" height="8" rx="1"/><path d="M10.5 5.5v-2a1 1 0 0 0-1-1h-6a1 1 0 0 0-1 1v6a1 1 0 0 0 1 1h2"/></svg>`;
+const ICON_CUT = `<svg ${SVG_ATTRS}><circle cx="4.5" cy="11.5" r="2"/><circle cx="11.5" cy="11.5" r="2"/><path d="M6 10l7-8M10 10L3 2"/></svg>`;
+const ICON_RESTORE = `<svg ${SVG_ATTRS}><path d="M2.5 8a5.5 5.5 0 1 0 1.6-3.9M2.5 2.5v3h3"/></svg>`;
+
+function get_menu_element(ulabel: ULabel): HTMLDivElement | null {
+    return document.getElementById(`${MENU_CLASS}__${ulabel.config.container_id}`) as HTMLDivElement | null;
+}
+
+function ensure_menu_element(ulabel: ULabel): HTMLDivElement | null {
+    let menu = get_menu_element(ulabel);
+    if (menu != null) return menu;
+    const container = document.getElementById(ulabel.config.container_id);
+    if (container == null) return null;
+    menu = document.createElement("div");
+    menu.id = `${MENU_CLASS}__${ulabel.config.container_id}`;
+    menu.className = MENU_CLASS;
+    // A mousedown inside the menu must not reach the annbox/document handlers
+    menu.addEventListener("mousedown", (mouse_event) => mouse_event.stopPropagation());
+    menu.addEventListener("contextmenu", (mouse_event) => mouse_event.preventDefault());
+    container.appendChild(menu);
+    return menu;
+}
+
+function add_item(menu: HTMLDivElement, label: string, icon_svg: string, on_click: () => void): void {
+    const item = document.createElement("div");
+    item.className = `${MENU_CLASS}-item`;
+    const icon = document.createElement("span");
+    icon.className = `${MENU_CLASS}-item-icon`;
+    icon.innerHTML = icon_svg;
+    const text = document.createElement("span");
+    text.textContent = label;
+    item.appendChild(icon);
+    item.appendChild(text);
+    item.addEventListener("click", (click_event) => {
+        click_event.stopPropagation();
+        on_click();
+    });
+    menu.appendChild(item);
+}
+
+function add_detail_row(menu: HTMLDivElement, label: string, value: unknown): void {
+    const row = document.createElement("div");
+    row.className = `${MENU_CLASS}-detail`;
+    const key = document.createElement("span");
+    key.className = `${MENU_CLASS}-detail-key`;
+    key.textContent = label;
+    const val = document.createElement("span");
+    val.className = `${MENU_CLASS}-detail-value`;
+    val.textContent = format_detail_value(value);
+    row.appendChild(key);
+    row.appendChild(val);
+    menu.appendChild(row);
+}
+
+function format_detail_value(value: unknown): string {
+    if (value == null) return "";
+    if (typeof value === "object") return JSON.stringify(value);
+    return String(value);
+}
+
+/** Keep the menu inside the viewport, preferring to hang right/below the cursor. */
+function position_menu(menu: HTMLDivElement, client_x: number, client_y: number): void {
+    menu.style.display = "block";
+    menu.style.left = `${client_x}px`;
+    menu.style.top = `${client_y}px`;
+    const rect = menu.getBoundingClientRect();
+    const max_left = window.innerWidth - rect.width - VIEWPORT_MARGIN;
+    const max_top = window.innerHeight - rect.height - VIEWPORT_MARGIN;
+    if (rect.left > max_left) menu.style.left = `${Math.max(VIEWPORT_MARGIN, max_left)}px`;
+    if (rect.top > max_top) menu.style.top = `${Math.max(VIEWPORT_MARGIN, max_top)}px`;
+}
+
+function render_details(
+    ulabel: ULabel,
+    menu: HTMLDivElement,
+    annotation: ULabelAnnotation,
+    client_x: number,
+    client_y: number,
+): void {
+    menu.replaceChildren();
+    const subtask = ulabel.get_current_subtask();
+    const class_id = Number(get_annotation_class_id(annotation));
+    const class_def = subtask.class_defs.find((cd) => cd.id === class_id);
+    add_detail_row(menu, "id", annotation.id);
+    add_detail_row(menu, "class", class_def != null ? `${class_def.name} (${class_id})` : String(class_id));
+    add_detail_row(menu, "type", annotation.spatial_type);
+    add_detail_row(menu, "edited by", annotation.last_edited_by);
+    add_detail_row(menu, "edited at", annotation.last_edited_at);
+    if (annotation.deprecated) {
+        const sources = Object.entries(annotation.deprecated_by ?? {}).filter(([, value]) => value).map(([key]) => key);
+        add_detail_row(menu, "deprecated by", sources.join(", "));
+    }
+    const meta = annotation.annotation_meta;
+    if (meta != null && typeof meta === "object") {
+        for (const [key, value] of Object.entries(meta)) {
+            add_detail_row(menu, key, value);
+        }
+    }
+    // The panel is taller than the item list; re-clamp from the original anchor
+    position_menu(menu, client_x, client_y);
+}
+
+/**
+ * "Copy to" / "Move to" / "Delete from" entry. One eligible subtask collapses to a flat
+ * "<label> <name>" item; several open an in-place list of subtask names. A `count_of`
+ * above 1 is shown as "<verb> <n> <rest> <name>" or "<name> (<n>)".
+ */
+function add_subtask_picker(
+    ulabel: ULabel,
+    menu: HTMLDivElement,
+    label: string,
+    icon_svg: string,
+    target_keys: string[],
+    client_x: number,
+    client_y: number,
+    on_pick: (target_key: string) => void,
+    count_of: (target_key: string) => number = () => 1,
+): void {
+    const name_of = (key: string) => ulabel.subtasks[key].display_name;
+    if (target_keys.length === 1) {
+        const key = target_keys[0];
+        const count = count_of(key);
+        const [verb, ...rest] = label.split(" ");
+        const text = count > 1 ? `${verb} ${count} ${rest.join(" ")}` : label;
+        add_item(menu, `${text} ${name_of(key)}`, icon_svg, () => on_pick(key));
+        return;
+    }
+    add_item(menu, `${label}\u2026`, icon_svg, () => {
+        menu.replaceChildren();
+        for (const key of target_keys) {
+            const count = count_of(key);
+            add_item(menu, count > 1 ? `${name_of(key)} (${count})` : name_of(key), icon_svg, () => on_pick(key));
+        }
+        position_menu(menu, client_x, client_y);
+    });
+}
+
+/**
+ * Open the menu for an annotation in the current subtask at a viewport
+ * position. Items: Change class (editable subtask with at least two
+ * compatible classes), Copy to / Move to (another writable subtask has a
+ * compatible class; Move to only on an editable subtask), Erase from (a
+ * bitmask, where another writable subtask holds bitmask counterparts, see
+ * `find_counterparts`), Delete from (another writable subtask holds
+ * counterparts; the count shows when above 1), Delete (editable
+ * subtask), Isolate / Show all (always; view-only), Details (always).
+ * A deprecated annotation (only reachable under deprecated focus) gets
+ * Restore (see `can_restore_annotation`), Isolate / Show all, and Details.
+ *
+ * @returns whether the menu was shown
+ */
+export function show_context_menu(ulabel: ULabel, annid: string, client_x: number, client_y: number): boolean {
+    const subtask = ulabel.get_current_subtask();
+    const annotation = subtask.annotations.access[annid];
+    if (
+        annotation == null ||
+        (annotation.deprecated && ulabel.is_annotation_defocused(annotation, ulabel.get_current_subtask_key()))
+    ) {
+        hide_context_menu(ulabel);
+        return false;
+    }
+    const menu = ensure_menu_element(ulabel);
+    if (menu == null) return false;
+    menu.replaceChildren();
+
+    if (annotation.deprecated) {
+        if (ulabel.can_restore_annotation(annid)) {
+            add_item(menu, "Restore", ICON_RESTORE, () => {
+                hide_context_menu(ulabel);
+                ulabel.restore_annotation(annid);
+            });
+        }
+    } else {
+        add_edit_items(ulabel, menu, annotation, annid, client_x, client_y);
+    }
+    // isolate_annotation closes the menu itself
+    const is_isolated = subtask.state.isolated_annid === annid;
+    add_item(menu, is_isolated ? "Show all" : "Isolate", ICON_ISOLATE, () => {
+        ulabel.isolate_annotation(is_isolated ? null : annid);
+    });
+    add_item(menu, "Details", ICON_DETAILS, () => render_details(ulabel, menu, annotation, client_x, client_y));
+
+    ulabel.state.context_menu_annid = annid;
+    position_menu(menu, client_x, client_y);
+    return true;
+}
+
+/** Change class, Copy/Move to, Erase/Delete from, and Delete for a live annotation. */
+function add_edit_items(
+    ulabel: ULabel,
+    menu: HTMLDivElement,
+    annotation: ULabelAnnotation,
+    annid: string,
+    client_x: number,
+    client_y: number,
+): void {
+    const read_only = ulabel.is_subtask_edit_locked();
+    if (!read_only && ulabel._get_compatible_class_ids(annotation).length >= 2) {
+        add_item(menu, "Change class", ICON_CHANGE_CLASS, () => {
+            hide_context_menu(ulabel);
+            const cbox = annotation.containing_box;
+            if (cbox != null) {
+                ulabel.show_id_dialog((cbox.tlx + cbox.brx) / 2, (cbox.tly + cbox.bry) / 2, annid, false);
+            } else {
+                ulabel.show_id_dialog(0, 0, annid, true);
+            }
+        });
+    }
+    const source_key = ulabel.get_current_subtask_key();
+    const counterparts: Record<string, string[]> = {};
+    for (const key of Object.keys(ulabel.subtasks)) {
+        if (key === source_key || ulabel.is_subtask_edit_locked(key)) continue;
+        const ids = ulabel.find_counterparts(annid, source_key, key);
+        if (ids.length > 0) counterparts[key] = ids;
+    }
+    const copy_targets = ulabel.get_copy_target_subtask_keys(annotation, source_key).filter(
+        (key) => !(ulabel.config.hide_copy_to_linked && key in counterparts),
+    );
+    if (copy_targets.length > 0) {
+        const transfer = (target_key: string, cut: boolean) => {
+            hide_context_menu(ulabel);
+            if (ulabel.find_counterparts(annid, source_key, target_key).length > 0) {
+                const target_name = ulabel.subtasks[target_key].display_name ?? target_key;
+                if (!confirm(`${target_name} already has this annotation. ${cut ? "Move" : "Copy"} it there anyway?`)) return;
+            }
+            // Also arm ctrl+v, counting this as the first paste into the target
+            const envelope = ulabel.copy_annotation_to_clipboard(annid);
+            const new_id = ulabel.copy_annotation_to_subtask(annid, source_key, target_key, null, cut, true);
+            if (envelope !== null && new_id !== null) {
+                (envelope.paste_counts ??= {})[target_key] = 1;
+                navigator.clipboard?.writeText(JSON.stringify(envelope)).catch(() => {});
+            }
+        };
+        add_subtask_picker(ulabel, menu, "Copy to", ICON_COPY, copy_targets, client_x, client_y, (key) => transfer(key, false));
+        if (!read_only) {
+            add_subtask_picker(ulabel, menu, "Move to", ICON_CUT, copy_targets, client_x, client_y, (key) => transfer(key, true));
+        }
+    }
+    const remove = (target_key: string, erase: boolean) => {
+        hide_context_menu(ulabel);
+        ulabel.delete_counterparts(annid, source_key, target_key, erase);
+    };
+    if (annotation.spatial_type === "bitmask") {
+        const erase_targets = Object.keys(counterparts).filter((key) => counterparts[key].some(
+            (id) => ulabel.subtasks[key].annotations.access[id].spatial_type === "bitmask",
+        ));
+        if (erase_targets.length > 0) {
+            add_subtask_picker(ulabel, menu, "Erase from", ICON_DELETE, erase_targets, client_x, client_y, (key) => remove(key, true));
+        }
+    }
+    const delete_targets = Object.keys(counterparts);
+    if (delete_targets.length > 0) {
+        const count_of = (key: string) => counterparts[key].length;
+        add_subtask_picker(ulabel, menu, "Delete from", ICON_DELETE, delete_targets, client_x, client_y, (key) => remove(key, false), count_of);
+    }
+    if (!read_only) {
+        add_item(menu, "Delete", ICON_DELETE, () => {
+            hide_context_menu(ulabel);
+            ulabel.delete_annotation(annid);
+        });
+    }
+}
+
+/** Close the menu and drop the hover it was holding. No-op when closed. */
+export function hide_context_menu(ulabel: ULabel): void {
+    if (ulabel.state.context_menu_annid == null) return;
+    ulabel.state.context_menu_annid = null;
+    const menu = get_menu_element(ulabel);
+    if (menu != null) {
+        menu.style.display = "none";
+        menu.replaceChildren();
+    }
+    $(".annotation-list-item").removeClass("highlighted");
+    ulabel.hide_and_clear_action_candidates();
+}
+
+export function is_context_menu_open(ulabel: ULabel): boolean {
+    return ulabel.state.context_menu_annid != null;
+}
diff --git a/src/geometric_utils.ts b/src/geometric_utils.ts
index 5c178fb3..f861e68b 100644
--- a/src/geometric_utils.ts
+++ b/src/geometric_utils.ts
@@ -12,6 +12,7 @@ export type PointAccessObject = {
     access: string | number | null; // Access string or number that acts as the index of the point in the original spatial payload
     distance: number | null;
     point: Point2D | null;
+    segment?: number; // Index of the segment's first point, when segments are searched
 };
 export type LineEquation = {
     a: number;
@@ -339,6 +340,7 @@ export class GeometricUtils {
                     ret["access"] = "" + (kpi + nr["prop"]);
                     ret["distance"] = nr["dst"];
                     ret["point"] = GeometricUtils.interpolate_poly_segment(poly_pts, kpi, nr["prop"]);
+                    ret["segment"] = kpi;
                 }
             }
             return ret;
@@ -585,6 +587,21 @@ export class GeometricUtils {
         return false;
     }
 
+    /**
+     * The cross bar of a tbar with stem `sp` -> `ep`: centred on `sp`,
+     * perpendicular to the stem, as long as the stem.
+     */
+    public static tbar_cross_segment(sp: Point2D, ep: Point2D): ULabelSpatialPayload2D {
+        const halflen: number = Math.sqrt(
+            (sp[0] - ep[0]) * (sp[0] - ep[0]) + (sp[1] - ep[1]) * (sp[1] - ep[1]),
+        ) / 2;
+        const theta: number = Math.atan((ep[1] - sp[1]) / (ep[0] - sp[0]));
+        return [
+            [sp[0] + halflen * Math.sin(theta), sp[1] - halflen * Math.cos(theta)],
+            [sp[0] - halflen * Math.sin(theta), sp[1] + halflen * Math.cos(theta)],
+        ];
+    }
+
     // Convert a bbox to a simple polygon by adding the last point
     public static bbox_to_simple_polygon(
         bbox: ULabelSpatialPayload2D,
diff --git a/src/html_builder.ts b/src/html_builder.ts
index 8cf7d920..789b6644 100644
--- a/src/html_builder.ts
+++ b/src/html_builder.ts
@@ -478,23 +478,10 @@ export function build_edit_suggestion(ulabel: ULabel) {
             "border-radius": ulabel.config["edit_handle_size"] / 2 + "px",
         });
 
-        // Global edit suggestion
-        let id_edit: string = "";
-        let mcm_ind: string = "";
-        if (!ulabel.subtasks[stkey]["single_class_mode"]) {
-            id_edit = `--><a href="#" class="reid_suggestion global_sub_suggestion gedit-target"></a><!--`;
-            mcm_ind = " mcm";
-        }
+        // Global edit suggestion: a zero-height anchor at the hovered annotation's
+        // box centre that the confidence card is positioned against
         subtask_dialog_container_jq.append(`
-            <div id="${global_id}" class="global_edit_suggestion glob_editable gedit-target${mcm_ind}">
-                <a href="#" class="move_suggestion global_sub_suggestion movable gedit-target">
-                    <img class="movable gedit-target" src="data:image/png;base64,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">
-                </a><!--
-                ${id_edit}
-                --><a href="#" class="delete_suggestion global_sub_suggestion gedit-target">
-                    <span class="bigx gedit-target">&#215;</span>
-                </a>
-            </div>
+            <div id="${global_id}" class="global_edit_suggestion"></div>
         `);
 
         // Register these dialogs with each subtask
@@ -531,17 +518,9 @@ export function build_confidence_dialog(ulabel: ULabel) {
             width: ulabel.config["edit_handle_size"] + "px",
         });
 
-        // Global edit suggestion
-        let id_edit: string = "";
-        let mcm_ind: string = "";
-        if (!ulabel.subtasks[stkey]["single_class_mode"]) {
-            // TODO (joshua-dean): Is `id_edit` actually necessary or can we yoink it?
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            id_edit = `--><a href="#" class="reid_suggestion global_sub_suggestion gedit-target"></a><!--`;
-            mcm_ind = " mcm";
-        }
+        // Global confidence card, anchored to the edit suggestion container
         global_edit_suggestion_jq.append(`
-            <div id="${global_id}" class="annotation-confidence gedit-target${mcm_ind}">
+            <div id="${global_id}" class="annotation-confidence">
                 <p class="annotation-confidence-classname" style="margin: 0.4em 0.6em 0.1em; opacity: 1; font-weight: 600;"></p>
                 <p class="annotation-confidence-value" style="margin: 0.1em 0.6em 0.4em; opacity: 0.85; font-size: 0.9em;">
                 </p>
@@ -550,7 +529,7 @@ export function build_confidence_dialog(ulabel: ULabel) {
 
         // Style the dialog. Absolutely positioned against the 0-height edit-suggestion
         // container, whose top edge is the annotation's anchor; show_global_edit_suggestion
-        // sets top/bottom per hover to hug the button ring above or below the anchor.
+        // sets top/bottom per hover to hug the containing box above or below the anchor.
         $("#" + global_id).css({
             "background-color": "rgba(0, 0, 0, 0.75)",
             "color": "white",
diff --git a/src/index.js b/src/index.js
index 0be43d9e..f0736dd9 100644
--- a/src/index.js
+++ b/src/index.js
@@ -32,8 +32,11 @@ import { initialize_annotation_canvases } from "../build/canvas_utils";
 import { record_action, record_finish, record_finish_edit, record_finish_move, undo, redo } from "../build/actions";
 import { ULabelMask, is_raw_mask_payload } from "../build/mask_utils";
 import { get_active_class_id, get_local_storage_item, set_local_storage_item } from "../build/utilities";
-import { set_active_class, get_selected_class_id, set_focus_active_class, set_defocused_opacity, can_annotation_be_class } from "../build/active_class";
+import { set_active_class, get_selected_class_id, set_focus_active_class, set_focus_edited, set_focus_deprecated, set_defocused_opacity, can_annotation_be_class } from "../build/active_class";
+import { show_context_menu, hide_context_menu, is_context_menu_open } from "../build/context_menu";
+import { isolate_annotation, is_annotation_isolated_out } from "../build/isolate";
 import { get_idd_string } from "../build/html_builder";
+import { SubmitButtons } from "../build/toolbox_items/submit_buttons";
 
 import $ from "jquery";
 const jQuery = $;
@@ -68,6 +71,9 @@ const BITMASK_OUTLINE_BORDER = 2;
 // Opacity of annotations outside a subtask's focused class. 0 skips them.
 const DEFAULT_DEFOCUSED_OPACITY = 0.4;
 
+// Image-space shift applied when an annotation is pasted back into the subtask it was copied from.
+const PASTE_OFFSET_PX = 20;
+
 export class ULabel {
     static version() {
         return ULABEL_VERSION;
@@ -113,7 +119,7 @@ export class ULabel {
         switch (mouse_event.button) {
             case 0:
                 if (mouse_event.target.id === "brush_circle") {
-                    return "brush";
+                    return ul.is_subtask_edit_locked() ? null : "brush";
                 } else if (mouse_event.target.id === ul.get_current_subtask()["canvas_fid"]) {
                     if (mouse_event.ctrlKey || mouse_event.metaKey) {
                         return "pan";
@@ -121,15 +127,15 @@ export class ULabel {
                     if (mouse_event.shiftKey && !ul.get_current_subtask()["state"]["starting_complex_polygon"]) {
                         return "zoom";
                     }
-                    if (ul.is_current_subtask_read_only()) {
+                    if (ul.is_subtask_edit_locked()) {
                         return null;
                     }
+                    if (ULabel.is_body_move_start(mouse_event, ul)) {
+                        return "move";
+                    }
                     return "annotation";
                 } else if ($(mouse_event.target).hasClass("editable")) {
                     return "edit";
-                } else if ($(mouse_event.target).hasClass("movable")) {
-                    mouse_event.preventDefault();
-                    return "move";
                 } else {
                     return null;
                 }
@@ -140,6 +146,21 @@ export class ULabel {
         }
     }
 
+    /**
+     * Whether a left mousedown on the canvas should move the hovered annotation
+     * rather than start a draw: body move enabled, not a delete mode (whose
+     * drags start over the annotations they target), Alt not held, and the
+     * hover candidate a real containing hit (not the near-miss box fallback).
+     */
+    static is_body_move_start(mouse_event, ul) {
+        if (!ul.config["allow_body_move"]) return false;
+        const current_subtask = ul.get_current_subtask();
+        if (DELETE_MODES.includes(current_subtask["state"]["annotation_mode"])) return false;
+        if (mouse_event.altKey) return false;
+        const move_candidate = current_subtask["state"]["move_candidate"];
+        return move_candidate != null && move_candidate["containing"] === true;
+    }
+
     /**
      * Removes persistent event listeners from the document and window.
      * Listeners attached directly to html elements are not explicitly removed.
@@ -420,6 +441,7 @@ export class ULabel {
         ul.subtasks[subtask_key]["annotations"] = {
             ordering: [],
             access: {},
+            loaded_edited_at: {},
         };
         if (subtask["resume_from"] != null) {
             for (var i = 0; i < subtask["resume_from"].length; i++) {
@@ -538,6 +560,7 @@ export class ULabel {
                 // Push to ordering and add to access
                 ul.subtasks[subtask_key]["annotations"]["ordering"].push(cand.id);
                 ul.subtasks[subtask_key]["annotations"]["access"][cand.id] = cand;
+                ul.subtasks[subtask_key]["annotations"]["loaded_edited_at"][cand.id] = cand.last_edited_at;
 
                 if (cand.spatial_type === "polygon") {
                     // If missing any of `spatial_payload_holes` or `spatial_payload_child_indices`,
@@ -597,7 +620,6 @@ export class ULabel {
                 idd_id_front: "id_dialog_front__" + subtask_key,
                 idd_visible: false,
                 idd_associated_annotation: null,
-                idd_thumbnail: false,
                 id_payload: id_payload,
                 delete_mode_id_payload: [{ class_id: -1, confidence: 1 }],
                 // Class ids currently rendered in this subtask's pies; shrinks to
@@ -621,6 +643,7 @@ export class ULabel {
                 fly_to_idx: null,
                 // The last non-delete class selected; what class focus follows
                 selected_class_id: ul.subtasks[subtask_key]["class_ids"][0] ?? null,
+                isolated_annid: null,
                 defocused_opacity: raw_subtask["defocused_opacity"] ?? DEFAULT_DEFOCUSED_OPACITY,
                 // Cache of the layer opacity slider, synced by readjust_subtask_opacities
                 layer_opacity: 1,
@@ -760,9 +783,17 @@ export class ULabel {
             // Overlay snapshot + rAF flag used to keep in-progress bitmask moves cheap
             bitmask_move_overlay: null,
             move_raf_pending: false,
+            // Saved/undone state captured in begin_move so a zero-diff click can be unwound
+            move_snapshot: null,
+            // Annotation the right-click context menu is open for, if any
+            context_menu_annid: null,
+            // Last copied/cut annotation envelope (see copy_annotation_to_clipboard)
+            clipboard: null,
 
             // Global annotation state (subtasks also maintain an annotation state)
             current_subtask: null, // The key of the current subtask
+            // Read-only subtask an undo/redo was issued from while it runs on the writable one
+            undo_redo_from_subtask: null,
             last_brush_stroke: null,
             anno_scaling_mode: this.config.anno_scaling_mode,
 
@@ -787,45 +818,7 @@ export class ULabel {
         // TODO(v1)
         // There can only be one drag, yes? Maybe pare this down...
         // Would be nice to consolidate this with global state also
-        this.drag_state = {
-            active_key: null,
-            release_button: null,
-            annotation: {
-                mouse_start: null, // Screen coordinates where the current mouse drag started
-                offset_start: null, // Scroll values where the current mouse drag started
-                zoom_val_start: null, // zoom_val when the dragging interaction started
-            },
-            brush: {
-                mouse_start: null, // Screen coordinates where the current mouse drag started
-                offset_start: null, // Scroll values where the current mouse drag started
-                zoom_val_start: null, // zoom_val when the dragging interaction started
-            },
-            edit: {
-                mouse_start: null, // Screen coordinates where the current mouse drag started
-                offset_start: null, // Scroll values where the current mouse drag started
-                zoom_val_start: null, // zoom_val when the dragging interaction started
-            },
-            pan: {
-                mouse_start: null, // Screen coordinates where the current mouse drag started
-                offset_start: null, // Scroll values where the current mouse drag started
-                zoom_val_start: null, // zoom_val when the dragging interaction started
-            },
-            zoom: {
-                mouse_start: null, // Screen coordinates where the current mouse drag started
-                offset_start: null, // Scroll values where the current mouse drag started
-                zoom_val_start: null, // zoom_val when the dragging interaction started
-            },
-            move: {
-                mouse_start: null, // Screen coordinates where the current mouse drag started
-                offset_start: null, // Scroll values where the current mouse drag started
-                zoom_val_start: null, // zoom_val when the dragging interaction started
-            },
-            right: {
-                mouse_start: null, // Screen coordinates where the current mouse drag started
-                offset_start: null, // Scroll values where the current mouse drag started
-                zoom_val_start: null, // zoom_val when the dragging interaction started
-            },
-        };
+        this.drag_state = ULabel.build_initial_drag_state();
 
         for (const st in this.subtasks) {
             for (let i = 0; i < this.subtasks[st]["annotations"]["ordering"].length; i++) {
@@ -868,6 +861,7 @@ export class ULabel {
 
         // The configured initial mode may not be one the initial class allows
         this.sync_annotation_modes_to_active_class();
+        this.update_edit_lock_display();
 
         // Show the brush toolbox if bitmask is the initial mode (brush starts off; toggle to paint)
         if (this.get_current_subtask()["state"]["annotation_mode"] === "bitmask") {
@@ -1103,6 +1097,51 @@ export class ULabel {
         return this.get_current_subtask()["read_only"] === true;
     }
 
+    /**
+     * Whether user input may not edit a subtask: read-only, or under deprecated
+     * focus (where only Restore applies). Public API methods are unaffected.
+     * @param {string|null} subtask_key defaults to the current subtask
+     */
+    is_subtask_edit_locked(subtask_key = null) {
+        const subtask = this.subtasks[subtask_key ?? this.get_current_subtask_key()];
+        return subtask?.["read_only"] === true || subtask?.["focus_deprecated"] === true;
+    }
+
+    /**
+     * Show the current subtask's deprecated-focus banner, and the locked cursor
+     * on the front canvas of every subtask under deprecated focus.
+     */
+    update_edit_lock_display() {
+        for (const subtask of Object.values(this.subtasks)) {
+            $("#" + subtask["canvas_fid"]).toggleClass("edit_locked", subtask["focus_deprecated"] === true);
+        }
+        $("#" + this.config["container_id"] + " .deprecated-focus-banner")
+            .toggleClass("ulabel-hidden", this.get_current_subtask()?.["focus_deprecated"] !== true);
+    }
+
+    /**
+     * End the current subtask's in-progress input before it becomes edit-locked:
+     * completes an active drag and discards other work as Escape would.
+     */
+    discard_in_progress_input() {
+        const state = this.get_current_subtask()["state"];
+        if (this.drag_state["active_key"] !== null) {
+            this.end_drag(this.state["last_move"]);
+        }
+        if (state["starting_complex_polygon"]) {
+            undo(this, true);
+        }
+        if (state["is_in_progress"]) {
+            this.cancel_annotation();
+        }
+        if (state["is_in_brush_mode"]) {
+            this.disable_bitmask_brush();
+        }
+        this.hide_id_dialog();
+        this.hide_context_menu();
+        this.hide_and_clear_action_candidates();
+    }
+
     /**
      * Whether a subtask's annotations are hidden from view: vanished, or its
      * layer opacity slider is at 0. Hidden implies non-interactive, so the
@@ -1151,7 +1190,40 @@ export class ULabel {
     }
 
     /**
-     * Whether a class focus is active on a subtask and this annotation is not in it.
+     * Make a subtask read-only or editable at runtime. Making the current
+     * subtask read-only completes an active drag and discards other
+     * in-progress work as Escape would. Not recorded, does not mark edited.
+     * @param {string} subtask_key
+     * @param {boolean} read_only
+     */
+    set_subtask_read_only(subtask_key, read_only) {
+        const subtask = this.subtasks[subtask_key];
+        if (subtask === undefined) {
+            log_message(`set_subtask_read_only: unknown subtask key ${subtask_key}`, LogLevel.WARNING, true);
+            return;
+        }
+        read_only = read_only === true;
+        if (subtask["read_only"] === read_only) return;
+
+        // Teardown runs before the flag flips, so it behaves as on an editable subtask
+        if (read_only && subtask_key === this.get_current_subtask_key()) {
+            this.discard_in_progress_input();
+        }
+        subtask["read_only"] = read_only;
+
+        // Non-spatial rows bake their read-only controls in at creation
+        for (const annotation_id of subtask["annotations"]["ordering"]) {
+            const annotation = subtask["annotations"]["access"][annotation_id];
+            if (!NONSPATIAL_MODES.includes(annotation["spatial_type"])) continue;
+            if ($(`div#${this.get_nonspatial_annotation_element_id(annotation_id)}`).length === 0) continue;
+            this.clear_nonspatial_annotation(annotation_id);
+            const svg_obj = annotation["spatial_type"] === "whole-image" ? WHOLE_IMAGE_SVG : GLOBAL_SVG;
+            this.draw_nonspatial_annotation(annotation, svg_obj, subtask_key);
+        }
+    }
+
+    /**
+     * Whether class focus or edit focus is active on a subtask and this annotation is not in it.
      * Affects drawing and input targeting only: a defocused annotation is still
      * real data, so geometry (bitmask overlap, merges) must ignore this.
      * @param {object} annotation
@@ -1160,12 +1232,43 @@ export class ULabel {
      */
     is_annotation_defocused(annotation, subtask_key) {
         const subtask = this.subtasks[subtask_key];
-        if (subtask == null || !subtask["focus_active_class"]) return false;
+        if (subtask == null) return false;
+        // Isolation hides rather than dims, but shares every input gate
+        if (is_annotation_isolated_out(this, annotation, subtask_key)) return true;
+        // Deprecated annotations are in focus only under deprecated focus, and then only they are
+        const is_deprecated = annotation["deprecated"] === true;
+        if (is_deprecated !== (subtask["focus_deprecated"] === true)) return true;
+        if (subtask["focus_edited"]) {
+            const loaded_edited_at = subtask["annotations"]["loaded_edited_at"] ?? {};
+            if (SubmitButtons.classify_edit(annotation, loaded_edited_at[annotation["id"]]) === null) return true;
+        }
+        if (!subtask["focus_active_class"]) return false;
         const selected_class_id = get_selected_class_id(this, subtask_key);
         if (selected_class_id == null) return false;
         return get_annotation_class_id(annotation) !== String(selected_class_id);
     }
 
+    /**
+     * Isolate one annotation in a subtask (hide all others), or pass `null`
+     * to show all again. View-only: not recorded, does not mark edited.
+     *
+     * @param {string|null} annotation_id
+     * @param {string|null} subtask_key defaults to the current subtask
+     * @param {boolean} redraw
+     * @returns {boolean} whether the request was accepted
+     */
+    isolate_annotation(annotation_id, subtask_key = null, redraw = true) {
+        return isolate_annotation(this, annotation_id, subtask_key, redraw);
+    }
+
+    /**
+     * @param {string|null} subtask_key defaults to the current subtask
+     * @returns {string|null} the isolated annotation id, if any
+     */
+    get_isolated_annotation_id(subtask_key = null) {
+        return this.subtasks[subtask_key ?? this.get_current_subtask_key()]?.["state"]["isolated_annid"] ?? null;
+    }
+
     /**
      * Set a subtask's active class: id payload, toolbox selection, per-class
      * mode sync, and - on subtasks with `focus_active_class` - the class focus.
@@ -1179,6 +1282,27 @@ export class ULabel {
         return set_active_class(this, class_id, subtask_key, redraw);
     }
 
+    /**
+     * Open the right-click context menu for an annotation in the current
+     * subtask at a viewport position.
+     *
+     * @param {string} annotation_id
+     * @param {number} client_x
+     * @param {number} client_y
+     * @returns {boolean} whether the menu was shown
+     */
+    show_context_menu(annotation_id, client_x, client_y) {
+        return show_context_menu(this, annotation_id, client_x, client_y);
+    }
+
+    hide_context_menu() {
+        hide_context_menu(this);
+    }
+
+    is_context_menu_open() {
+        return is_context_menu_open(this);
+    }
+
     /**
      * The last non-delete class selected on a subtask. Delete-mode toggles
      * don't move it, so class focus stays put while deleting.
@@ -1200,6 +1324,28 @@ export class ULabel {
         set_focus_active_class(this, subtask_key, enabled, redraw);
     }
 
+    /**
+     * Turn edit focus on or off for a subtask: annotations unchanged since
+     * load dim and drop out of input.
+     * @param {string} subtask_key
+     * @param {boolean} enabled
+     * @param {boolean} redraw
+     */
+    set_focus_edited(subtask_key, enabled, redraw = true) {
+        set_focus_edited(this, subtask_key, enabled, redraw);
+    }
+
+    /**
+     * Turn deprecated focus on or off for a subtask: deprecated annotations
+     * are drawn and in focus, live ones dim and drop out of input.
+     * @param {string} subtask_key
+     * @param {boolean} enabled
+     * @param {boolean} redraw
+     */
+    set_focus_deprecated(subtask_key, enabled, redraw = true) {
+        set_focus_deprecated(this, subtask_key, enabled, redraw);
+    }
+
     /**
      * Opacity for annotations outside the focused class. 0 skips drawing them
      * entirely, which is cheaper but loses them as visual context.
@@ -1213,6 +1359,9 @@ export class ULabel {
 
     set_subtask(st_key) {
         let old_st = this.get_current_subtask_key();
+        this.hide_context_menu();
+        // Isolation is a per-subtask view; leaving the subtask ends it
+        this.isolate_annotation(null, old_st);
 
         // Clear stale hover on the outgoing subtask so its white outline doesn't linger
         // (its canvases stay visible at reduced opacity in the background).
@@ -1276,6 +1425,7 @@ export class ULabel {
 
         // Set transparancy for inactive layers
         this.readjust_subtask_opacities();
+        this.update_edit_lock_display();
 
         // Redraw demo
         this.redraw_demo();
@@ -1982,9 +2132,7 @@ export class ULabel {
 
         // Replacing the pies dropped their hover listeners; re-add
         $("#" + idd_id + ", #" + idd_id_front).on("mousemove.ulabel", (mouse_event) => {
-            if (!this.get_current_subtask()["state"]["idd_thumbnail"]) {
-                this.handle_id_dialog_hover(mouse_event);
-            }
+            this.handle_id_dialog_hover(mouse_event);
         });
     }
 
@@ -2644,18 +2792,7 @@ export class ULabel {
         ctx.stroke();
 
         // Draw the cross of the tbar
-        let halflen = Math.sqrt(
-            (sp[0] - ep[0]) * (sp[0] - ep[0]) + (sp[1] - ep[1]) * (sp[1] - ep[1]),
-        ) / 2;
-        let theta = Math.atan((ep[1] - sp[1]) / (ep[0] - sp[0]));
-        let sb = [
-            sp[0] + halflen * Math.sin(theta),
-            sp[1] - halflen * Math.cos(theta),
-        ];
-        let eb = [
-            sp[0] - halflen * Math.sin(theta),
-            sp[1] + halflen * Math.cos(theta),
-        ];
+        const [sb, eb] = GeometricUtils.tbar_cross_segment(sp, ep);
 
         ctx.lineCap = "square";
         ctx.beginPath();
@@ -2734,9 +2871,13 @@ export class ULabel {
     }
 
     draw_annotation(annotation_object, offset = null, subtask = null) {
-        // DEBUG left here for refactor reference, but I don't think it's needed moving forward
-        //    there may be a use case for drawing depreacted annotations
-        if (annotation_object["deprecated"]) return;
+        // Deprecated annotations are drawn only under deprecated focus, and never as note rows
+        if (
+            annotation_object["deprecated"] &&
+            (subtask === "demo" || !this.subtasks[subtask]?.["focus_deprecated"] || NONSPATIAL_MODES.includes(annotation_object["spatial_type"]))
+        ) return;
+        // Isolated-out annotations are hidden outright, never dimmed
+        if (is_annotation_isolated_out(this, annotation_object, subtask)) return;
         // Defocused annotations are only drawn by the scratch pass, which dims
         // them as a layer; anything else reaching here would draw at full alpha.
         if (!this.state["drawing_defocused"] && this.is_annotation_defocused(annotation_object, subtask)) return;
@@ -2863,13 +3004,20 @@ export class ULabel {
      */
     draw_context_in_focus_passes(canvas_id, subtask, draw) {
         const context_entry = this.subtasks[subtask]["state"]["annotation_contexts"][canvas_id];
-        const annotation_ids = context_entry["annotation_ids"];
-        if (!this.subtasks[subtask]["focus_active_class"]) {
+        const access = this.subtasks[subtask]["annotations"]["access"];
+        // Isolation hides, so it never enters the dimming pass
+        const annotation_ids = context_entry["annotation_ids"].filter(
+            (annid) => !is_annotation_isolated_out(this, access[annid], subtask),
+        );
+        if (
+            !this.subtasks[subtask]["focus_active_class"] &&
+            !this.subtasks[subtask]["focus_edited"] &&
+            !this.subtasks[subtask]["focus_deprecated"]
+        ) {
             for (const annid of annotation_ids) draw(annid);
             return;
         }
 
-        const access = this.subtasks[subtask]["annotations"]["access"];
         const defocused = [];
         const focused = [];
         for (const annid of annotation_ids) {
@@ -3222,6 +3370,7 @@ export class ULabel {
     }
 
     toggle_brush_mode(mouse_event) {
+        if (this.is_subtask_edit_locked()) return;
         // The brush is only valid in polygon or bitmask mode
         const current_subtask = this.get_current_subtask_key();
         const state = this.subtasks[current_subtask]["state"];
@@ -3264,6 +3413,7 @@ export class ULabel {
     }
 
     toggle_erase_mode(mouse_event) {
+        if (this.is_subtask_edit_locked()) return;
         const current_subtask = this.get_current_subtask();
         // If not in brush mode, turn it on
         if (!current_subtask["state"]["is_in_brush_mode"]) {
@@ -3761,6 +3911,9 @@ export class ULabel {
         }
 
         // Record the delete annotation
+        const affected = [...deprecated_ids, ...Object.keys(modified_annotations)].map(
+            (annid) => ({ annotation_id: annid, subtask_key: current_subtask_key }),
+        );
         record_action(this, {
             act_type: "delete_annotations_in_polygon",
             annotation_id: delete_annid,
@@ -3773,6 +3926,7 @@ export class ULabel {
             redo_payload: {
                 delete_polygon: delete_polygon,
             },
+            affected: affected,
         }, redoing);
 
         if (!redoing) {
@@ -3794,6 +3948,8 @@ export class ULabel {
         let annotation_ids_to_redraw = [];
         let polyline_was_updated = false;
         for (let annid of undo_payload["deprecated_ids"]) {
+            // A victim may have been removed since (e.g. a moved copy whose move was undone)
+            if (annotations[annid] === undefined) continue;
             if (!polyline_was_updated && annotations[annid].spatial_type === "polyline") {
                 polyline_was_updated = true;
             }
@@ -3804,6 +3960,7 @@ export class ULabel {
         }
         // Loop through all modified annotations
         for (let [annid, annotation] of Object.entries(undo_payload["modified_annotations"])) {
+            if (annotations[annid] === undefined) continue;
             if (!polyline_was_updated && annotation.spatial_type === "polyline") {
                 polyline_was_updated = true;
             }
@@ -3836,6 +3993,11 @@ export class ULabel {
     // Remove an annotation from access and ordering
     remove_annotation_from_access_and_ordering(annotation_id) {
         const current_subtask = this.get_current_subtask();
+        // Undoing a creation bypasses delete_annotation; the isolation must
+        // not outlive its target
+        if (current_subtask["state"]["isolated_annid"] === annotation_id) {
+            this.isolate_annotation(null);
+        }
         if (annotation_id in current_subtask["annotations"]["access"]) {
             // Remove the annotation from access
             delete current_subtask["annotations"]["access"][annotation_id];
@@ -3844,19 +4006,27 @@ export class ULabel {
         }
     }
 
-    // Remove all recorded events associated with a specific annotation id
-    remove_recorded_events_for_annotation(annotation_id) {
-        // filter action stream
-        let new_action_stream = [];
-        for (let action of this.get_current_subtask()["actions"]["stream"]) {
-            if (
-                action.annotation_id !== annotation_id ||
-                action.act_type === "delete_annotations_in_polygon"
-            ) {
-                new_action_stream.push(action);
-            }
+    // Clear a subtask's isolation when its target has just been deprecated
+    // by a path that bypasses delete_annotation (bitmask strokes, undo/redo)
+    release_isolation_if_deprecated(annotation_id, subtask_key = null) {
+        subtask_key = subtask_key ?? this.get_current_subtask_key();
+        const subtask = this.subtasks[subtask_key];
+        if (subtask["state"]["isolated_annid"] !== annotation_id) return;
+        const annotation = subtask["annotations"]["access"][annotation_id];
+        if (annotation === undefined || (annotation["deprecated"] && !subtask["focus_deprecated"])) {
+            this.isolate_annotation(null, subtask_key);
         }
-        this.get_current_subtask()["actions"]["stream"] = new_action_stream;
+    }
+
+    // Remove all recorded events associated with a specific annotation id
+    // Forget every recorded action about an annotation that no longer exists in
+    // a subtask (default: the current one). Delete-polygon actions survive since
+    // they cover many annotations; their payloads skip missing ids on undo.
+    remove_recorded_events_for_annotation(annotation_id, subtask_key = null) {
+        const actions = this.subtasks[subtask_key ?? this.get_current_subtask_key()]["actions"];
+        const keep = (action) => action.annotation_id !== annotation_id || action.act_type === "delete_annotations_in_polygon";
+        actions["stream"] = actions["stream"].filter(keep);
+        actions["undone_stack"] = actions["undone_stack"].filter(keep);
     }
 
     /**
@@ -3887,8 +4057,8 @@ export class ULabel {
 
     // Edit suggestion: highlight a point in an annotation that can be edited
     show_edit_suggestion(edit_suggestion, currently_exists = false) {
-        // Vertex edit handle is a mutation affordance; skip it in read-only subtasks.
-        if (this.is_current_subtask_read_only()) return;
+        // Vertex edit handle is a mutation affordance; skip it in edit-locked subtasks.
+        if (this.is_subtask_edit_locked()) return;
         let esid = "edit_suggestion__" + this.get_current_subtask_key();
         var esjq = $("#" + esid);
         esjq.css("display", "block");
@@ -3948,6 +4118,9 @@ export class ULabel {
 
     // Global edit suggestion: id dialog, move button, and delete button
     show_global_edit_suggestion(annid, offset = null, nonspatial_id = null) {
+        // Nonspatial annotations have no outline or confidence card on the canvas
+        if (nonspatial_id !== null) return;
+
         const subtask_key = this.get_current_subtask_key();
         const current_subtask = this.subtasks[subtask_key];
 
@@ -3958,98 +4131,80 @@ export class ULabel {
             diffY = offset["diffY"];
         }
 
-        let idd_x;
-        let idd_y;
-        const is_read_only = this.is_current_subtask_read_only();
-        // With fewer than two compatible classes there is nothing to reassign
-        // to, so the reid button and the pie thumbnail don't apply (the same
-        // treatment single_class_mode gives every annotation)
-        const can_reassign = this._get_compatible_class_ids(
-            current_subtask["annotations"]["access"][annid],
-        ).length > 1;
-        if (nonspatial_id === null) {
-            let esid = "global_edit_suggestion__" + subtask_key;
-            var esjq = $("#" + esid);
-            esjq.css("display", "block");
-            // Collapse to the compact single-class ring when there is nothing to
-            // reassign to: `mcm` carries the wide 3-slot width and scale, and the
-            // reid button drops out of flow so move/delete close the gap.
-            esjq.toggleClass("mcm", !current_subtask["single_class_mode"] && can_reassign);
-            esjq.find("a.reid_suggestion").css("display", can_reassign ? "" : "none");
-            // Hide the move/reid/delete buttons on read-only subtasks; use visibility rather than
-            // display so the button ring geometry stays measurable for the dialogs around it.
-            esjq.find(".global_sub_suggestion").css("visibility", is_read_only ? "hidden" : "");
-            let cbox = current_subtask["annotations"]["access"][annid]["containing_box"];
-            let new_lft = (cbox["tlx"] + cbox["brx"] + 2 * diffX) / (2 * this.config["image_width"]);
-            let new_top = (cbox["tly"] + cbox["bry"] + 2 * diffY) / (2 * this.config["image_height"]);
-            current_subtask["state"]["visible_dialogs"][esid]["left"] = new_lft;
-            current_subtask["state"]["visible_dialogs"][esid]["top"] = new_top;
-            // Decide confidence card position from the un-offset cbox so it stays stable during moves.
-            // Account for annbox scroll: what matters is the visible position, not the image-space position.
-            const scroll_top = $("#" + this.config["annbox_id"]).scrollTop() || 0;
-            const conf_id = `global_annotation_confidence__${subtask_key}`;
-            const conf_jq = $(`#${conf_id}`);
-            // The dialog container is CSS-scaled about the anchor, so offsets set
-            // here land `scale` times as far; the cbox measurements are in screen px.
-            const es_el = esjq[0];
-            const scale = es_el.offsetWidth > 0 ?
-                es_el.getBoundingClientRect().width / es_el.offsetWidth :
-                1;
-            const card_height = conf_jq.outerHeight() || 0;
-            const gap = 10;
-            // The buttons ring the anchor (box centre) via translateY(-50%); hug the
-            // ring by clearing half a button's height (local units) plus the gap.
-            // The card is positioned absolutely against the 0-height anchor container:
-            // deriving the position from the card's own layout (offsetTop) feeds
-            // integer rounding back into the next mousemove and makes the card jitter.
-            const ring_clearance = (esjq.find("a.global_sub_suggestion").outerHeight() || 60) / 2 + gap / scale;
-            const anchor_visible = ((cbox["tly"] + cbox["bry"]) / 2 * this.state["zoom_val"]) - scroll_top;
-            const card_top_visible = anchor_visible - (ring_clearance + card_height) * scale;
-            const flip_below = card_top_visible < 0;
-            conf_jq.css(
-                flip_below ?
-                        { top: `${ring_clearance}px`, bottom: "auto" } :
-                        { top: "auto", bottom: `${ring_clearance}px` },
+        const esid = "global_edit_suggestion__" + subtask_key;
+        const esjq = $("#" + esid);
+        esjq.css("display", "block");
+        const cbox = current_subtask["annotations"]["access"][annid]["containing_box"];
+        const new_lft = (cbox["tlx"] + cbox["brx"] + 2 * diffX) / (2 * this.config["image_width"]);
+        const new_top = (cbox["tly"] + cbox["bry"] + 2 * diffY) / (2 * this.config["image_height"]);
+        current_subtask["state"]["visible_dialogs"][esid]["left"] = new_lft;
+        current_subtask["state"]["visible_dialogs"][esid]["top"] = new_top;
+        // Decide confidence card position from the un-offset cbox so it stays stable during moves.
+        // Account for annbox scroll: what matters is the visible position, not the image-space position.
+        const annbox_jq = $("#" + this.config["annbox_id"]);
+        const scroll_top = annbox_jq.scrollTop() || 0;
+        const conf_id = `global_annotation_confidence__${subtask_key}`;
+        const conf_jq = $(`#${conf_id}`);
+        // The dialog container is CSS-scaled about the anchor, so offsets set
+        // here land `scale` times as far; the cbox measurements are in screen px.
+        const es_el = esjq[0];
+        const scale = es_el.offsetWidth > 0 ?
+            es_el.getBoundingClientRect().width / es_el.offsetWidth :
+            1;
+        const card_height = conf_jq.outerHeight() || 0;
+        const gap = 10;
+        // The anchor is the box centre; hug the box by clearing half its on-screen
+        // height plus the gap, converted to the container's local units.
+        // The card is positioned absolutely against the 0-height anchor container:
+        // deriving the position from the card's own layout (offsetTop) feeds
+        // integer rounding back into the next mousemove and makes the card jitter.
+        const box_clearance = ((cbox["bry"] - cbox["tly"]) / 2 * this.state["zoom_val"] + gap) / scale;
+        const anchor_visible = ((cbox["tly"] + cbox["bry"]) / 2 * this.state["zoom_val"]) - scroll_top;
+        const card_top_visible = anchor_visible - (box_clearance + card_height) * scale;
+        const flip_below = card_top_visible < 0;
+        conf_jq.css(
+            flip_below ?
+                    { top: `${box_clearance}px`, bottom: "auto" } :
+                    { top: "auto", bottom: `${box_clearance}px` },
+        );
+        this.reposition_dialogs();
+        if (annbox_jq.length && conf_jq.length) {
+            const annbox_el = annbox_jq[0];
+            const visible_left = annbox_el.getBoundingClientRect().left + annbox_el.clientLeft;
+            const visible_right = visible_left + annbox_el.clientWidth;
+            const anchor_rect = es_el.getBoundingClientRect();
+            const anchor_x = anchor_rect.left + anchor_rect.width / 2;
+            const card_half_width = (conf_jq.outerWidth() || 0) * scale / 2;
+            const card_center = Math.max(
+                visible_left + gap + card_half_width,
+                Math.min(anchor_x, visible_right - gap - card_half_width),
             );
-            this.reposition_dialogs();
-            idd_x = (cbox["tlx"] + cbox["brx"] + 2 * diffX) / 2;
-            idd_y = (cbox["tly"] + cbox["bry"] + 2 * diffY) / 2;
-            this.set_hovered_annotation(annid);
-        } else {
-            // TODO(new3d)
-            idd_x = $("#reclf__" + nonspatial_id).offset().left - 85;// this.get_global_element_center_x($("#reclf__" + nonspatial_id));
-            idd_y = $("#reclf__" + nonspatial_id).offset().top - 85;// this.get_global_element_center_y($("#reclf__" + nonspatial_id));
-        }
-
-        // let placeholder = $("#global_edit_suggestion a.reid_suggestion");
-        if (!current_subtask["single_class_mode"] && !is_read_only && can_reassign) {
-            // Show id dialog thumbnail
-            this.show_id_dialog(idd_x, idd_y, annid, true, nonspatial_id != null);
-        } else {
-            // can_reassign varies per annotation, so a thumbnail shown for the
-            // previously hovered annotation must not linger over this one
-            this.hide_id_dialog();
+            conf_jq.css("transform", `translateX(calc(-50% + ${(card_center - anchor_x) / scale}px))`);
         }
+        this.set_hovered_annotation(annid);
     }
 
     hide_global_edit_suggestion() {
         $(".global_edit_suggestion").css("display", "none");
-        this.hide_id_dialog();
         this.set_hovered_annotation(null);
     }
 
     /**
-     * Class ids in the current subtask that can take an annotation's spatial
+     * Class ids in a subtask that can take an annotation's spatial
      * type. A null annotation places no restriction.
+     *
+     * @param {object|null} annotation
+     * @param {string|null} subtask_key defaults to the current subtask
      */
-    _get_compatible_class_ids(annotation = null) {
-        const class_ids = this.get_current_subtask()["class_ids"];
+    _get_compatible_class_ids(annotation = null, subtask_key = null) {
+        subtask_key ??= this.get_current_subtask_key();
+        const class_ids = this.subtasks[subtask_key]["class_ids"];
         if (annotation == null) return class_ids;
-        return class_ids.filter((class_id) => can_annotation_be_class(this, annotation, class_id));
+        return class_ids.filter((class_id) => can_annotation_be_class(this, annotation, class_id, subtask_key));
     }
 
     // ID dialog: color wheel to change the ID of an annotation
-    show_id_dialog(gbx, gby, active_ann, thumbnail = false, nonspatial = false) {
+    show_id_dialog(gbx, gby, active_ann, nonspatial = false) {
         let stkey = this.get_current_subtask_key();
 
         // Only offer classes that can take this annotation's spatial type. With
@@ -4073,19 +4228,16 @@ export class ULabel {
         // TODO
         // am_dialog_associated_ann = active_ann;
         this.get_current_subtask()["state"]["idd_visible"] = true;
-        this.get_current_subtask()["state"]["idd_thumbnail"] = thumbnail;
         this.get_current_subtask()["state"]["idd_associated_annotation"] = active_ann;
         this.get_current_subtask()["state"]["idd_which"] = "back";
 
         let idd_id = this.get_current_subtask()["state"]["idd_id"];
         let idd_niu_id = this.get_current_subtask()["state"]["idd_id_front"];
-        let new_height = $(`#global_edit_suggestion__${stkey} a.reid_suggestion`)[0].getBoundingClientRect().height;
 
         if (nonspatial) {
             this.get_current_subtask()["state"]["idd_which"] = "front";
             idd_id = this.get_current_subtask()["state"]["idd_id_front"];
             idd_niu_id = this.get_current_subtask()["state"]["idd_id"];
-            new_height = 28;
         } else {
             // Add this id to the list of dialogs with managed positions
             // TODO actually only do this when calling append()
@@ -4100,14 +4252,11 @@ export class ULabel {
         if (nonspatial) {
             let new_home = $(`#reclf__${active_ann}`);
             let fad_st = $(`#fad_st__${stkey} div.front_dialogs`);
-            let ofst = -100;
-            let zidx = 2000;
-            if (thumbnail) {
-                zidx = -1;
-                // ofst = -100;
-            }
-            let top_c = new_home.offset().top - fad_st.offset().top + ofst + new_height / 2;
-            let left_c = new_home.offset().left - fad_st.offset().left + ofst + 1 + new_height / 2;
+            // Centre the pie over the reclf button (28px tall)
+            const ofst = -100 + 14;
+            const zidx = 2000;
+            let top_c = new_home.offset().top - fad_st.offset().top + ofst;
+            let left_c = new_home.offset().left - fad_st.offset().left + ofst + 1;
             idd.css({
                 "display": "block",
                 "position": "absolute",
@@ -4120,24 +4269,6 @@ export class ULabel {
             });
         }
 
-        // Add or remove thumbnail class if necessary
-        let scale_ratio = new_height / this.config["outer_diameter"];
-        if (thumbnail) {
-            if (!idd.hasClass("thumb")) {
-                idd.addClass("thumb");
-            }
-            $("#" + idd_id + ".thumb").css({
-                transform: `scale(${scale_ratio})`,
-            });
-        } else {
-            $("#" + idd_id + ".thumb").css({
-                transform: `scale(1.0)`,
-            });
-            if (idd.hasClass("thumb")) {
-                idd.removeClass("thumb");
-            }
-        }
-
         this.reposition_dialogs();
 
         // Configure the dialog to show the current information for this ann
@@ -4178,17 +4309,57 @@ export class ULabel {
     // ================= Annotation Utilities =================
 
     /**
-     * Undo the last action.
+     * Undo the last action. From a read-only subtask, undoes on the sole writable subtask
+     * if that action was triggered from the read-only subtask.
      */
     undo() {
-        undo(this);
+        this.run_on_edit_subtask("stream", () => undo(this));
     }
 
     /**
-     * Redo the last undone action.
+     * Redo the last undone action. From a read-only subtask, redoes on the sole writable subtask
+     * if that action was triggered from the read-only subtask.
      */
     redo() {
-        redo(this);
+        this.run_on_edit_subtask("undone_stack", () => redo(this));
+    }
+
+    /**
+     * Run an undo/redo on the sole writable subtask when the current one is read-only and the
+     * action on top of `stack` was triggered from it: switching to the writable subtask if
+     * `paste_switch_to_target` is set, otherwise in place.
+     *
+     * @param {"stream" | "undone_stack"} stack the stack the operation pops
+     * @param {() => void} fn the undo/redo
+     */
+    run_on_edit_subtask(stack, fn) {
+        const writable = Object.keys(this.subtasks).filter((key) => this.subtasks[key].read_only !== true);
+        if (!this.is_current_subtask_read_only() || writable.length !== 1) return fn();
+        const current_key = this.get_current_subtask_key();
+        const edit_key = writable[0];
+        const actions = this.subtasks[edit_key].actions[stack];
+        if (actions.length === 0) return;
+        const origin_key = actions[actions.length - 1].origin_subtask_key ?? null;
+        if (origin_key !== current_key) {
+            this.config.on_undo_redo_blocked?.(stack === "stream" ? "undo" : "redo", edit_key, current_key, origin_key);
+            return;
+        }
+        this.state["undo_redo_from_subtask"] = current_key;
+        try {
+            if (this.config["paste_switch_to_target"]) {
+                this.set_subtask(edit_key);
+                return fn();
+            }
+            this.state["current_subtask"] = edit_key;
+            try {
+                fn();
+            } finally {
+                this.state["current_subtask"] = current_key;
+                this.toolbox.redraw_update_items(this);
+            }
+        } finally {
+            this.state["undo_redo_from_subtask"] = null;
+        }
     }
 
     /**
@@ -4206,6 +4377,8 @@ export class ULabel {
         if (this.is_subtask_hidden()) {
             return;
         }
+        // A new annotation would be hidden by an active isolation
+        this.isolate_annotation(null);
 
         const annotation_access = current_subtask["annotations"]["access"];
         const annotation_ordering = current_subtask["annotations"]["ordering"];
@@ -4298,79 +4471,889 @@ export class ULabel {
         );
     }
 
-    create_point_annotation_at_mouse_location() {
-        const last_move = this.state["last_move"];
-        if (last_move !== null) {
-            const spatial_payload = this.get_image_aware_mouse_x_y(last_move);
-            // Create a point annotation at the mouse position
-            this.create_annotation("point", [spatial_payload]);
-        }
+    /**
+     * Whether an annotation can be pasted into a subtask: it is spatial, the
+     * subtask is not read-only, and at least one of its classes allows the
+     * annotation's spatial type.
+     *
+     * @param {object} annotation
+     * @param {string} subtask_key
+     * @returns {boolean}
+     */
+    can_paste_into_subtask(annotation, subtask_key) {
+        const subtask = this.subtasks[subtask_key];
+        if (subtask === undefined || subtask["read_only"] === true) return false;
+        if (annotation == null) return false;
+        const spatial_type = annotation["spatial_type"];
+        if (NONSPATIAL_MODES.includes(spatial_type) || DELETE_MODES.includes(spatial_type)) return false;
+        return this._get_compatible_class_ids(annotation, subtask_key).length > 0;
     }
 
-    delete_annotation(annotation_id, redoing = false, should_record_action = true) {
-        // Grab constants for convenience
-        const current_subtask = this.get_current_subtask();
-        const annotations = current_subtask["annotations"]["access"];
-        const spatial_type = annotations[annotation_id]["spatial_type"];
-
-        // Deprecate the annotation and redraw it
-        mark_deprecated(annotations[annotation_id], true);
-
-        if (current_subtask["state"]["active_id"] !== null) {
-            current_subtask["state"]["active_id"] = null;
-            current_subtask["state"]["is_in_edit"] = false;
-            current_subtask["state"]["is_in_move"] = false;
-            current_subtask["state"]["is_in_progress"] = false;
-            current_subtask["state"]["starting_complex_polygon"] = false;
-        }
-
-        // Clear drag state if we're in the middle of a drag
-        if (this.drag_state["active_key"] !== null) {
-            this.drag_state["active_key"] = null;
-            this.drag_state["release_button"] = null;
-        }
-
-        // Clear edit candidate
-        current_subtask["state"]["edit_candidate"] = null;
-
-        let frame = this.state["current_frame"];
-        if (MODES_3D.includes(spatial_type)) {
-            frame = null;
-        }
-
-        record_action(this, {
-            act_type: "delete_annotation",
-            annotation_id: annotation_id,
-            frame: frame,
-            undo_payload: {},
-            redo_payload: {},
-        }, redoing, should_record_action);
+    /**
+     * Keys of the other subtasks an annotation can be copied into.
+     *
+     * @param {object} annotation
+     * @param {string|null} source_key subtask the annotation lives in; defaults to the current subtask
+     * @returns {string[]}
+     */
+    get_copy_target_subtask_keys(annotation, source_key = null) {
+        source_key ??= this.get_current_subtask_key();
+        return Object.keys(this.subtasks).filter(
+            (key) => key !== source_key && this.can_paste_into_subtask(annotation, key),
+        );
     }
 
-    delete_annotation__undo(annotation_id) {
-        // Set the annotation to be undeprecated and redraw it
-        mark_deprecated(this.get_current_subtask()["annotations"]["access"][annotation_id], false);
+    /**
+     * Compatible class in the target that matches the source class by id, or
+     * failing that by name. Null when the source class has no counterpart.
+     *
+     * @param {object} annotation
+     * @param {string} target_key
+     * @param {string|null} source_class_name name of the source class, if known
+     * @returns {number|null}
+     */
+    match_paste_class_id(annotation, target_key, source_class_name = null) {
+        const compatible = this._get_compatible_class_ids(annotation, target_key);
+        const source_class_id = Number(get_annotation_class_id(annotation));
+        if (compatible.includes(source_class_id)) return source_class_id;
+        if (source_class_name == null) return null;
+        const by_name = this.subtasks[target_key]["class_defs"].find(
+            (def) => def["name"] === source_class_name && compatible.includes(def["id"]),
+        );
+        return by_name == null ? null : by_name["id"];
     }
 
-    delete_annotation__redo(annotation_id) {
-        this.delete_annotation(annotation_id, true);
+    /**
+     * Class for a pasted annotation: the source class when the target has it
+     * (by id, else by name), else the target's active class, else the first
+     * compatible class.
+     *
+     * @param {object} annotation
+     * @param {string} target_key
+     * @param {string|null} source_class_name name of the source class, if known
+     * @returns {number|null} null when no class in the target fits
+     */
+    resolve_paste_class_id(annotation, target_key, source_class_name = null) {
+        const compatible = this._get_compatible_class_ids(annotation, target_key);
+        if (compatible.length === 0) return null;
+        const matched = this.match_paste_class_id(annotation, target_key, source_class_name);
+        if (matched !== null) return matched;
+        const active_class_id = get_active_class_id(this, target_key);
+        if (active_class_id !== undefined && compatible.includes(active_class_id)) return active_class_id;
+        return compatible[0];
     }
 
     /**
-     * Delete a vertex from a polygon or polyline annotation
-     * @param {string} annotation_id - The ID of the annotation
-     * @param {string|array} access_str - Access string identifying the vertex to delete
-     * @param {boolean} redoing - Whether this is a redo operation
-     * @param {boolean} should_record_action - Whether to record this action in the action stream
+     * Name of a class in a subtask, or null when the subtask has no such class.
+     *
+     * @param {number} class_id
+     * @param {string} subtask_key
+     * @returns {string|null}
      */
-    delete_vertex(annotation_id, access_str, redoing = false, should_record_action = true) {
-        const current_subtask = this.get_current_subtask();
-        const annotation = current_subtask["annotations"]["access"][annotation_id];
-        const spatial_type = annotation["spatial_type"];
+    get_class_name(class_id, subtask_key) {
+        const class_def = this.subtasks[subtask_key]?.["class_defs"].find((def) => def["id"] === class_id);
+        return class_def?.["name"] ?? null;
+    }
 
-        // Only allow vertex deletion for polygons and polylines
-        if (spatial_type !== "polygon" && spatial_type !== "polyline") {
-            return;
+    /**
+     * Insert a copy of an annotation into a subtask. The copy gets a fresh id,
+     * fresh stamps, no deprecation and a class payload for `class_id`; every
+     * other field carries over, except the `config.annotation_link_meta_key`
+     * entry of `annotation_meta`. Records a `paste_annotation` action on the
+     * target subtask's stream.
+     *
+     * @param {object} annotation source annotation (from any subtask or a clipboard payload)
+     * @param {string} target_key subtask to paste into
+     * @param {number|null} class_id class for the copy; null resolves via `resolve_paste_class_id`
+     * @param {[number, number]} offset image-space shift applied to the copy
+     * @param {boolean} record record a `paste_annotation` action on the target stream
+     * @param {string|null} source_key when given, stamped as `annotation_meta.copied_from`
+     * @returns {string|null} id of the new annotation, or null when nothing was pasted
+     */
+    paste_annotation(annotation, target_key, class_id = null, offset = [0, 0], record = true, source_key = null) {
+        if (!this.can_paste_into_subtask(annotation, target_key)) {
+            log_message(`Cannot paste a ${annotation?.["spatial_type"]} annotation into subtask ${target_key}`, LogLevel.WARNING, true);
+            return null;
+        }
+        class_id ??= this.resolve_paste_class_id(annotation, target_key);
+        if (!this._get_compatible_class_ids(annotation, target_key).includes(class_id)) {
+            log_message(`Class ${class_id} in subtask ${target_key} cannot take a ${annotation["spatial_type"]} annotation`, LogLevel.WARNING, true);
+            return null;
+        }
+
+        const copy = JSON.parse(JSON.stringify(annotation));
+        // Bitmask payloads may be raw arrays or stale; re-encode from the decoded mask
+        if (copy["spatial_type"] === "bitmask") {
+            copy["spatial_payload"] = this.get_bitmask(annotation).to_rle();
+        }
+        const now = ULabel.get_time();
+        delete copy["edit_type"];
+        copy["id"] = this.make_new_annotation_id();
+        copy["created_by"] = this.config.username;
+        copy["created_at"] = now;
+        copy["last_edited_by"] = this.config.username;
+        copy["last_edited_at"] = now;
+        copy["deprecated"] = false;
+        copy["deprecated_by"] = { human: false };
+        const link_key = this.config["annotation_link_meta_key"];
+        if (link_key != null && typeof copy["annotation_meta"] === "object" && copy["annotation_meta"] !== null) {
+            delete copy["annotation_meta"][link_key];
+        }
+        if (source_key !== null) {
+            // Per-subtask annotation_meta may be a string; only an object can carry the stamp
+            const meta = typeof copy["annotation_meta"] === "object" && copy["annotation_meta"] !== null ? copy["annotation_meta"] : {};
+            copy["annotation_meta"] = { ...meta, copied_from: { subtask_key: source_key, annotation_id: annotation["id"] } };
+        }
+        copy["classification_payloads"] = this.subtasks[target_key]["class_ids"].map((cid) => ({
+            class_id: cid,
+            confidence: cid === class_id ? 1.0 : 0.0,
+        }));
+
+        let new_annotation = ULabelAnnotation.from_json(copy);
+        if (new_annotation === null) {
+            log_message("Cannot paste an annotation with an incompatible spatial payload", LogLevel.WARNING, true);
+            return null;
+        }
+        const [dx, dy] = offset;
+        if (dx !== 0 || dy !== 0) {
+            const spatial_type = new_annotation["spatial_type"];
+            if (spatial_type === "bitmask") {
+                this.translate_bitmask(new_annotation, dx, dy);
+            } else {
+                // The JSON round trip broke any shared closing-point reference, so every point shifts once
+                let layers = [new_annotation["spatial_payload"]];
+                if (spatial_type === "polygon") {
+                    layers = new_annotation["spatial_payload"];
+                }
+                for (const layer of layers) {
+                    for (const point of layer) {
+                        point[0] += dx;
+                        point[1] += dy;
+                    }
+                }
+            }
+        }
+        if (!this.config.allow_annotations_outside_image) {
+            new_annotation = new_annotation.clamp_annotation_to_image_bounds(this.config["image_width"], this.config["image_height"]);
+        }
+        this._insert_pasted_annotation(new_annotation, target_key, false, record);
+        return new_annotation["id"];
+    }
+
+    /**
+     * Add an already-prepared pasted annotation to a subtask. Shared by
+     * `paste_annotation`, its redo, and `move_annotation`'s redo.
+     *
+     * @param {object} annotation_json annotation with its final id, class and geometry
+     * @param {string} target_key
+     * @param {boolean} is_redo
+     * @param {boolean} record record a `paste_annotation` action on the target stream
+     */
+    _insert_pasted_annotation(annotation_json, target_key, is_redo, record = true) {
+        const target = this.subtasks[target_key];
+        // A new annotation would be hidden by an active isolation
+        this.isolate_annotation(null, target_key);
+        const annotation = ULabelAnnotation.from_json(annotation_json);
+        const annotation_id = annotation["id"];
+        annotation["canvas_id"] = this.get_init_canvas_context_id(annotation_id, target_key);
+        target["annotations"]["access"][annotation_id] = annotation;
+        target["annotations"]["ordering"].push(annotation_id);
+        this.rebuild_containing_box(annotation_id, false, target_key);
+
+        if (record) {
+            let frame = this.state["current_frame"];
+            if (MODES_3D.includes(annotation["spatial_type"])) {
+                frame = null;
+            }
+            record_action(this, {
+                act_type: "paste_annotation",
+                annotation_id: annotation_id,
+                frame: frame,
+                undo_payload: {},
+                redo_payload: { annotation: annotation },
+            }, is_redo, true, target_key);
+        }
+
+        // No action listener: the target may not be the current subtask
+        this.redraw_annotation(annotation_id, target_key);
+        this.toolbox.redraw_update_items(this);
+    }
+
+    /**
+     * Drop a pasted annotation from a subtask entirely (it never existed
+     * before the paste, so there is nothing to deprecate).
+     *
+     * @param {string} annotation_id
+     * @param {string} subtask_key
+     */
+    _remove_pasted_annotation(annotation_id, subtask_key) {
+        const subtask = this.subtasks[subtask_key];
+        if (!(annotation_id in subtask["annotations"]["access"])) return;
+        if (subtask["state"]["isolated_annid"] === annotation_id) {
+            this.isolate_annotation(null, subtask_key);
+        }
+        this.destroy_annotation_context(annotation_id, subtask_key);
+        delete subtask["annotations"]["access"][annotation_id];
+        subtask["annotations"]["ordering"] = subtask["annotations"]["ordering"].filter((value) => value !== annotation_id);
+    }
+
+    /**
+     * Drop a moved copy from its subtask along with everything that subtask
+     * recorded about it. A copy that was itself moved on is followed first
+     * so no orphaned duplicate outlives the move being undone.
+     *
+     * @param {string} copy_id
+     * @param {string} subtask_key
+     */
+    _discard_moved_copy(copy_id, subtask_key) {
+        for (const action of this.subtasks[subtask_key]["actions"]["stream"]) {
+            if (action.act_type === "move_annotation" && action.annotation_id === copy_id) {
+                const payload = JSON.parse(action.undo_payload);
+                this._discard_moved_copy(payload.copy_id, payload.target_subtask_key);
+            }
+        }
+        this._remove_pasted_annotation(copy_id, subtask_key);
+        this.remove_recorded_events_for_annotation(copy_id, subtask_key);
+    }
+
+    /**
+     * Undo a paste: remove the copy from the current subtask.
+     *
+     * @param {string} annotation_id
+     */
+    paste_annotation__undo(annotation_id) {
+        this._remove_pasted_annotation(annotation_id, this.get_current_subtask_key());
+    }
+
+    /**
+     * Redo a paste: re-add the stored copy to the current subtask.
+     *
+     * @param {string} annotation_id
+     * @param {object} redo_payload `{ annotation }` as recorded by the paste
+     */
+    paste_annotation__redo(annotation_id, redo_payload) {
+        this._insert_pasted_annotation(redo_payload.annotation, this.get_current_subtask_key(), true);
+    }
+
+    /**
+     * Copy an annotation from one subtask into another at the same image
+     * coordinates. Cut turns the copy into a move: the source, which must live
+     * in the current, writable subtask, is deleted and the whole move is one
+     * undoable `move_annotation` action on the source's stream (nothing is
+     * recorded on the target). When `choose_class` is set, no class was given
+     * and the source class has no counterpart in the target (by id or name)
+     * that could be chosen from several, the target becomes the current
+     * subtask and the class pie opens on the copy (unless
+     * `config.paste_class_choice` is off). `config.paste_switch_to_target`
+     * makes the target current after any successful copy.
+     *
+     * @param {string} annotation_id
+     * @param {string} source_key subtask the annotation lives in
+     * @param {string} target_key subtask to copy into
+     * @param {number|null} class_id class for the copy; null resolves via `resolve_paste_class_id`
+     * @param {boolean} cut delete the source afterwards
+     * @param {boolean} choose_class open the class pie when the class is ambiguous
+     * @param {[number, number]} offset image-space shift applied to the copy
+     * @returns {string|null} id of the copy
+     */
+    copy_annotation_to_subtask(annotation_id, source_key, target_key, class_id = null, cut = false, choose_class = false, offset = [0, 0]) {
+        const annotation = this.subtasks[source_key]?.["annotations"]["access"][annotation_id];
+        if (annotation == null) {
+            log_message(`Annotation ${annotation_id} not found in subtask ${source_key}`, LogLevel.WARNING, true);
+            return null;
+        }
+        let move = cut;
+        if (cut && (source_key !== this.get_current_subtask_key() || this.is_current_subtask_read_only())) {
+            log_message("Cut only removes annotations from the current, writable subtask; copied instead", LogLevel.WARNING, true);
+            move = false;
+        }
+        let offer_choice = false;
+        if (class_id === null && this.can_paste_into_subtask(annotation, target_key)) {
+            const source_class_name = this.get_class_name(Number(get_annotation_class_id(annotation)), source_key);
+            const matched = this.match_paste_class_id(annotation, target_key, source_class_name);
+            offer_choice = choose_class && this.config["paste_class_choice"] && matched === null;
+            class_id = this.resolve_paste_class_id(annotation, target_key, source_class_name);
+        }
+        const new_id = this.paste_annotation(annotation, target_key, class_id, offset, !move, source_key);
+        if (new_id === null) return null;
+
+        if (move) {
+            this._record_move_annotation(annotation_id, target_key, new_id, false);
+        }
+
+        if (this.config["paste_switch_to_target"] && target_key !== this.get_current_subtask_key()) {
+            this.set_subtask(target_key);
+        }
+        if (offer_choice) {
+            this._offer_pasted_class_choice(new_id, target_key);
+        }
+        return new_id;
+    }
+
+    /**
+     * Find an annotation in `target_key` that was pasted from
+     * `annotation_id` in `source_key` (via `annotation_meta.copied_from`) and
+     * has not been deleted by a human (filter-hidden copies count).
+     *
+     * @param {string} annotation_id source annotation
+     * @param {string} source_key subtask the source lives in
+     * @param {string} target_key subtask to search
+     * @returns {string|null} id of the copy, or null when there is none
+     */
+    find_pasted_copy(annotation_id, source_key, target_key) {
+        const target = this.subtasks[target_key];
+        if (target == null) return null;
+        for (const copy_id of target["annotations"]["ordering"]) {
+            const copy = target["annotations"]["access"][copy_id];
+            // Filter-hidden copies still count; only a human deletion clears the guard
+            if (copy["deprecated_by"]?.["human"]) continue;
+            const from = copy["annotation_meta"]?.["copied_from"];
+            if (from?.["subtask_key"] === source_key && from?.["annotation_id"] === annotation_id) {
+                return copy_id;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Spatial annotations in `target_key` linked to `annotation_id` in
+     * `source_key`: its copies, the annotation it was copied from, and those
+     * sharing a value under `config.annotation_link_meta_key`. Human-deleted
+     * annotations are skipped; filter-hidden ones count.
+     *
+     * @param {string} annotation_id
+     * @param {string} source_key subtask the annotation lives in
+     * @param {string} target_key subtask to search
+     * @returns {string[]}
+     */
+    find_counterparts(annotation_id, source_key, target_key) {
+        const source = this.subtasks[source_key]?.["annotations"]["access"][annotation_id];
+        const target = this.subtasks[target_key];
+        if (source == null || target == null || source_key === target_key) return [];
+        const link_values = new Set(this._get_link_values(source));
+        const source_from = source["annotation_meta"]?.["copied_from"];
+        const ids = [];
+        for (const candidate_id of target["annotations"]["ordering"]) {
+            const candidate = target["annotations"]["access"][candidate_id];
+            if (candidate["deprecated_by"]?.["human"]) continue;
+            const spatial_type = candidate["spatial_type"];
+            if (NONSPATIAL_MODES.includes(spatial_type) || DELETE_MODES.includes(spatial_type)) continue;
+            const from = candidate["annotation_meta"]?.["copied_from"];
+            if (
+                (from?.["subtask_key"] === source_key && from?.["annotation_id"] === annotation_id) ||
+                (source_from?.["subtask_key"] === target_key && source_from?.["annotation_id"] === candidate_id) ||
+                this._get_link_values(candidate).some((value) => link_values.has(value))
+            ) {
+                ids.push(candidate_id);
+            }
+        }
+        return ids;
+    }
+
+    // Non-empty strings under `config.annotation_link_meta_key` (a string or string[])
+    _get_link_values(annotation) {
+        const key = this.config["annotation_link_meta_key"];
+        if (key == null) return [];
+        const value = annotation["annotation_meta"]?.[key];
+        return (Array.isArray(value) ? value : [value]).filter((v) => typeof v === "string" && v !== "");
+    }
+
+    /**
+     * Remove an annotation's counterparts (see `find_counterparts`) from a
+     * writable subtask. Erasing (bitmask sources only) subtracts the source
+     * from its bitmask counterparts (a mask erased to nothing is deleted;
+     * other counterparts are left alone); otherwise every counterpart is
+     * deleted. Recorded as one `delete_counterparts` action on the target's stream.
+     * `config.paste_switch_to_target` then switches to the target.
+     *
+     * @param {string} annotation_id
+     * @param {string} source_key subtask the annotation lives in
+     * @param {string} target_key subtask to remove counterparts from
+     * @param {boolean | null} erase default: whether the source is a bitmask
+     * @returns {string[]} ids of the changed counterparts
+     */
+    delete_counterparts(annotation_id, source_key, target_key, erase = null) {
+        const source = this.subtasks[source_key]?.["annotations"]["access"][annotation_id];
+        const target = this.subtasks[target_key];
+        if (source == null || target == null) {
+            log_message(`Annotation ${annotation_id} or subtask ${target_key} not found`, LogLevel.WARNING, true);
+            return [];
+        }
+        if (target["read_only"] === true) {
+            log_message(`Subtask ${target_key} is read-only; nothing removed`, LogLevel.WARNING, true);
+            return [];
+        }
+        const is_bitmask = source["spatial_type"] === "bitmask";
+        erase ??= is_bitmask;
+        if (erase && !is_bitmask) {
+            log_message(`Only a bitmask can be erased from subtask ${target_key}`, LogLevel.WARNING, true);
+            return [];
+        }
+        const source_mask = erase ? this.get_bitmask(source) : null;
+        const before = { masks: {}, deprecated_ids: [] };
+        const after = { masks: {}, deprecated_ids: [] };
+        for (const id of this.find_counterparts(annotation_id, source_key, target_key)) {
+            const counterpart = target["annotations"]["access"][id];
+            if (!erase) {
+                before.deprecated_ids.push(id);
+                continue;
+            }
+            if (counterpart["spatial_type"] !== "bitmask") continue;
+            const current_mask = this.get_bitmask(counterpart);
+            const mask = current_mask.clone();
+            if (!mask.subtract(source_mask)) continue;
+            before.masks[id] = current_mask.to_rle();
+            after.masks[id] = mask.to_rle();
+            if (mask.is_empty()) before.deprecated_ids.push(id);
+        }
+        after.deprecated_ids = before.deprecated_ids;
+        const changed_ids = [...new Set([...Object.keys(after.masks), ...after.deprecated_ids])];
+        if (changed_ids.length === 0) {
+            log_message(`Nothing to remove from subtask ${target_key}`, LogLevel.INFO, true);
+            return [];
+        }
+        this._apply_counterpart_removal(after, target_key, true);
+        this._record_delete_counterparts(annotation_id, target_key, { before, after }, false);
+        if (this.config["paste_switch_to_target"] && target_key !== this.get_current_subtask_key()) {
+            this.set_subtask(target_key);
+        }
+        return changed_ids;
+    }
+
+    _record_delete_counterparts(annotation_id, target_key, payload, is_redo) {
+        const ids = new Set([...Object.keys(payload.after.masks), ...payload.after.deprecated_ids]);
+        record_action(this, {
+            act_type: "delete_counterparts",
+            annotation_id: annotation_id,
+            frame: this.state["current_frame"],
+            undo_payload: payload,
+            redo_payload: payload,
+            affected: [...ids].map((id) => ({ annotation_id: id, subtask_key: target_key })),
+        }, is_redo, true, target_key);
+    }
+
+    // Set masks and deprecation from a `delete_counterparts` payload half, then redraw
+    _apply_counterpart_removal(state, subtask_key, deprecated) {
+        const access = this.subtasks[subtask_key]["annotations"]["access"];
+        const ids = new Set();
+        for (const [id, rle] of Object.entries(state.masks)) {
+            const annotation = access[id];
+            if (annotation === undefined) continue;
+            annotation["spatial_payload"] = rle;
+            this.set_bitmask_from_rle(annotation, rle);
+            this.rebuild_bitmask_containing_box(annotation);
+            ids.add(id);
+        }
+        for (const id of state.deprecated_ids) {
+            if (access[id] === undefined) continue;
+            mark_deprecated(access[id], deprecated);
+            if (deprecated) this.release_isolation_if_deprecated(id, subtask_key);
+            ids.add(id);
+        }
+        this.redraw_multiple_spatial_annotations([...ids], subtask_key);
+        if ([...ids].some((id) => access[id]["spatial_type"] === "polyline")) {
+            this.update_filter_distance(null, false, true);
+        }
+        this.toolbox.redraw_update_items(this);
+    }
+
+    /**
+     * Undo `delete_counterparts`: restore the masks and deletions in the current subtask.
+     *
+     * @param {object} undo_payload `{ before, after }`
+     */
+    delete_counterparts__undo(undo_payload) {
+        this._apply_counterpart_removal(undo_payload.before, this.get_current_subtask_key(), false);
+    }
+
+    /**
+     * Redo `delete_counterparts` in the current subtask.
+     *
+     * @param {string} annotation_id source annotation
+     * @param {object} redo_payload `{ before, after }`
+     */
+    delete_counterparts__redo(annotation_id, redo_payload) {
+        const subtask_key = this.get_current_subtask_key();
+        this._apply_counterpart_removal(redo_payload.after, subtask_key, true);
+        this._record_delete_counterparts(annotation_id, subtask_key, redo_payload, true);
+    }
+
+    /**
+     * Whether a context-menu copy/move/delete-from makes the target the current subtask.
+     * @param {boolean} enabled
+     */
+    set_paste_switch_to_target(enabled) {
+        this.config["paste_switch_to_target"] = Boolean(enabled);
+    }
+
+    /** @returns {boolean} */
+    get_paste_switch_to_target() {
+        return this.config["paste_switch_to_target"];
+    }
+
+    /**
+     * Deprecate the source of a move and record the compound action on the
+     * current (source) subtask's stream. The copy must already be in place.
+     *
+     * @param {string} annotation_id source annotation in the current subtask
+     * @param {string} target_key subtask holding the copy
+     * @param {string} copy_id id of the copy
+     * @param {boolean} is_redo
+     */
+    _record_move_annotation(annotation_id, target_key, copy_id, is_redo) {
+        const spatial_type = this.get_current_subtask()["annotations"]["access"][annotation_id]["spatial_type"];
+        this.delete_annotation(annotation_id, is_redo, false);
+        let frame = this.state["current_frame"];
+        if (MODES_3D.includes(spatial_type)) {
+            frame = null;
+        }
+        const copy = this.subtasks[target_key]["annotations"]["access"][copy_id];
+        record_action(this, {
+            act_type: "move_annotation",
+            annotation_id: annotation_id,
+            frame: frame,
+            undo_payload: { target_subtask_key: target_key, copy_id: copy_id },
+            redo_payload: { target_subtask_key: target_key, annotation: copy },
+            affected: [{ annotation_id: copy_id, subtask_key: target_key }],
+        }, is_redo);
+    }
+
+    /**
+     * Undo a move: restore the source in the current subtask and drop the
+     * copy from the target, along with everything the target recorded about
+     * the copy (its edits there can no longer be replayed) and any copies
+     * made by moving it on again.
+     *
+     * @param {string} annotation_id
+     * @param {object} undo_payload `{ target_subtask_key, copy_id }`
+     */
+    move_annotation__undo(annotation_id, undo_payload) {
+        mark_deprecated(this.get_current_subtask()["annotations"]["access"][annotation_id], false);
+        this._discard_moved_copy(undo_payload.copy_id, undo_payload.target_subtask_key);
+        this.toolbox.redraw_update_items(this);
+    }
+
+    /**
+     * Redo a move: re-insert the copy in the target and deprecate the source
+     * again.
+     *
+     * @param {string} annotation_id
+     * @param {object} redo_payload `{ target_subtask_key, annotation }`
+     */
+    move_annotation__redo(annotation_id, redo_payload) {
+        const target_key = redo_payload.target_subtask_key;
+        this._insert_pasted_annotation(redo_payload.annotation, target_key, true, false);
+        this._record_move_annotation(annotation_id, target_key, redo_payload.annotation["id"], true);
+    }
+
+    /**
+     * When a pasted annotation could take several classes in its subtask, make
+     * that subtask current and open the class pie on the copy.
+     *
+     * @param {string} annotation_id id of the pasted annotation
+     * @param {string} target_key subtask it was pasted into
+     */
+    _offer_pasted_class_choice(annotation_id, target_key) {
+        const annotation = this.subtasks[target_key]["annotations"]["access"][annotation_id];
+        if (this._get_compatible_class_ids(annotation, target_key).length <= 1) return;
+        if (target_key !== this.get_current_subtask_key()) {
+            this.set_subtask(target_key);
+        }
+        const cbox = annotation["containing_box"];
+        if (cbox != null) {
+            this.show_id_dialog((cbox.tlx + cbox.brx) / 2, (cbox.tly + cbox.bry) / 2, annotation_id, false);
+        }
+    }
+
+    /**
+     * Put the hovered annotation (or `annotation_id`) on the in-memory
+     * clipboard; cut also deletes it from the current subtask. Returns the
+     * JSON envelope for the system clipboard, or null when nothing was copied.
+     *
+     * @param {string|null} annotation_id defaults to the hovered annotation
+     * @param {boolean} cut delete the source (current subtask must be writable)
+     * @returns {object|null} `{ ulabel_annotation: 1, image_width, image_height, source_subtask_key, annotation }`
+     */
+    copy_annotation_to_clipboard(annotation_id = null, cut = false) {
+        const subtask_key = this.get_current_subtask_key();
+        const subtask = this.subtasks[subtask_key];
+        annotation_id ??= subtask["state"]["edit_candidate"]?.["annid"] ?? null;
+        if (annotation_id === null) return null;
+        const annotation = subtask["annotations"]["access"][annotation_id];
+        if (annotation == null || annotation["deprecated"]) return null;
+        const spatial_type = annotation["spatial_type"];
+        if (NONSPATIAL_MODES.includes(spatial_type) || DELETE_MODES.includes(spatial_type)) return null;
+        if (cut && this.is_subtask_edit_locked()) return null;
+
+        const copy = JSON.parse(JSON.stringify(annotation));
+        if (spatial_type === "bitmask") {
+            copy["spatial_payload"] = this.get_bitmask(annotation).to_rle();
+        }
+        const envelope = {
+            ulabel_annotation: 1,
+            copy_id: uuidv4(),
+            copied_at: Date.now(),
+            image_width: this.config["image_width"],
+            image_height: this.config["image_height"],
+            source_subtask_key: subtask_key,
+            source_class_name: this.get_class_name(Number(get_annotation_class_id(annotation)), subtask_key),
+            annotation: copy,
+            paste_counts: {},
+        };
+        this.state["clipboard"] = envelope;
+        if (cut) {
+            this.delete_annotation(annotation_id);
+        }
+        return envelope;
+    }
+
+    /**
+     * Paste a clipboard envelope into the current subtask. Without an
+     * argument the in-memory clipboard is used. The first paste into another
+     * subtask keeps the coordinates; a paste back into the source subtask,
+     * and every repeat paste into the same subtask, is offset by a further
+     * `PASTE_OFFSET_PX` so each copy is visible. When the source class has
+     * no counterpart in the target (by id or name), the class pie opens on
+     * the copy if several classes could take it and
+     * `config.paste_class_choice` is on.
+     *
+     * @param {object|null} envelope as produced by `copy_annotation_to_clipboard`
+     * @returns {string|null} id of the pasted annotation
+     */
+    paste_annotation_from_clipboard(envelope = null) {
+        envelope ??= this.state["clipboard"];
+        if (envelope == null || envelope["annotation"] == null) return null;
+        // The system clipboard yields a fresh parse each paste; the in-memory
+        // envelope for the same copy carries the running paste counts. A
+        // different, newer in-memory copy wins over a stale system payload
+        // (e.g. a menu copy whose system clipboard write failed)
+        const stored = this.state["clipboard"];
+        const same_copy = envelope["copy_id"] != null && stored?.["copy_id"] === envelope["copy_id"];
+        const stored_newer = (stored?.["copied_at"] ?? 0) > (envelope["copied_at"] ?? 0);
+        if (stored != null && stored !== envelope && (same_copy || stored_newer)) {
+            envelope = stored;
+        }
+        if (envelope["image_width"] !== this.config["image_width"] || envelope["image_height"] !== this.config["image_height"]) {
+            log_message("Clipboard annotation belongs to an image of different dimensions; not pasted", LogLevel.WARNING, true);
+            return null;
+        }
+        const target_key = this.get_current_subtask_key();
+        if (!this.can_paste_into_subtask(envelope["annotation"], target_key)) {
+            log_message(`No class in subtask ${target_key} accepts a ${envelope["annotation"]["spatial_type"]} annotation`, LogLevel.WARNING, true);
+            return null;
+        }
+        this.state["clipboard"] = envelope;
+        envelope["paste_counts"] ??= {};
+        // A paste onto the source keeps its class and starts nudged; elsewhere
+        // only repeats are nudged
+        const same_subtask = envelope["source_subtask_key"] === target_key;
+        const steps = (envelope["paste_counts"][target_key] ?? 0) + (same_subtask ? 1 : 0);
+        const offset = [PASTE_OFFSET_PX * steps, PASTE_OFFSET_PX * steps];
+        const source_class_name = envelope["source_class_name"] ?? null;
+        const matched = this.match_paste_class_id(envelope["annotation"], target_key, source_class_name);
+        const class_id = this.resolve_paste_class_id(envelope["annotation"], target_key, source_class_name);
+        const new_id = this.paste_annotation(envelope["annotation"], target_key, class_id, offset, true, envelope["source_subtask_key"] ?? null);
+        if (new_id === null) return null;
+        envelope["paste_counts"][target_key] = (envelope["paste_counts"][target_key] ?? 0) + 1;
+        if (matched === null && this.config["paste_class_choice"]) {
+            this._offer_pasted_class_choice(new_id, target_key);
+        }
+        return new_id;
+    }
+
+    /**
+     * Copy an annotation into another subtask at the same image coordinates.
+     * The class defaults to the target class matching the source class by id,
+     * else by name, else the target's active class, else the first compatible
+     * class.
+     *
+     * @param {string} annotation_id
+     * @param {string} target_subtask_key
+     * @param {number|null} class_id
+     * @param {string|null} source_subtask_key defaults to the current subtask
+     * @returns {string|null} id of the copy, or null when nothing was copied
+     */
+    copy_annotation(annotation_id, target_subtask_key, class_id = null, source_subtask_key = null) {
+        source_subtask_key ??= this.get_current_subtask_key();
+        return this.copy_annotation_to_subtask(annotation_id, source_subtask_key, target_subtask_key, class_id);
+    }
+
+    create_point_annotation_at_mouse_location() {
+        const last_move = this.state["last_move"];
+        if (last_move !== null) {
+            const spatial_payload = this.get_image_aware_mouse_x_y(last_move);
+            // Create a point annotation at the mouse position
+            this.create_annotation("point", [spatial_payload]);
+        }
+    }
+
+    delete_annotation(annotation_id, redoing = false, should_record_action = true, prev_stamp = null) {
+        // Grab constants for convenience
+        const current_subtask = this.get_current_subtask();
+        const annotations = current_subtask["annotations"]["access"];
+        const spatial_type = annotations[annotation_id]["spatial_type"];
+
+        if (this.state["context_menu_annid"] === annotation_id) {
+            this.hide_context_menu();
+        }
+        // Deleting the isolated annotation must bring the others back
+        if (current_subtask["state"]["isolated_annid"] === annotation_id) {
+            this.isolate_annotation(null);
+        }
+
+        // Deprecate the annotation and redraw it
+        mark_deprecated(annotations[annotation_id], true);
+
+        if (current_subtask["state"]["active_id"] !== null) {
+            current_subtask["state"]["active_id"] = null;
+            current_subtask["state"]["is_in_edit"] = false;
+            current_subtask["state"]["is_in_move"] = false;
+            current_subtask["state"]["is_in_progress"] = false;
+            current_subtask["state"]["starting_complex_polygon"] = false;
+        }
+
+        // Clear drag state if we're in the middle of a drag
+        if (this.drag_state["active_key"] !== null) {
+            this.drag_state["active_key"] = null;
+            this.drag_state["release_button"] = null;
+        }
+
+        // Clear edit candidate
+        current_subtask["state"]["edit_candidate"] = null;
+
+        let frame = this.state["current_frame"];
+        if (MODES_3D.includes(spatial_type)) {
+            frame = null;
+        }
+
+        record_action(this, {
+            act_type: "delete_annotation",
+            annotation_id: annotation_id,
+            frame: frame,
+            undo_payload: {},
+            redo_payload: {},
+            ...(prev_stamp ?? {}),
+        }, redoing, should_record_action);
+    }
+
+    delete_annotation__undo(annotation_id) {
+        // Set the annotation to be undeprecated and redraw it
+        mark_deprecated(this.get_current_subtask()["annotations"]["access"][annotation_id], false);
+    }
+
+    delete_annotation__redo(annotation_id) {
+        this.delete_annotation(annotation_id, true);
+    }
+
+    /**
+     * Whether Restore applies to an annotation in the current subtask: deleted by
+     * a human only (filters keep theirs), editable subtask, not an emptied bitmask.
+     * @param {string} annotation_id
+     * @returns {boolean}
+     */
+    can_restore_annotation(annotation_id) {
+        if (this.is_current_subtask_read_only()) return false;
+        const annotation = this.get_current_subtask()["annotations"]["access"][annotation_id];
+        const deprecated_by = annotation?.["deprecated_by"];
+        if (deprecated_by?.["human"] !== true) return false;
+        if (Object.entries(deprecated_by).some(([key, value]) => key !== "human" && value)) return false;
+        const spatial_payload = annotation["spatial_payload"];
+        switch (annotation["spatial_type"]) {
+            case "delete_polygon":
+            case "delete_bbox":
+                return false;
+            case "bitmask":
+                return !this.get_bitmask(annotation).is_empty();
+            case "polygon":
+                return spatial_payload.length > 0;
+            case "polyline":
+            case "contour":
+                return spatial_payload.length >= 2;
+            default:
+                return true;
+        }
+    }
+
+    /**
+     * The edit stamp an annotation had before the recorded action that wrote its
+     * current stamp, searched across every subtask's stream; null if none did.
+     * @param {string} annotation_id
+     * @param {string} subtask_key
+     * @returns {{at: string|null, by: string}|null}
+     */
+    find_stamp_before_last_action(annotation_id, subtask_key) {
+        const stamp = this.subtasks[subtask_key]["annotations"]["access"][annotation_id]["last_edited_at"];
+        if (stamp == null) return null;
+        for (const [key, subtask] of Object.entries(this.subtasks)) {
+            const stream = subtask["actions"]["stream"];
+            for (let i = stream.length - 1; i >= 0; i--) {
+                const action = stream[i];
+                if (action["stamped_at"] !== stamp) continue;
+                if (key === subtask_key && action["annotation_id"] === annotation_id) {
+                    return { at: action["prev_timestamp"], by: action["prev_user"] };
+                }
+                const idx = (action["affected"] ?? []).findIndex(
+                    (entry) => entry["annotation_id"] === annotation_id && entry["subtask_key"] === subtask_key,
+                );
+                if (idx !== -1) {
+                    const prev = action["affected_prev"][idx];
+                    return { at: prev["prev_timestamp"], by: prev["prev_user"] };
+                }
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Undelete a human-deleted annotation in the current subtask. Its edit stamp
+     * reverts to before the deletion when the streams still know it, else now.
+     * @param {string} annotation_id
+     * @param {boolean} redoing
+     * @returns {boolean} whether it was restored
+     */
+    restore_annotation(annotation_id, redoing = false) {
+        if (!redoing && !this.can_restore_annotation(annotation_id)) return false;
+        const annotation = this.get_current_subtask()["annotations"]["access"][annotation_id];
+        const stamp = this.find_stamp_before_last_action(annotation_id, this.get_current_subtask_key());
+        if (this.state["context_menu_annid"] === annotation_id) {
+            this.hide_context_menu();
+        }
+        mark_deprecated(annotation, false);
+        record_action(this, {
+            act_type: "restore_annotation",
+            annotation_id: annotation_id,
+            frame: MODES_3D.includes(annotation["spatial_type"]) ? null : this.state["current_frame"],
+            undo_payload: {},
+            redo_payload: {},
+            stamp_override: stamp ?? undefined,
+        }, redoing);
+        return true;
+    }
+
+    restore_annotation__undo(annotation_id) {
+        mark_deprecated(this.get_current_subtask()["annotations"]["access"][annotation_id], true);
+        this.release_isolation_if_deprecated(annotation_id);
+    }
+
+    restore_annotation__redo(annotation_id) {
+        this.restore_annotation(annotation_id, true);
+    }
+
+    /**
+     * Delete a vertex from a polygon or polyline annotation
+     * @param {string} annotation_id - The ID of the annotation
+     * @param {string|array} access_str - Access string identifying the vertex to delete
+     * @param {boolean} redoing - Whether this is a redo operation
+     * @param {boolean} should_record_action - Whether to record this action in the action stream
+     */
+    delete_vertex(annotation_id, access_str, redoing = false, should_record_action = true) {
+        const current_subtask = this.get_current_subtask();
+        const annotation = current_subtask["annotations"]["access"][annotation_id];
+        const spatial_type = annotation["spatial_type"];
+
+        // Only allow vertex deletion for polygons and polylines
+        if (spatial_type !== "polygon" && spatial_type !== "polyline") {
+            return;
         }
 
         let spatial_payload = annotation["spatial_payload"];
@@ -4465,8 +5448,10 @@ export class ULabel {
             },
         }, redoing, should_record_action);
 
-        // If the entire annotation should be deleted, do so
+        // If the entire annotation should be deleted, do so with its geometry intact
         if (should_delete) {
+            annotation["spatial_payload"] = old_spatial_payload;
+            this.rebuild_containing_box(annotation_id);
             this.delete_annotation(annotation_id, false, false);
         }
     }
@@ -4589,7 +5574,8 @@ export class ULabel {
     }
 
     /**
-     * Get annotation segment to a point.
+     * Get the midpoint of the annotation segment nearest a point: where the
+     * insert handle sits, leaving the rest of the stroke free for a body move.
      * @param {*} global_x
      * @param {*} global_y
      * @param {*} max_dist Maximum distance to search
@@ -4612,7 +5598,7 @@ export class ULabel {
             const spatial_type = this.get_current_subtask()["annotations"]["access"][edid]["spatial_type"];
             let spatial_payload = this.get_current_subtask()["annotations"]["access"][edid]["spatial_payload"];
             let active_spatial_payload = spatial_payload;
-            let n_iters, access_idx;
+            let n_iters;
             switch (spatial_type) {
                 case "bbox":
                 case "bbox3":
@@ -4630,14 +5616,13 @@ export class ULabel {
                         var npi = GeometricUtils.get_nearest_point_on_polygon(
                             global_x, global_y, active_spatial_payload, max_dist / this.get_empirical_scale(), true,
                         );
-                        // for polygons, access index is a list of two indices
-                        // for polylines, access index is a single index
-                        access_idx = spatial_type === "polygon" ? [i, npi["access"]] : npi["access"];
                         if (npi["distance"] != null && npi["distance"] < ret["distance"]) {
+                            const segment = npi["segment"];
+                            const midpoint = "" + (segment + 0.5);
                             ret["annid"] = edid;
-                            ret["access"] = access_idx;
+                            ret["access"] = spatial_type === "polygon" ? [i, midpoint] : midpoint;
                             ret["distance"] = npi["distance"];
-                            ret["point"] = npi["point"];
+                            ret["point"] = GeometricUtils.interpolate_poly_segment(active_spatial_payload, segment, 0.5);
                         }
                     }
                     break;
@@ -4684,8 +5669,21 @@ export class ULabel {
         this.state["edited"] = !saved;
     }
 
+    /**
+     * Whether an `edits_only` submit (optionally limited to `subtasks`) would send anything.
+     *
+     * @param {string[] | null} subtasks subtask keys to check; default all
+     * @returns {boolean}
+     */
+    has_edits(subtasks = null) {
+        const payload = SubmitButtons.build_submit_payload(this, { subtasks: subtasks ?? undefined, edits_only: true });
+        return Object.values(payload.annotations).some((annotations) => annotations.length > 0);
+    }
+
     create_nonspatial_annotation(annotation_id = null, redo_payload = null) {
         const current_subtask = this.get_current_subtask();
+        // A new annotation would be hidden by an active isolation
+        this.isolate_annotation(null);
         let redoing = false;
         let annotation_mode = null;
         let init_idpyld = null;
@@ -4767,6 +5765,8 @@ export class ULabel {
 
         const subtask_key = this.get_current_subtask_key();
         const current_subtask = this.subtasks[subtask_key];
+        // A new annotation would be hidden by an active isolation
+        this.isolate_annotation(null);
 
         if (redo_payload === null) {
             annotation_id = this.make_new_annotation_id();
@@ -4864,7 +5864,7 @@ export class ULabel {
             if (annotation_mode === "polygon" || annotation_mode === "polyline" || annotation_mode === "delete_polygon") {
                 this.continue_annotation(this.state["last_move"]);
             } else {
-                this.finish_annotation();
+                this.finish_annotation(null, true);
             }
         }
     }
@@ -4943,6 +5943,11 @@ export class ULabel {
         for (var pti = 1; pti < npts; pti++) {
             this.update_containing_box(spatial_payload[pti], actid, subtask);
         }
+        if (spatial_type === "tbar" && spatial_payload.length >= 2) {
+            for (const cross_pt of GeometricUtils.tbar_cross_segment(spatial_payload[0], spatial_payload[1])) {
+                this.update_containing_box(cross_pt, actid, subtask);
+            }
+        }
         if (spatial_type) {
             let line_size = this.get_subtask_line_size(subtask);
             this.subtasks[subtask]["annotations"]["access"][actid]["containing_box"]["tlx"] -= 3 * line_size;
@@ -4950,7 +5955,6 @@ export class ULabel {
             this.subtasks[subtask]["annotations"]["access"][actid]["containing_box"]["brx"] += 3 * line_size;
             this.subtasks[subtask]["annotations"]["access"][actid]["containing_box"]["bry"] += 3 * line_size;
         }
-        // TODO modification here for T-Bar would be nice too
     }
 
     // Check that two containing boxes are equal
@@ -5248,11 +6252,16 @@ export class ULabel {
 
         // Loop through all annotations in the ordering until we find a polygon that intersects with the brush
         if (brush_polygon !== null) {
+            const subtask_key = this.get_current_subtask_key();
             for (let i = current_subtask["annotations"]["ordering"].length - 1; i >= 0; i--) {
                 let active_id = current_subtask["annotations"]["ordering"][i];
                 let annotation = current_subtask["annotations"]["access"][active_id];
-                // Only undeprecated polygons
-                if (!annotation["deprecated"] && annotation["spatial_type"] === "polygon") {
+                // Only undeprecated polygons in focus
+                if (
+                    !annotation["deprecated"] &&
+                    annotation["spatial_type"] === "polygon" &&
+                    !this.is_annotation_defocused(annotation, subtask_key)
+                ) {
                     // Split into fills + their associated holes
                     let split_polygons = this.split_complex_polygon(active_id);
                     // Check if the brush intersects with or is within any layer
@@ -5394,7 +6403,18 @@ export class ULabel {
                 }
 
                 if (new_spatial_payload.length === 0) {
-                    // Delete the annotation before overwriting payload
+                    // Fold the stroke into the deletion, as finish_annotation folds a normal stroke
+                    const stream = current_subtask["actions"]["stream"];
+                    const begin = stream.at(-1);
+                    if (begin?.act_type === "begin_brush" && begin.annotation_id === active_id) {
+                        stream.pop();
+                        this.replace_polygon_spatial_data(active_id, JSON.parse(begin.undo_payload).polygon_spatial_data);
+                        this.delete_annotation(active_id, false, true, {
+                            prev_timestamp: begin.prev_timestamp,
+                            prev_user: begin.prev_user,
+                        });
+                        return;
+                    }
                     this.delete_annotation(active_id);
                 }
                 annotation["spatial_payload"] = new_spatial_payload;
@@ -5418,6 +6438,8 @@ export class ULabel {
     create_bitmask_annotation() {
         const subtask_key = this.get_current_subtask_key();
         const current_subtask = this.subtasks[subtask_key];
+        // A new annotation would be hidden by an active isolation
+        this.isolate_annotation(null);
         const annotation_id = this.make_new_annotation_id();
         const init_id_payload = this.get_init_id_payload("bitmask");
         const canvas_id = this.get_init_canvas_context_id(
@@ -5449,15 +6471,17 @@ export class ULabel {
         return annotation_id;
     }
 
-    // Find the topmost undeprecated bitmask annotation with foreground under the brush.
+    // Find the topmost undeprecated, in-focus bitmask annotation with foreground under the brush.
     // When `class_id` is provided, only annotations of that class are considered.
     find_bitmask_under_brush(imx, imy, radius, class_id = null) {
         const current_subtask = this.get_current_subtask();
+        const subtask_key = this.get_current_subtask_key();
         const ordering = current_subtask["annotations"]["ordering"];
         const access = current_subtask["annotations"]["access"];
         for (let i = ordering.length - 1; i >= 0; i--) {
             const annotation = access[ordering[i]];
             if (annotation["deprecated"] || annotation["spatial_type"] !== "bitmask") continue;
+            if (this.is_annotation_defocused(annotation, subtask_key)) continue;
             // Optionally only join annotations that match the given class
             // (get_annotation_class_id returns a string, so coerce for comparison)
             if (class_id !== null && get_annotation_class_id(annotation) !== String(class_id)) continue;
@@ -5643,6 +6667,7 @@ export class ULabel {
         // If the stroke erased the whole mask, deprecate the annotation (ULabel's delete semantics)
         if (after_empty) {
             mark_deprecated(annotation, true);
+            this.release_isolation_if_deprecated(active_id);
         }
 
         if (current_subtask["single_class_mode"]) {
@@ -5670,12 +6695,21 @@ export class ULabel {
             frame: this.state["current_frame"],
             undo_payload: stroke_payload,
             redo_payload: stroke_payload,
+            affected: this.bitmask_other_edits_affected(other_edits),
         });
 
         // The active annotation is re-rendered by the action listener; render the others here
         this.render_bitmask_other_edits(other_edits);
     }
 
+    // `affected` entries for the masks carved by an overwrite stroke
+    bitmask_other_edits_affected(other_edits) {
+        return (other_edits || []).map((edit) => ({
+            annotation_id: edit.annotation_id,
+            subtask_key: edit.subtask,
+        }));
+    }
+
     // {id, subtask} for all undeprecated bitmask annotations except the given one. Scoped to the
     // active subtask unless `brush_overlap_across_subtasks` is set. Matches the render frame-gate
     // (see draw_annotation_from_id): a stroke can only affect masks visible on the current frame.
@@ -5751,6 +6785,7 @@ export class ULabel {
             access[oid]["spatial_payload"] = other_mask.to_rle();
             if (after_empty) {
                 mark_deprecated(access[oid], true);
+                this.release_isolation_if_deprecated(oid, st);
             }
             other_edits.push({
                 annotation_id: oid,
@@ -5795,6 +6830,7 @@ export class ULabel {
                 this.set_bitmask_from_rle(annotation, null);
                 annotation["spatial_payload"] = null;
                 mark_deprecated(annotation, true);
+                this.release_isolation_if_deprecated(annotation_id);
             } else {
                 this.set_bitmask_from_rle(annotation, undo_payload.before_rle);
                 annotation["spatial_payload"] = undo_payload.before_rle;
@@ -5821,6 +6857,7 @@ export class ULabel {
             this.set_bitmask_from_rle(annotation, redo_payload.after_rle);
             annotation["spatial_payload"] = redo_payload.after_rle;
             mark_deprecated(annotation, redo_payload.after_empty === true);
+            this.release_isolation_if_deprecated(annotation_id);
         }
         // Re-apply the carve to any other masks
         const other_edits = redo_payload.other_edits || [];
@@ -5830,6 +6867,7 @@ export class ULabel {
             this.set_bitmask_from_rle(other, edit.after_rle);
             other["spatial_payload"] = edit.after_rle;
             mark_deprecated(other, edit.after_empty === true);
+            this.release_isolation_if_deprecated(edit.annotation_id, edit.subtask);
             this.rebuild_bitmask_containing_box(other);
             this.redraw_annotation(edit.annotation_id, edit.subtask);
         }
@@ -5841,6 +6879,7 @@ export class ULabel {
             frame: this.state["current_frame"],
             undo_payload: redo_payload,
             redo_payload: redo_payload,
+            affected: this.bitmask_other_edits_affected(other_edits),
         }, true);
     }
 
@@ -6094,12 +7133,25 @@ export class ULabel {
                 },
                 redo_payload: {},
             }, redoing);
+
+            // A cancelled drawing was never committed; undo re-inserts it from the payload
+            if (!is_complex_layer) {
+                this.destroy_annotation_context(annotation_id);
+                this.remove_annotation_from_access_and_ordering(annotation_id);
+                this.toolbox.redraw_update_items(this);
+            }
         }
     }
 
     cancel_annotation__undo(annotation_id, undo_payload) {
         // Mark that the annotation is in progress again
         const current_subtask = this.get_current_subtask();
+        if (!undo_payload.is_complex_layer) {
+            const annotation = undo_payload.annotation;
+            annotation["canvas_id"] = this.get_init_canvas_context_id(annotation_id);
+            current_subtask["annotations"]["access"][annotation_id] = annotation;
+            current_subtask["annotations"]["ordering"].push(annotation_id);
+        }
         current_subtask["state"]["active_id"] = annotation_id;
         current_subtask["state"]["is_in_progress"] = true;
 
@@ -6129,7 +7181,7 @@ export class ULabel {
         }
     }
 
-    finish_annotation(mouse_event = null) {
+    finish_annotation(mouse_event = null, redoing = false) {
         // Convenience
         const current_subtask = this.get_current_subtask();
         const annotations = current_subtask["annotations"]["access"];
@@ -6223,6 +7275,8 @@ export class ULabel {
 
         let undo_payload = {};
         let redo_payload = {};
+        let prev_timestamp;
+        let prev_user;
         if (should_record_action) {
             // Once we've finished a polygon or polyline, undoing will
             // remove the entire completed annotation rather that undoing each point.
@@ -6240,6 +7294,9 @@ export class ULabel {
                     act_type = "finish_modify_annotation";
                     undo_payload = JSON.parse(action.undo_payload);
                     redo_payload.polygon_spatial_data = ULabelAnnotation.get_polygon_spatial_data(annotations[active_id]);
+                    // The popped action already stamped the annotation; keep its pre-edit stamp so undo restores it
+                    prev_timestamp = action.prev_timestamp;
+                    prev_user = action.prev_user;
                     break;
                 }
             }
@@ -6254,7 +7311,9 @@ export class ULabel {
                 frame: this.state["current_frame"],
                 undo_payload: undo_payload,
                 redo_payload: redo_payload,
-            }, false, should_record_action);
+                prev_timestamp: prev_timestamp,
+                prev_user: prev_user,
+            }, redoing, should_record_action);
         }
 
         // TODO build a dialog here when necessary -- will also need to integrate with undo
@@ -6288,8 +7347,13 @@ export class ULabel {
     }
 
     finish_annotation__undo(annotation_id) {
+        const current_subtask = this.get_current_subtask();
+        // The isolation must not outlive its target
+        if (current_subtask["state"]["isolated_annid"] === annotation_id) {
+            this.isolate_annotation(null);
+        }
         // Deprecate the annotation
-        mark_deprecated(this.get_current_subtask()["annotations"]["access"][annotation_id], true);
+        mark_deprecated(current_subtask["annotations"]["access"][annotation_id], true);
     }
 
     finish_annotation__redo(annotation_id) {
@@ -6327,6 +7391,13 @@ export class ULabel {
             frame = null;
         }
 
+        // A body click that never drags is unwound in finish_move; keep what
+        // record_action is about to clobber.
+        this.state["move_snapshot"] = {
+            edited: this.state["edited"],
+            undone_stack: current_subtask["actions"]["undone_stack"].slice(),
+        };
+
         record_action(this, {
             act_type: "begin_move",
             annotation_id: active_id,
@@ -6409,6 +7480,31 @@ export class ULabel {
         let spatial_payload = annotation["spatial_payload"];
         let active_spatial_payload = spatial_payload;
 
+        // A click with no drag is not an edit: drop the begin_move so neither
+        // undo nor redo ever see it, and leave the saved state as it was.
+        if (diffX === 0 && diffY === 0 && diffZ === 0) {
+            const action = current_subtask["actions"]["stream"].pop();
+            annotation["last_edited_at"] = action["prev_timestamp"];
+            annotation["last_edited_by"] = action["prev_user"];
+            const snapshot = this.state["move_snapshot"];
+            if (snapshot != null) {
+                this.set_saved(!snapshot["edited"]);
+                // In place: undo() may hold a reference to this array
+                const undone_stack = current_subtask["actions"]["undone_stack"];
+                undone_stack.length = 0;
+                undone_stack.push(...snapshot["undone_stack"]);
+                this.state["move_snapshot"] = null;
+            }
+            current_subtask["state"]["active_id"] = null;
+            current_subtask["state"]["is_in_move"] = false;
+            if (spatial_type === "bitmask") {
+                this.end_bitmask_move();
+            }
+            this.redraw_all_annotations_in_annotation_context(annotation["canvas_id"], current_subtask_key);
+            return;
+        }
+        this.state["move_snapshot"] = null;
+
         // Bitmask masks are translated wholesale rather than point-by-point
         if (spatial_type === "bitmask") {
             // Bitmask storage is bounded by image dimensions; a translate that pushes
@@ -6641,7 +7737,7 @@ export class ULabel {
         for (let edi = 0; edi < this.get_current_subtask()["annotations"]["ordering"].length; edi++) {
             const annotation_id = this.get_current_subtask()["annotations"]["ordering"][edi];
             let annotation = this.get_current_subtask()["annotations"]["access"][annotation_id];
-            if (annotation["deprecated"]) continue;
+            // Deprecated annotations are candidates only under deprecated focus
             if (this.is_annotation_defocused(annotation, current_subtask_key)) continue;
             let cbox = annotation["containing_box"];
             let frame = annotation["frame"];
@@ -6684,6 +7780,7 @@ export class ULabel {
                         break;
                     case "bbox":
                     case "point":
+                    case "bbox3":
                         if (
                             gblx >= cbox["tlx"] &&
                             gblx <= cbox["brx"] &&
@@ -6694,6 +7791,7 @@ export class ULabel {
                         }
                         break;
                     case "polyline":
+                    case "contour":
                         // Within the drawn stroke of the line itself
                         if (GeometricUtils.point_is_near_polyline(
                             [gblx, gbly],
@@ -6703,6 +7801,19 @@ export class ULabel {
                             is_a_containing_annotation = true;
                         }
                         break;
+                    case "tbar": {
+                        // Within the stroke of either the stem or the cross bar
+                        const stroke = (annotation["line_size"] ?? this.get_subtask_line_size()) / 2 + slack;
+                        const [sp, ep] = annotation["spatial_payload"];
+                        const cross = GeometricUtils.tbar_cross_segment(sp, ep);
+                        if (
+                            GeometricUtils.point_is_near_polyline([gblx, gbly], [sp, ep], stroke) ||
+                            GeometricUtils.point_is_near_polyline([gblx, gbly], cross, stroke)
+                        ) {
+                            is_a_containing_annotation = true;
+                        }
+                        break;
+                    }
                     case "bitmask":
                         // The mouse must be over a painted pixel of the mask
                         if (this.get_bitmask(annotation).has_foreground_in_circle(
@@ -6733,6 +7844,7 @@ export class ULabel {
                             ret["candidate_ids"] = [annotation_id];
                             ret["best"] = {
                                 annid: annotation_id,
+                                containing: true,
                             };
                         }
                     }
@@ -6741,6 +7853,7 @@ export class ULabel {
                     minsize = boxsize;
                     ret["best"] = {
                         annid: annotation_id,
+                        containing: false,
                     };
                 }
             }
@@ -6755,7 +7868,7 @@ export class ULabel {
      * Find closest keypoints (ends of polygons/polylines etc) within a range defined by the edit handle
      * If no endpoints, search along segments with infinite range
      */
-    suggest_edits(mouse_event = null, nonspatial_id = null, force_refresh = false) {
+    suggest_edits(mouse_event = null, nonspatial_id = null) {
         const current_subtask = this.get_current_subtask();
         // Don't show any dialogs when currently drawing/editing an annotation,
         // And hide just edit dialogs when moving
@@ -6794,14 +7907,6 @@ export class ULabel {
             const global_x = this.get_global_mouse_x(mouse_event);
             const global_y = this.get_global_mouse_y(mouse_event);
 
-            // Ignore when we're already hovering an edit
-            if (
-                !force_refresh &&
-                $(mouse_event.target).hasClass("gedit-target")
-            ) {
-                return;
-            }
-
             const edit_candidates = this.get_edit_candidates(
                 global_x,
                 global_y,
@@ -6814,6 +7919,19 @@ export class ULabel {
 
             // Show global edit dialogs for "best" candidate
             best_candidate = edit_candidates["best"];
+            const containing = best_candidate["containing"];
+
+            // A deprecated annotation is view-only: hover card and context menu, no handles or grab
+            if (current_subtask["annotations"]["access"][best_candidate["annid"]]["deprecated"]) {
+                this.hide_edit_suggestion();
+                current_subtask["state"]["move_candidate"] = null;
+                this.set_move_cursor(false);
+                $("#" + current_subtask["canvas_fid"]).addClass("context_menu_hover");
+                current_subtask["state"]["edit_candidate"] = best_candidate;
+                this.update_confidence_dialog();
+                this.show_global_edit_suggestion(best_candidate.annid, null, null);
+                return;
+            }
 
             // Look for an existing point that's close enough to suggest editing it
             const nearest_active_keypoint = this.get_nearest_active_keypoint(global_x, global_y, dst_thresh, edit_candidates["candidate_ids"]);
@@ -6832,8 +7950,14 @@ export class ULabel {
                 }
             }
 
-            // Only spatial annotations can be moved
+            // Only spatial annotations can be moved. `containing` is what lets a
+            // body drag start a move: a near-miss on the box alone is not grabbable.
+            best_candidate["containing"] = containing;
             current_subtask["state"]["move_candidate"] = best_candidate;
+            this.set_move_cursor(
+                !this.is_subtask_edit_locked() &&
+                ULabel.is_body_move_start(mouse_event, this),
+            );
         }
 
         // Both spatial/non-spatial can have the global suggestions
@@ -6848,6 +7972,16 @@ export class ULabel {
     hide_edits() {
         this.hide_global_edit_suggestion();
         this.hide_edit_suggestion();
+        this.set_move_cursor(false);
+        $("#" + this.get_current_subtask()["canvas_fid"]).removeClass("context_menu_hover");
+    }
+
+    /**
+     * Show the move cursor on the front canvas when a left click would drag the
+     * hovered annotation rather than start drawing.
+     */
+    set_move_cursor(movable) {
+        $("#" + this.get_current_subtask()["canvas_fid"]).toggleClass("movable_hover", movable);
     }
 
     hide_and_clear_action_candidates() {
@@ -6987,6 +8121,12 @@ export class ULabel {
 
     set_id_dialog_payload_nopin(class_ind, dist_prop) {
         let class_ids = this.get_current_subtask()["class_ids"];
+        // Delete modes pass class_ind -1, so every class takes the remainder;
+        // with a single class that would divide by zero
+        let other_prop = 0;
+        if (class_ids.length > 1) {
+            other_prop = (1 - dist_prop) / (class_ids.length - 1);
+        }
         // Recompute and render opaque pie slices
         for (var i = 0; i < class_ids.length; i++) {
             if (i === class_ind) {
@@ -6997,7 +8137,7 @@ export class ULabel {
             } else {
                 this.get_current_subtask()["state"]["id_payload"][i] = {
                     class_id: class_ids[i],
-                    confidence: (1 - dist_prop) / (class_ids.length - 1),
+                    confidence: other_prop,
                 };
             }
         }
@@ -7166,6 +8306,12 @@ export class ULabel {
             }
             old_payload = current_subtask["annotations"]["access"][annotation_id]["classification_payloads"];
             new_payload = current_subtask["state"]["id_payload"];
+            // Re-picking the current class is not an edit; just dismiss the pie
+            if (JSON.stringify(old_payload) === JSON.stringify(new_payload)) {
+                this.hide_id_dialog();
+                this.suggest_edits(null);
+                return;
+            }
         } else {
             redoing = true;
             old_payload = redo_payload.old_id_payload;
@@ -7204,10 +8350,35 @@ export class ULabel {
     }
 
     assign_annotation_id__undo(annotation_id, undo_payload) {
-        // Restore the old payload
         this.get_current_subtask()["annotations"]["access"][annotation_id]["classification_payloads"] = undo_payload.old_id_payload;
     }
 
+    edit_text_payload(annotation_id, new_text, redoing = false) {
+        const annotation = this.get_current_subtask()["annotations"]["access"][annotation_id];
+        const old_text = annotation["text_payload"];
+        if (!redoing && old_text === new_text) return;
+        annotation["text_payload"] = new_text;
+        record_action(this, {
+            act_type: "edit_text_payload",
+            annotation_id: annotation_id,
+            frame: this.state["current_frame"],
+            undo_payload: {
+                old_text: old_text,
+            },
+            redo_payload: {
+                new_text: new_text,
+            },
+        }, redoing);
+    }
+
+    edit_text_payload__undo(annotation_id, undo_payload) {
+        this.get_current_subtask()["annotations"]["access"][annotation_id]["text_payload"] = undo_payload.old_text;
+    }
+
+    edit_text_payload__redo(annotation_id, redo_payload) {
+        this.edit_text_payload(annotation_id, redo_payload.new_text, true);
+    }
+
     handle_id_dialog_click(mouse_event, annotation_id = null, new_class_idx = null) {
         const current_subtask = this.get_current_subtask();
 
@@ -7292,13 +8463,18 @@ export class ULabel {
     // ================= Viewer/Annotation Interaction Handlers  =================
 
     handle_mouse_down(mouse_event) {
+        // Like a native menu, the click that dismisses the menu does nothing else
+        if (this.is_context_menu_open()) {
+            this.hide_context_menu();
+            return;
+        }
         const drag_key = ULabel.get_drag_key_start(mouse_event, this);
         if (drag_key != null) {
             // Suppress browser defaults (e.g. middle-click auto-scroll)
             mouse_event.preventDefault();
             // Don't start new drag while id_dialog is visible or subtask is hidden
             if (
-                (this.get_current_subtask()["state"]["idd_visible"] && !this.get_current_subtask()["state"]["idd_thumbnail"]) ||
+                this.get_current_subtask()["state"]["idd_visible"] ||
                 (this.is_subtask_hidden() && drag_key !== "pan" && drag_key !== "zoom")
             ) {
                 return;
@@ -7312,13 +8488,12 @@ export class ULabel {
     handle_mouse_move(mouse_event) {
         const annotation_mode = this.get_current_subtask()["state"]["annotation_mode"];
         const idd_visible = this.get_current_subtask()["state"]["idd_visible"];
-        const idd_thumbnail = this.get_current_subtask()["state"]["idd_thumbnail"];
         const edit_candidate = this.get_current_subtask()["state"]["edit_candidate"];
         this.state["last_move"] = mouse_event;
         // If the ID dialog is visible, let it's own handler take care of this
         // If not dragging...
         if (this.drag_state["active_key"] === null) {
-            if (idd_visible && !idd_thumbnail) {
+            if (idd_visible || this.is_context_menu_open()) {
                 return;
             }
             // If polygon is in progress, redirect last segment
@@ -7335,10 +8510,16 @@ export class ULabel {
                 let gmx = this.get_global_mouse_x(mouse_event);
                 let gmy = this.get_global_mouse_y(mouse_event);
                 this.move_brush_circle(gmx, gmy);
-            } else if (mouse_event.shiftKey && annotation_mode === "polygon" && idd_visible && edit_candidate != null) {
-                // If shift key is held while hovering a polygon, we want to start a new complex payload
-
-                // set annotation as active, in_progress, and starting_complex_polygon
+            } else if (
+                mouse_event.shiftKey &&
+                annotation_mode === "polygon" &&
+                !this.is_subtask_edit_locked() &&
+                edit_candidate != null &&
+                this.get_current_subtask()["annotations"]["access"][edit_candidate["annid"]]?.["spatial_type"] === "polygon" &&
+                !this.get_current_subtask()["annotations"]["access"][edit_candidate["annid"]]["deprecated"]
+            ) {
+                // Shift-hovering a polygon starts a new complex layer on it. The hover ring
+                // that used to signal this via `idd_visible` is gone; the candidate is the cue.
                 this.get_current_subtask()["state"]["active_id"] = edit_candidate["annid"];
                 this.start_complex_polygon();
             } else { // Nothing in progress. Maybe show editable queues
@@ -7353,7 +8534,7 @@ export class ULabel {
                     this.drag_rezoom(mouse_event);
                     break;
                 case "annotation":
-                    if (!idd_visible || idd_thumbnail) {
+                    if (!idd_visible) {
                         this.continue_annotation(mouse_event);
                     }
                     break;
@@ -7367,12 +8548,12 @@ export class ULabel {
                     }
                     break;
                 case "edit":
-                    if (!idd_visible || idd_thumbnail) {
+                    if (!idd_visible) {
                         this.continue_edit(mouse_event);
                     }
                     break;
                 case "move":
-                    if (!idd_visible || idd_thumbnail) {
+                    if (!idd_visible) {
                         this.schedule_continue_move(mouse_event);
                     }
                     break;
@@ -7412,7 +8593,7 @@ export class ULabel {
             this.update_frame(dlta);
         } else {
             // Don't scroll if id dialog is visible
-            if (this.get_current_subtask()["state"]["idd_visible"] && !this.get_current_subtask()["state"]["idd_thumbnail"]) {
+            if (this.get_current_subtask()["state"]["idd_visible"]) {
                 return;
             }
 
@@ -7628,6 +8809,7 @@ export class ULabel {
 
     // Handle zooming at a certain focus
     rezoom(foc_x = null, foc_y = null, abs = false) {
+        this.hide_context_menu();
         // JQuery convenience
         var imwrap = $("#" + this.config["imwrap_id"]);
         var annbox = $("#" + this.config["annbox_id"]);
@@ -7730,18 +8912,55 @@ export class ULabel {
         return this.fly_to_annotation(annotation, null, max_zoom);
     }
 
+    /**
+     * Center the view on image-space boxes when none of them is in view, keeping
+     * the zoom unless their union does not fit, then zooming out to fit it.
+     *
+     * @param {{tlx: number, tly: number, brx: number, bry: number}[]} boxes
+     * @returns {boolean} whether the view moved
+     */
+    fly_to_boxes_if_offscreen(boxes) {
+        if (boxes.length === 0) return false;
+        const annbox = $("#" + this.config["annbox_id"]);
+        const scale = this.get_empirical_scale();
+        const viewport_width = annbox.width();
+        const viewport_height = annbox.height();
+        if (!(scale > 0) || !(viewport_width > 0) || !(viewport_height > 0)) return false;
+
+        const view_tlx = annbox.scrollLeft() / scale;
+        const view_tly = annbox.scrollTop() / scale;
+        const view_brx = view_tlx + viewport_width / scale;
+        const view_bry = view_tly + viewport_height / scale;
+        const any_in_view = boxes.some(
+            (box) => box.tlx <= view_brx && box.brx >= view_tlx && box.tly <= view_bry && box.bry >= view_tly,
+        );
+        if (any_in_view) return false;
+
+        const tlx = Math.min(...boxes.map((box) => box.tlx));
+        const tly = Math.min(...boxes.map((box) => box.tly));
+        const brx = Math.max(...boxes.map((box) => box.brx));
+        const bry = Math.max(...boxes.map((box) => box.bry));
+        const padding_factor = 0.9;
+        const fit_zoom = Math.min(
+            (viewport_width * padding_factor) / Math.max(brx - tlx, 1),
+            (viewport_height * padding_factor) / Math.max(bry - tly, 1),
+        );
+        if (fit_zoom < this.state["zoom_val"]) this.set_zoom_val(fit_zoom);
+        this.rezoom((tlx + brx) / 2, (tly + bry) / 2, true);
+        return true;
+    }
+
     fly_to_annotation(annotation, subtask_key = null, max_zoom = 10) {
-        // Handle null, deprecated, and non-spatial annotations
+        // Handle null and non-spatial annotations
         if (
             annotation === null ||
             annotation === undefined ||
-            annotation["deprecated"] ||
             NONSPATIAL_MODES.includes(annotation["spatial_type"])
         ) {
             return false;
         }
 
-        // Navigation should only visit what's on screen
+        // Navigation should only visit what's on screen; deprecated ones only under deprecated focus
         if (this.is_annotation_defocused(annotation, subtask_key ?? this.get_current_subtask_key())) {
             return false;
         }
@@ -7803,13 +9022,13 @@ export class ULabel {
 
         if (annotation_idx === -1) return;
 
-        // Count non-deprecated annotations up to and including this one
+        // Count in-focus annotations up to and including this one
         let visible_count = 0;
         let current_visible_idx = -1;
         const current_subtask_key = this.get_current_subtask_key();
         for (let i = 0; i < ordering.length; i++) {
             const ann = current_subtask["annotations"]["access"][ordering[i]];
-            if (!ann["deprecated"] && !this.is_annotation_defocused(ann, current_subtask_key)) {
+            if (!this.is_annotation_defocused(ann, current_subtask_key)) {
                 if (ordering[i] === annotation_id) {
                     current_visible_idx = visible_count;
                 }
@@ -7933,6 +9152,7 @@ export class ULabel {
     }
 
     reset_interaction_state(subtask = null) {
+        this.hide_context_menu();
         let q = [];
         if (subtask === null) {
             for (let st in this.subtasks) {
@@ -7958,40 +9178,22 @@ export class ULabel {
         if (subtask !== null && subtask !== this.state["current_subtask"]) {
             return;
         }
-        this.drag_state = {
+        this.drag_state = ULabel.build_initial_drag_state();
+    }
+
+    static build_initial_drag_state() {
+        const drag_state = {
             active_key: null,
             release_button: null,
-            annotation: {
-                mouse_start: null, // Screen coordinates where the current mouse drag started
-                offset_start: null, // Scroll values where the current mouse drag started
-                zoom_val_start: null, // zoom_val when the dragging interaction started
-            },
-            edit: {
-                mouse_start: null, // Screen coordinates where the current mouse drag started
-                offset_start: null, // Scroll values where the current mouse drag started
-                zoom_val_start: null, // zoom_val when the dragging interaction started
-            },
-            pan: {
-                mouse_start: null, // Screen coordinates where the current mouse drag started
-                offset_start: null, // Scroll values where the current mouse drag started
-                zoom_val_start: null, // zoom_val when the dragging interaction started
-            },
-            zoom: {
-                mouse_start: null, // Screen coordinates where the current mouse drag started
-                offset_start: null, // Scroll values where the current mouse drag started
-                zoom_val_start: null, // zoom_val when the dragging interaction started
-            },
-            move: {
-                mouse_start: null, // Screen coordinates where the current mouse drag started
-                offset_start: null, // Scroll values where the current mouse drag started
-                zoom_val_start: null, // zoom_val when the dragging interaction started
-            },
-            right: {
+        };
+        for (const drag_key of ["annotation", "brush", "edit", "pan", "zoom", "move", "right"]) {
+            drag_state[drag_key] = {
                 mouse_start: null, // Screen coordinates where the current mouse drag started
                 offset_start: null, // Scroll values where the current mouse drag started
                 zoom_val_start: null, // zoom_val when the dragging interaction started
-            },
-        };
+            };
+        }
+        return drag_state;
     }
 
     // Allow for external access and modification of annotations within a subtask
@@ -8117,6 +9319,8 @@ export class ULabel {
         this.reset_interaction_state(subtask);
         this.subtasks[subtask]["actions"]["stream"] = [];
         this.subtasks[subtask]["actions"]["undone_stack"] = [];
+        // The isolated id is about to stop existing; the redraw below repaints
+        this.isolate_annotation(null, subtask, false);
 
         // Bulk teardown of outgoing annotations: much cheaper than a per-annotation loop.
         this._clear_subtask_annotation_canvases(subtask);
diff --git a/src/isolate.ts b/src/isolate.ts
new file mode 100644
index 00000000..f9074c16
--- /dev/null
+++ b/src/isolate.ts
@@ -0,0 +1,71 @@
+/**
+ * Isolate one annotation: everything else in its subtask is hidden from the
+ * canvas and from input (hover, Tab, fly-to, the list, bulk delete) until the
+ * isolation clears. View-only state: nothing is recorded, `edited` is
+ * untouched, and `get_annotations()` is unaffected.
+ */
+
+import type { ULabel } from "../index";
+import { ULabelAnnotation } from "./annotation";
+import { log_message, LogLevel } from "./error_logging";
+
+/**
+ * Whether another annotation is isolated in the subtask, hiding this one.
+ * Bitmask geometry paths must not consult this: hidden annotations are still data.
+ */
+export function is_annotation_isolated_out(ulabel: ULabel, annotation: ULabelAnnotation, subtask_key: string): boolean {
+    const subtask = ulabel.subtasks[subtask_key];
+    if (subtask == null) return false;
+    const isolated_annid = subtask.state.isolated_annid;
+    return isolated_annid != null && annotation.id !== isolated_annid;
+}
+
+/**
+ * Isolate an annotation, or pass `null` to show all again.
+ *
+ * @param ulabel ULabel instance
+ * @param annotation_id annotation to isolate, or `null` to clear
+ * @param subtask_key defaults to the current subtask
+ * @param redraw whether the change repaints immediately
+ * @returns whether the request was accepted
+ */
+export function isolate_annotation(
+    ulabel: ULabel,
+    annotation_id: string | null,
+    subtask_key: string | null = null,
+    redraw: boolean = true,
+): boolean {
+    const key = subtask_key ?? ulabel.get_current_subtask_key();
+    const subtask = ulabel.subtasks[key];
+    if (subtask == null) {
+        log_message(`isolate_annotation: unknown subtask key ${key}`, LogLevel.WARNING, true);
+        return false;
+    }
+    if (annotation_id != null) {
+        const annotation = subtask.annotations.access[annotation_id];
+        // Deprecated annotations are only visible, so only isolatable, under deprecated focus
+        if (annotation == null || (annotation.deprecated && !subtask.focus_deprecated)) {
+            log_message(`isolate_annotation: unknown or deprecated annotation ${annotation_id}`, LogLevel.WARNING, true);
+            return false;
+        }
+    }
+
+    const previous = subtask.state.isolated_annid;
+    if (previous === annotation_id) return true;
+    subtask.state.isolated_annid = annotation_id;
+
+    // Whatever was hovered, targeted, or mid-fly-to may have just been hidden
+    subtask.state.hovered_annid = null;
+    subtask.state.edit_candidate = null;
+    subtask.state.move_candidate = null;
+    subtask.state.fly_to_idx = null;
+    ulabel.hide_context_menu();
+
+    if (redraw) {
+        ulabel.redraw_all_annotations(key);
+        ulabel.toolbox?.redraw_update_items(ulabel);
+    }
+
+    ulabel.config.on_isolate_change?.(key, annotation_id);
+    return true;
+}
diff --git a/src/listeners.ts b/src/listeners.ts
index 05dd676d..b896ac9a 100644
--- a/src/listeners.ts
+++ b/src/listeners.ts
@@ -14,6 +14,50 @@ import { AnnotationResizeItem, SMALL_ANNOTATION_SIZE, LARGE_ANNOTATION_SIZE, INC
 
 const ULABEL_NAMESPACE = ".ulabel";
 
+/** Whether a keyboard/clipboard event originates from a text field, where the browser should keep its default behavior. */
+function is_text_input_target(target: EventTarget | null): boolean {
+    const element = target as HTMLElement | null;
+    if (element == null) return false;
+    return element.tagName === "INPUT" || element.tagName === "TEXTAREA" || element.isContentEditable === true;
+}
+
+/**
+ * Native clipboard shortcuts: copy/cut the hovered annotation, paste into the
+ * current subtask. Only intercepts the event when there is something to act on.
+ */
+function handle_clipboard_event(
+    clipboard_event: JQuery.TriggeredEvent,
+    ulabel: ULabel,
+    kind: "copy" | "cut" | "paste",
+) {
+    if (is_text_input_target(clipboard_event.target) || ulabel.state.is_editing_keybind) return;
+    if (ulabel.get_current_subtask()["state"]["is_in_progress"]) return;
+    if (kind !== "copy" && ulabel.is_subtask_edit_locked()) return;
+    const clipboard_data = (clipboard_event.originalEvent as ClipboardEvent | undefined)?.clipboardData ?? null;
+
+    if (kind === "paste") {
+        let envelope = null;
+        const text = clipboard_data?.getData("text/plain");
+        if (text) {
+            try {
+                const parsed = JSON.parse(text);
+                if (parsed?.ulabel_annotation === 1) envelope = parsed;
+            } catch {
+                // Not our payload; fall back to the in-memory clipboard
+            }
+        }
+        if (envelope === null && ulabel.state.clipboard === null) return;
+        clipboard_event.preventDefault();
+        ulabel.paste_annotation_from_clipboard(envelope);
+        return;
+    }
+
+    const envelope = ulabel.copy_annotation_to_clipboard(null, kind === "cut");
+    if (envelope === null) return;
+    clipboard_event.preventDefault();
+    clipboard_data?.setData("text/plain", JSON.stringify(envelope));
+}
+
 /**
  * Check if a keyboard event matches a keybind (supports chords like "ctrl+s")
  */
@@ -66,7 +110,7 @@ function handle_keypress_event(
     }
 
     const current_subtask = ulabel.get_current_subtask();
-    const is_read_only = ulabel.is_current_subtask_read_only();
+    const is_read_only = ulabel.is_subtask_edit_locked();
 
     // Create a point annotation at the mouse's current location
     if (event_matches_keybind(keypress_event, ulabel.config.create_point_annotation_keybind)) {
@@ -171,6 +215,20 @@ function handle_keypress_event(
         return;
     }
 
+    // Toggle edit focus (only created/modified annotations) on the current subtask
+    if (event_matches_keybind(keypress_event, ulabel.config.toggle_edit_focus_keybind)) {
+        const st_key = ulabel.get_current_subtask_key();
+        ulabel.set_focus_edited(st_key, !ulabel.subtasks[st_key].focus_edited);
+        return;
+    }
+
+    // Toggle deprecated focus (Show Deprecated) on the current subtask
+    if (event_matches_keybind(keypress_event, ulabel.config.toggle_deprecated_focus_keybind)) {
+        const st_key = ulabel.get_current_subtask_key();
+        ulabel.set_focus_deprecated(st_key, !ulabel.subtasks[st_key].focus_deprecated);
+        return;
+    }
+
     // Check for class keybinds
     if (!DELETE_MODES.includes(current_subtask.state.annotation_mode)) {
         for (let i = 0; i < current_subtask.class_defs.length; i++) {
@@ -265,8 +323,15 @@ function handle_keydown_event(
 
     // Handle Escape key
     if (keydown_event.key.toLowerCase() === "escape") {
-        // If in erase or brush mode, cancel the brush
-        if (current_subtask.state.is_in_erase_mode) {
+        if (ulabel.is_context_menu_open()) {
+            ulabel.hide_context_menu();
+        } else if (current_subtask.state.idd_visible) {
+            // A clicked-open id dialog has no other dismissal
+            ulabel.hide_id_dialog();
+        } else if (current_subtask.state.isolated_annid != null) {
+            ulabel.isolate_annotation(null);
+        } else if (current_subtask.state.is_in_erase_mode) {
+            // If in erase or brush mode, cancel the brush
             ulabel.toggle_erase_mode();
         } else if (current_subtask.state.is_in_brush_mode) {
             ulabel.toggle_brush_mode();
@@ -358,9 +423,7 @@ export function create_ulabel_listeners(
     id_dialog.on(
         "mousemove" + ULABEL_NAMESPACE,
         (mouse_event) => {
-            if (!ulabel.get_current_subtask()["state"]["idd_thumbnail"]) {
-                ulabel.handle_id_dialog_hover(mouse_event);
-            }
+            ulabel.handle_id_dialog_hover(mouse_event);
         },
     );
 
@@ -400,6 +463,31 @@ export function create_ulabel_listeners(
         (move_event) => ulabel.handle_mouse_move(move_event),
     );
 
+    // Right-click opens the context menu for the hovered annotation. While an
+    // annotation is in progress button 2 belongs to the draw (mouseup finishes
+    // a polyline), so no menu then.
+    annbox.on(
+        "contextmenu" + ULABEL_NAMESPACE,
+        (context_event) => {
+            context_event.preventDefault();
+            const state = ulabel.get_current_subtask()["state"];
+            if (state["active_id"] != null || state["idd_visible"]) return;
+            // The mousedown just before this dismissed any open menu (and its
+            // hover), so re-resolve the candidate under the cursor
+            ulabel.suggest_edits(context_event);
+            const edit_candidate = state["edit_candidate"];
+            if (edit_candidate != null) {
+                ulabel.show_context_menu(edit_candidate.annid, context_event.clientX!, context_event.clientY!);
+            }
+        },
+    );
+
+    // A mousedown anywhere outside the menu dismisses it (the menu stops its own)
+    $(document).on(
+        "mousedown" + ULABEL_NAMESPACE,
+        () => ulabel.hide_context_menu(),
+    );
+
     // ================= Uncategorized =================
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any -- jQuery overloads don't support namespaced event strings
@@ -517,7 +605,16 @@ export function create_ulabel_listeners(
     $(document).on(
         "click" + ULABEL_NAMESPACE,
         "div.fad_row.add a.add-glob-button",
-        () => ulabel.create_nonspatial_annotation(),
+        () => {
+            if (ulabel.is_subtask_edit_locked()) return;
+            ulabel.create_nonspatial_annotation();
+        },
+    );
+
+    $(document).on(
+        "click" + ULABEL_NAMESPACE,
+        "div.deprecated-focus-banner a.deprecated-focus-exit",
+        () => ulabel.set_focus_deprecated(ulabel.get_current_subtask_key(), false),
     );
 
     $(document).on(
@@ -533,13 +630,12 @@ export function create_ulabel_listeners(
     );
 
     $(document).on(
-        "input" + ULABEL_NAMESPACE,
+        "change" + ULABEL_NAMESPACE,
         "textarea.nonspatial_note",
-        (input_event) => {
-            // Update annotation's text field
-            const annos = ulabel.get_current_subtask()["annotations"]["access"];
-            const text_payload_anno_id = input_event.target.id.substring("note__".length);
-            annos[text_payload_anno_id]["text_payload"] = input_event.target.value;
+        (change_event) => {
+            if (ulabel.is_subtask_edit_locked()) return;
+            const text_payload_anno_id = change_event.target.id.substring("note__".length);
+            ulabel.edit_text_payload(text_payload_anno_id, change_event.target.value);
         },
     );
 
@@ -547,6 +643,7 @@ export function create_ulabel_listeners(
         "click" + ULABEL_NAMESPACE,
         "a.fad_button.delete",
         (click_event) => {
+            if (ulabel.is_subtask_edit_locked()) return;
             ulabel.delete_annotation(click_event.target.id.substring("delete__".length));
         },
     );
@@ -555,12 +652,12 @@ export function create_ulabel_listeners(
         "click" + ULABEL_NAMESPACE,
         "a.fad_button.reclf",
         (click_event) => {
+            if (ulabel.is_subtask_edit_locked()) return;
             // Show idd
             ulabel.show_id_dialog(
                 click_event.pageX!,
                 click_event.pageY!,
                 click_event.target.id.substring("reclf__".length),
-                false,
                 true,
             );
         },
@@ -570,7 +667,7 @@ export function create_ulabel_listeners(
         "mouseenter" + ULABEL_NAMESPACE,
         "div.fad_annotation_rows div.fad_row",
         (mouse_event) => {
-            // Show thumbnail for idd
+            // Track the hovered row as the edit candidate
             ulabel.suggest_edits(
                 null,
                 $(mouse_event.currentTarget).attr("id")!.substring("row__".length),
@@ -582,11 +679,8 @@ export function create_ulabel_listeners(
         "mouseleave" + ULABEL_NAMESPACE,
         "div.fad_annotation_rows div.fad_row",
         () => {
-            // Show thumbnail for idd
-            if (
-                ulabel.get_current_subtask()["state"]["idd_visible"] &&
-                !ulabel.get_current_subtask()["state"]["idd_thumbnail"]
-            ) {
+            // A clicked-open id dialog is its own interaction; don't yank it away
+            if (ulabel.get_current_subtask()["state"]["idd_visible"]) {
                 return;
             }
             ulabel.suggest_edits(null);
@@ -599,17 +693,22 @@ export function create_ulabel_listeners(
         (keypress_event: JQuery.KeyPressEvent) => {
             // Check the key pressed against the delete annotation keybind in the config
             if (event_matches_keybind(keypress_event, ulabel.config.delete_annotation_keybind)) {
-                if (ulabel.is_current_subtask_read_only()) return;
+                if (ulabel.is_subtask_edit_locked()) return;
                 const current_subtask = ulabel.get_current_subtask();
                 // Check the edit_candidate to make sure its not null and isn't nonspatial
                 const edit_cand = current_subtask.state.edit_candidate;
-                if (edit_cand !== null && !NONSPATIAL_MODES.includes(edit_cand.spatial_type)) {
+                if (
+                    edit_cand !== null &&
+                    !NONSPATIAL_MODES.includes(edit_cand.spatial_type) &&
+                    // Deprecated annotations are hoverable under deprecated focus but not deletable
+                    !current_subtask.annotations.access[edit_cand.annid]?.deprecated
+                ) {
                     ulabel.delete_annotation(edit_cand.annid);
                 }
             }
             // Check the key pressed against the delete vertex keybind in the config
             if (event_matches_keybind(keypress_event, ulabel.config.delete_vertex_keybind)) {
-                if (ulabel.is_current_subtask_read_only()) return;
+                if (ulabel.is_subtask_edit_locked()) return;
                 const current_subtask = ulabel.get_current_subtask();
                 const edit_cand = current_subtask.state.edit_candidate;
 
@@ -621,42 +720,22 @@ export function create_ulabel_listeners(
         },
     );
 
-    // Listener for id_dialog click interactions
+    // ULabel's anchors are buttons; don't let a click navigate to "#" (which
+    // scrolls the host page and rewrites its hash)
     $(document).on(
         "click" + ULABEL_NAMESPACE,
-        "#" + ulabel.config["container_id"] + " a.id-dialog-clickable-indicator",
+        "#" + ulabel.config["container_id"] + " a[href=\"#\"]",
         (click_event) => {
-            if (!ulabel.get_current_subtask()["state"]["idd_thumbnail"]) {
-                ulabel.handle_id_dialog_click(click_event);
-            }
+            click_event.preventDefault();
         },
     );
 
+    // Listener for id_dialog click interactions
     $(document).on(
         "click" + ULABEL_NAMESPACE,
-        ".global_edit_suggestion a.reid_suggestion",
+        "#" + ulabel.config["container_id"] + " a.id-dialog-clickable-indicator",
         (click_event) => {
-            const crst = ulabel.get_current_subtask();
-            const annid = crst["state"]["idd_associated_annotation"];
-            // No association means no dialog to open (e.g. it was suppressed
-            // because the annotation has no valid reassignment targets)
-            if (annid == null) return;
-            ulabel.hide_global_edit_suggestion();
-            ulabel.show_id_dialog(
-                ulabel.get_global_mouse_x(click_event),
-                ulabel.get_global_mouse_y(click_event),
-                annid,
-                false,
-            );
-        },
-    );
-
-    $(document).on(
-        "click" + ULABEL_NAMESPACE,
-        "#" + ulabel.config["annbox_id"] + " .delete_suggestion",
-        () => {
-            const crst = ulabel.get_current_subtask();
-            ulabel.delete_annotation(crst["state"]["move_candidate"]!["annid"]);
+            ulabel.handle_id_dialog_click(click_event);
         },
     );
 
@@ -668,8 +747,8 @@ export function create_ulabel_listeners(
             // of them doesn't count as leaving.
             if (ulabel.drag_state["active_key"] !== null) return;
             const state = ulabel.get_current_subtask()["state"];
-            // A clicked-open id dialog is its own interaction; don't yank it away
-            if (state["idd_visible"] && !state["idd_thumbnail"]) return;
+            // A clicked-open id dialog or context menu is its own interaction; don't yank it away
+            if (state["idd_visible"] || ulabel.is_context_menu_open()) return;
             ulabel.hide_and_clear_action_candidates();
         },
     );
@@ -724,6 +803,14 @@ export function create_ulabel_listeners(
         },
     );
 
+    // Copy / cut the hovered annotation, paste into the current subtask
+    for (const kind of ["copy", "cut", "paste"] as const) {
+        $(document).on(
+            kind + ULABEL_NAMESPACE,
+            (clipboard_event) => handle_clipboard_event(clipboard_event, ulabel, kind),
+        );
+    }
+
     $(window).on(
         "beforeunload" + ULABEL_NAMESPACE,
         () => {
diff --git a/src/subtask.ts b/src/subtask.ts
index 5dc478f8..55309b6a 100644
--- a/src/subtask.ts
+++ b/src/subtask.ts
@@ -17,6 +17,9 @@ export class ULabelSubtask {
     public annotations!: {
         access: { [key: string]: ULabelAnnotation };
         ordering: string[];
+        // `last_edited_at` each host-loaded annotation arrived with, by id.
+        // Absent for in-session creations.
+        loaded_edited_at?: { [key: string]: string | null };
     };
 
     public canvas_fid!: string;
@@ -36,7 +39,6 @@ export class ULabelSubtask {
         idd_associated_annotation: string;
         idd_id: string;
         idd_id_front: string;
-        idd_thumbnail: boolean;
         idd_visible: boolean;
         // Class ids currently rendered in the pies (compatible-class subset)
         idd_displayed_class_ids: number[];
@@ -54,6 +56,8 @@ export class ULabelSubtask {
         // The last non-delete class selected; what class focus follows when
         // `focus_active_class` is set. Defocused annotations are still real data.
         selected_class_id: number | null;
+        // When set, every other annotation in the subtask is hidden (view-only)
+        isolated_annid: string | null;
         defocused_opacity: number;
         // Cache of the layer opacity slider, synced by readjust_subtask_opacities
         layer_opacity: number;
@@ -78,6 +82,10 @@ export class ULabelSubtask {
         public inactive_opacity: number = 0.4,
         /** Focus follows the active class: other classes dim and drop out of input. */
         public focus_active_class: boolean = false,
+        /** Only annotations created or modified since load stay in focus. */
+        public focus_edited: boolean = false,
+        /** Only deprecated annotations stay in focus (and are drawn). */
+        public focus_deprecated: boolean = false,
     ) {
         this.actions = {
             stream: [],
@@ -97,6 +105,8 @@ export class ULabelSubtask {
         );
         ret.read_only = ("read_only" in subtask_json) && (subtask_json["read_only"] === true);
         ret.focus_active_class = subtask_json["focus_active_class"] === true;
+        ret.focus_edited = subtask_json["focus_edited"] === true;
+        ret.focus_deprecated = subtask_json["focus_deprecated"] === true;
         if ("inactive_opacity" in subtask_json && typeof subtask_json["inactive_opacity"] == "number") {
             ret.inactive_opacity = Math.min(Math.max(subtask_json["inactive_opacity"], 0.0), 1.0);
         }
diff --git a/src/toolbox.ts b/src/toolbox.ts
index 652c3971..cbb344d8 100644
--- a/src/toolbox.ts
+++ b/src/toolbox.ts
@@ -297,6 +297,7 @@ export class Toolbox {
                     ${images}
                 </div>
             </div>
+            <div class="deprecated-focus-banner ulabel-hidden">Showing deleted annotations · editing disabled<a href="#" class="deprecated-focus-exit">Exit</a></div>
             <button class="toolbox-collapse-btn" title="${collapse_title}">${collapse_arrow}</button>
             <div id="${ulabel.config["toolbox_id"]}" class="${toolbox_class}">
                 <div class="toolbox-header-container">
diff --git a/src/toolbox_items/annotation_list.ts b/src/toolbox_items/annotation_list.ts
index e2d088f1..dd803566 100644
--- a/src/toolbox_items/annotation_list.ts
+++ b/src/toolbox_items/annotation_list.ts
@@ -16,12 +16,14 @@ import {
     WHOLE_IMAGE_SVG,
 } from "../../src/blobs";
 
+// Eye icon for the per-entry isolate button; `currentColor` follows the theme
+const ISOLATE_SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M1.5 8s2.5-4.5 6.5-4.5S14.5 8 14.5 8s-2.5 4.5-6.5 4.5S1.5 8 1.5 8z"/><circle cx="8" cy="8" r="2"/></svg>`;
+
 /**
  * Toolbox item for displaying and navigating annotations in a list
  */
 export class AnnotationListToolboxItem extends ToolboxItem {
     private ulabel: ULabel;
-    private show_deprecated: boolean = false;
     private group_by_class: boolean = false;
     private is_collapsed: boolean = false;
     private sync_scheduled: boolean = false;
@@ -72,6 +74,58 @@ export class AnnotationListToolboxItem extends ToolboxItem {
             background-color: rgba(0, 128, 255, 0.1);
         }
 
+        #toolbox .annotation-list-show-all-btn {
+            display: none;
+            margin-left: auto;
+            margin-right: 0.5rem;
+            padding: 0.15rem 0.5rem;
+            border: 1px solid rgba(128, 128, 128, 0.5);
+            border-radius: 4px;
+            background: none;
+            color: inherit;
+            font-size: 0.75rem;
+            cursor: pointer;
+        }
+
+        #toolbox .annotation-list-show-all-btn:hover {
+            background-color: rgba(0, 128, 255, 0.1);
+        }
+
+        #toolbox .annotation-list-item-isolate {
+            display: inline-flex;
+            flex-shrink: 0;
+            width: 20px;
+            height: 20px;
+            padding: 2px;
+            border: none;
+            border-radius: 4px;
+            background: none;
+            color: inherit;
+            opacity: 0.4;
+            cursor: pointer;
+        }
+
+        #toolbox .annotation-list-item-isolate svg {
+            width: 100%;
+            height: 100%;
+        }
+
+        #toolbox .annotation-list-item-isolate:hover {
+            opacity: 1;
+            background-color: rgba(0, 128, 255, 0.15);
+        }
+
+        #toolbox .annotation-list-item-isolate.active {
+            opacity: 1;
+            color: rgb(0, 128, 255);
+        }
+
+        #toolbox .annotation-list-item-deprecated {
+            flex-shrink: 0;
+            color: gray;
+            cursor: help;
+        }
+
         #toolbox .annotation-list-content {
             display: block;
             padding: 0 1rem;
@@ -269,11 +323,9 @@ export class AnnotationListToolboxItem extends ToolboxItem {
             this.update_list();
         });
 
-        // Show/hide deprecated annotations checkbox
+        // Deprecated focus lives on the subtask, so the canvas follows the list
         $(document).on("change.ulabel", "#annotation-list-show-deprecated", (e) => {
-            this.show_deprecated = (e.target as HTMLInputElement).checked;
-            set_local_storage_item("ulabel_annotation_list_show_deprecated", this.show_deprecated ? "true" : "false");
-            this.update_list();
+            this.ulabel.set_focus_deprecated(this.ulabel.get_current_subtask_key(), (e.target as HTMLInputElement).checked);
         });
 
         // Group by class checkbox
@@ -283,6 +335,11 @@ export class AnnotationListToolboxItem extends ToolboxItem {
             this.update_list();
         });
 
+        // Edit focus lives on the subtask, so the canvas dims with the list
+        $(document).on("change.ulabel", "#annotation-list-edited-only", (e) => {
+            this.ulabel.set_focus_edited(this.ulabel.get_current_subtask_key(), (e.target as HTMLInputElement).checked);
+        });
+
         // Click on annotation list item to fly to it
         $(document).on("click.ulabel", ".annotation-list-item", (e) => {
             const annotation_id = $(e.currentTarget).data("annotation-id");
@@ -291,34 +348,34 @@ export class AnnotationListToolboxItem extends ToolboxItem {
             }
         });
 
+        // Per-entry isolate toggle; must not bubble into the fly-to click above
+        $(document).on("click.ulabel", ".annotation-list-item-isolate", (e) => {
+            e.stopPropagation();
+            const annotation_id = $(e.currentTarget).closest(".annotation-list-item").data("annotation-id");
+            if (!annotation_id) return;
+            const id = String(annotation_id);
+            this.ulabel.isolate_annotation(this.ulabel.get_isolated_annotation_id() === id ? null : id);
+        });
+
+        // Header button; must not bubble into the collapse toggle
+        $(document).on("click.ulabel", "#annotation-list-show-all", (e) => {
+            e.stopPropagation();
+            this.ulabel.isolate_annotation(null);
+        });
+
         // Hover on annotation list item to highlight annotation on canvas
         $(document).on("mouseenter.ulabel", ".annotation-list-item", (e) => {
+            if (this.ulabel.is_context_menu_open()) return;
             const annotation_id = $(e.currentTarget).data("annotation-id");
             if (annotation_id) {
-                // Highlight this list item
-                $(".annotation-list-item").removeClass("highlighted");
-                $(e.currentTarget).addClass("highlighted");
-
-                // Show the global edit suggestion (ID dialog)
-                this.ulabel.show_global_edit_suggestion(annotation_id, null, null);
-
-                // Set edit_candidate to allow delete keybind to work
-                const current_subtask = this.ulabel.get_current_subtask();
-                const annotation = current_subtask.annotations.access[annotation_id];
-                if (annotation && !annotation.deprecated) {
-                    current_subtask.state.edit_candidate = {
-                        annid: annotation.id!,
-                        spatial_type: annotation.spatial_type!,
-                        access: 0,
-                        distance: 0,
-                        point: [0, 0],
-                    };
-                }
+                this.highlight_from_list(String(annotation_id));
             }
         });
 
         // Remove highlight when mouse leaves the list item
         $(document).on("mouseleave.ulabel", ".annotation-list-item", () => {
+            // The menu holds the highlight until it closes
+            if (this.ulabel.is_context_menu_open()) return;
             $(".annotation-list-item").removeClass("highlighted");
             // Clear the edit candidate and edit suggestion
             const current_subtask = this.ulabel.get_current_subtask();
@@ -327,6 +384,16 @@ export class AnnotationListToolboxItem extends ToolboxItem {
             this.ulabel.hide_edit_suggestion();
         });
 
+        // Right-click a list item for its context menu. The mousedown just before
+        // dismissed any open menu (and its hover), so re-highlight first.
+        $(document).on("contextmenu.ulabel", ".annotation-list-item", (e) => {
+            e.preventDefault();
+            const annotation_id = $(e.currentTarget).data("annotation-id");
+            if (!annotation_id || this.ulabel.get_current_subtask().state.active_id != null) return;
+            this.highlight_from_list(String(annotation_id));
+            this.ulabel.show_context_menu(String(annotation_id), e.clientX!, e.clientY!);
+        });
+
         // Listen for mousemove on the annbox to sync list highlighting from canvas
         $(document).on("mousemove.ulabel", `#${this.ulabel.config.annbox_id}`, () => {
             // Use requestAnimationFrame to avoid excessive calls
@@ -357,6 +424,11 @@ export class AnnotationListToolboxItem extends ToolboxItem {
 
         if (!content || !toggle_btn) return;
 
+        const show_all_btn = document.querySelector<HTMLButtonElement>("#annotation-list-show-all");
+        if (show_all_btn) {
+            show_all_btn.style.display = this.ulabel.get_isolated_annotation_id() != null ? "inline-block" : "none";
+        }
+
         // Update toggle button
         toggle_btn.innerText = this.is_collapsed ? "▼" : "▲";
         content.style.display = this.is_collapsed ? "none" : "block";
@@ -367,6 +439,12 @@ export class AnnotationListToolboxItem extends ToolboxItem {
         const current_subtask = this.ulabel.get_current_subtask();
         if (!current_subtask) return;
 
+        // The keybind, API, and subtask switches all change it outside the checkbox
+        const edited_only_input = document.querySelector<HTMLInputElement>("#annotation-list-edited-only");
+        if (edited_only_input) edited_only_input.checked = current_subtask.focus_edited === true;
+        const show_deprecated_input = document.querySelector<HTMLInputElement>("#annotation-list-show-deprecated");
+        if (show_deprecated_input) show_deprecated_input.checked = current_subtask.focus_deprecated === true;
+
         // Build the list HTML
         const list_container = document.querySelector<HTMLDivElement>("#annotation-list-container");
         if (!list_container) return;
@@ -395,11 +473,7 @@ export class AnnotationListToolboxItem extends ToolboxItem {
         for (const annotation_id of subtask.annotations.ordering) {
             const annotation = subtask.annotations.access[annotation_id];
 
-            // Skip deprecated annotations unless the option to show them is enabled
-            if (!this.show_deprecated && annotation.deprecated) {
-                continue;
-            }
-
+            // Deprecated annotations are in focus only under deprecated focus
             if (this.ulabel.is_annotation_defocused(annotation, subtask_key)) {
                 continue;
             }
@@ -433,6 +507,8 @@ export class AnnotationListToolboxItem extends ToolboxItem {
                             <span class="annotation-list-item-class">${class_name}</span>
                             <span class="annotation-list-item-id">#${i}</span>
                         </div>
+                        ${this.build_deprecated_marker_html(annotation)}
+                        ${this.build_isolate_button_html(annotation)}
                     </div>
                 </div>
             `;
@@ -508,6 +584,8 @@ export class AnnotationListToolboxItem extends ToolboxItem {
                             <div class="annotation-list-item-text">
                                 <span class="annotation-list-item-id">#${i}</span>
                             </div>
+                            ${this.build_deprecated_marker_html(annotation)}
+                            ${this.build_isolate_button_html(annotation)}
                         </div>
                     </div>
                 `;
@@ -519,6 +597,20 @@ export class AnnotationListToolboxItem extends ToolboxItem {
         return html;
     }
 
+    private build_deprecated_marker_html(annotation: ULabelAnnotation): string {
+        if (!annotation.deprecated) return "";
+        const sources = Object.entries(annotation.deprecated_by ?? {}).filter(([, value]) => value).map(([key]) => key);
+        // deprecated_by keys can come from loaded JSON
+        const title = `Deprecated by: ${sources.join(", ")}`.replace(/[&<>"']/g, (c) => `&#${c.charCodeAt(0)};`);
+        return `<span class="annotation-list-item-deprecated" title="${title}">&#8856;</span>`;
+    }
+
+    private build_isolate_button_html(annotation: ULabelAnnotation): string {
+        const active = this.ulabel.get_isolated_annotation_id() === annotation.id;
+        const title = active ? "Show all annotations" : "Isolate this annotation";
+        return `<button class="annotation-list-item-isolate${active ? " active" : ""}" title="${title}">${ISOLATE_SVG}</button>`;
+    }
+
     /**
      * Get the SVG icon for a given spatial type
      */
@@ -615,6 +707,7 @@ export class AnnotationListToolboxItem extends ToolboxItem {
             <div class="toolbox-divider"></div>
             <div class="annotation-list-header">
                 <h3 class="annotation-list-title">Annotation List</h3>
+                <button id="annotation-list-show-all" class="annotation-list-show-all-btn">Show all</button>
                 <button id="annotation-list-toggle" class="annotation-list-toggle-btn">▲</button>
             </div>
             <div id="annotation-list-content" class="annotation-list-content">
@@ -627,6 +720,10 @@ export class AnnotationListToolboxItem extends ToolboxItem {
                         <input type="checkbox" id="annotation-list-group-by-class" />
                         <label for="annotation-list-group-by-class">Group by Class</label>
                     </div>
+                    <div class="annotation-list-option">
+                        <input type="checkbox" id="annotation-list-edited-only" />
+                        <label for="annotation-list-edited-only">Edited Only</label>
+                    </div>
                 </div>
                 <div id="annotation-list-container" class="annotation-list-container">
                     <div class="annotation-list-empty">No annotations</div>
@@ -665,13 +762,6 @@ export class AnnotationListToolboxItem extends ToolboxItem {
             this.is_collapsed = true;
         }
 
-        const stored_show_deprecated = get_local_storage_item("ulabel_annotation_list_show_deprecated");
-        if (stored_show_deprecated === "true") {
-            this.show_deprecated = true;
-        } else if (stored_show_deprecated === "false") {
-            this.show_deprecated = false;
-        }
-
         const stored_group_by_class = get_local_storage_item("ulabel_annotation_list_group_by_class");
         if (stored_group_by_class === "true") {
             this.group_by_class = true;
@@ -680,8 +770,6 @@ export class AnnotationListToolboxItem extends ToolboxItem {
         }
 
         // Reflect restored values into the checkbox DOM so the UI matches state.
-        const show_deprecated_input = document.querySelector<HTMLInputElement>("#annotation-list-show-deprecated");
-        if (show_deprecated_input) show_deprecated_input.checked = this.show_deprecated;
         const group_by_class_input = document.querySelector<HTMLInputElement>("#annotation-list-group-by-class");
         if (group_by_class_input) group_by_class_input.checked = this.group_by_class;
     }
@@ -702,6 +790,30 @@ export class AnnotationListToolboxItem extends ToolboxItem {
         this.sync_highlight_from_canvas();
     }
 
+    /**
+     * Make a list entry the hovered annotation: list highlight, canvas outline
+     * and card, and the edit candidate the keybinds act on.
+     */
+    private highlight_from_list(annotation_id: string) {
+        $(".annotation-list-item").removeClass("highlighted");
+        $(`.annotation-list-item[data-annotation-id="${annotation_id}"]`).addClass("highlighted");
+
+        this.ulabel.show_global_edit_suggestion(annotation_id, null, null);
+
+        const current_subtask = this.ulabel.get_current_subtask();
+        const annotation = current_subtask.annotations.access[annotation_id];
+        // The list only shows in-focus annotations, deprecated ones included under deprecated focus
+        if (annotation) {
+            current_subtask.state.edit_candidate = {
+                annid: annotation.id!,
+                spatial_type: annotation.spatial_type!,
+                access: 0,
+                distance: 0,
+                point: [0, 0],
+            };
+        }
+    }
+
     /**
      * Sync highlighting from canvas hover to list
      * Called when the edit_candidate changes on the canvas
diff --git a/src/toolbox_items/keybinds.ts b/src/toolbox_items/keybinds.ts
index 4a9376bf..703fb568 100644
--- a/src/toolbox_items/keybinds.ts
+++ b/src/toolbox_items/keybinds.ts
@@ -348,6 +348,22 @@ export class KeybindsToolboxItem extends ToolboxItem {
             config_key: "toggle_class_focus_keybind",
         });
 
+        keybinds.push({
+            key: config.toggle_edit_focus_keybind,
+            label: "Toggle Edit Focus",
+            description: "Focus edits: annotations unchanged since load dim and drop out of hover and navigation",
+            configurable: true,
+            config_key: "toggle_edit_focus_keybind",
+        });
+
+        keybinds.push({
+            key: config.toggle_deprecated_focus_keybind,
+            label: "Toggle Show Deprecated",
+            description: "Show deleted annotations for restoring; other editing is disabled",
+            configurable: true,
+            config_key: "toggle_deprecated_focus_keybind",
+        });
+
         keybinds.push({
             key: config.create_bbox_on_initial_crop_keybind,
             label: "Create BBox on Crop",
@@ -530,6 +546,15 @@ export class KeybindsToolboxItem extends ToolboxItem {
             configurable: false,
         });
 
+        if (config.allow_body_move) {
+            keybinds.push({
+                key: "Alt + Click Drag",
+                label: "Draw Over",
+                description: "Start a new annotation on top of an existing one instead of moving it",
+                configurable: false,
+            });
+        }
+
         // Scroll combinations
         keybinds.push({
             key: "Scroll",
diff --git a/src/toolbox_items/submit_buttons.ts b/src/toolbox_items/submit_buttons.ts
index 2a03b0b7..fee29fca 100644
--- a/src/toolbox_items/submit_buttons.ts
+++ b/src/toolbox_items/submit_buttons.ts
@@ -2,6 +2,7 @@ import type { ULabelSubmitButton } from "../../index";
 // Import ULabel from ../../src/index - TypeScript will find ../../src/index.d.ts for types
 import { ULabel } from "../../src/index";
 import { ULabelAnnotation, DELETE_MODES, NONSPATIAL_MODES } from "../annotation";
+import type { ULabelEditType } from "../annotation";
 import { ToolboxItem } from "../toolbox";
 import { log_message, LogLevel } from "../error_logging";
 
@@ -59,57 +60,7 @@ export class SubmitButtons extends ToolboxItem {
                 button.appendChild(animation);
 
                 // Create the submit payload
-                const submit_payload: { task_meta: object | null; annotations: Record<string, ULabelAnnotation[]> } = {
-                    task_meta: ulabel.config["task_meta"],
-                    annotations: {},
-                };
-
-                // Loop through all of the subtasks
-                for (const stkey in ulabel.subtasks) {
-                    submit_payload["annotations"][stkey] = [];
-
-                    // Add all of the annotations in that subtask
-                    let annotation: ULabelAnnotation | null = null;
-                    let temp_annotation: ULabelAnnotation | object;
-                    for (let i = 0; i < ulabel.subtasks[stkey]["annotations"]["ordering"].length; i++) {
-                        temp_annotation = ulabel.subtasks[stkey]["annotations"]["access"][ulabel.subtasks[stkey]["annotations"]["ordering"][i]];
-                        // Validate the annotation
-                        if (typeof temp_annotation === "object") {
-                            try {
-                                annotation = ULabelAnnotation.from_json(temp_annotation);
-                            } catch (e) {
-                                log_message(`Error validating annotation ${temp_annotation} during submit: ${e}.`, LogLevel.ERROR, true);
-                                continue;
-                            }
-                        }
-
-                        // Handle null
-                        if (annotation === null) {
-                            continue;
-                        }
-
-                        // Skip any delete modes
-                        if (DELETE_MODES.includes(annotation.spatial_type!)) {
-                            continue;
-                        }
-
-                        // Skip spatial annotations that have an empty spatial payload
-                        if (NONSPATIAL_MODES.includes(annotation.spatial_type!) ||
-                            annotation.spatial_payload.length === 0) {
-                            continue;
-                        }
-
-                        // Ensure annotation is within the image if required
-                        if (!ulabel.config.allow_annotations_outside_image) {
-                            annotation.clamp_annotation_to_image_bounds(
-                                ulabel.config["image_width"]!,
-                                ulabel.config["image_height"]!,
-                            );
-                        }
-
-                        submit_payload["annotations"][stkey].push(annotation);
-                    }
-                }
+                const submit_payload = SubmitButtons.build_submit_payload(ulabel, this.submit_buttons[idx]);
 
                 // Set set_saved if it was provided
                 if (this.submit_buttons[idx].set_saved) {
@@ -130,6 +81,121 @@ export class SubmitButtons extends ToolboxItem {
         }
     }
 
+    /**
+     * Build the payload passed to a submit button's hook, honoring the button's
+     * `subtasks` whitelist and `edits_only` filter.
+     */
+    public static build_submit_payload(
+        ulabel: ULabel,
+        button: Pick<ULabelSubmitButton, "subtasks" | "edits_only"> = {},
+    ): { task_meta: object | null; annotations: Record<string, ULabelAnnotation[]> } {
+        const submit_payload: { task_meta: object | null; annotations: Record<string, ULabelAnnotation[]> } = {
+            task_meta: ulabel.config["task_meta"],
+            annotations: {},
+        };
+
+        let subtask_keys = Object.keys(ulabel.subtasks);
+        if (button.subtasks !== undefined) {
+            for (const key of button.subtasks) {
+                if (!(key in ulabel.subtasks)) {
+                    log_message(`Submit button subtasks: unknown subtask "${key}"`, LogLevel.WARNING);
+                }
+            }
+            subtask_keys = subtask_keys.filter((key) => button.subtasks!.includes(key));
+        }
+
+        for (const stkey of subtask_keys) {
+            submit_payload["annotations"][stkey] = [];
+            const subtask_annotations = ulabel.subtasks[stkey]["annotations"];
+            const loaded_edited_at = subtask_annotations["loaded_edited_at"] ?? {};
+
+            // Add all of the annotations in that subtask
+            let annotation: ULabelAnnotation | null = null;
+            let temp_annotation: ULabelAnnotation | object;
+            for (let i = 0; i < subtask_annotations["ordering"].length; i++) {
+                const annotation_id = subtask_annotations["ordering"][i];
+                temp_annotation = subtask_annotations["access"][annotation_id];
+                if (typeof temp_annotation !== "object" || temp_annotation === null) {
+                    continue;
+                }
+
+                // Skip delete modes and nonspatial annotations (nonspatial may have a null payload)
+                const raw_spatial_type = (<ULabelAnnotation>temp_annotation).spatial_type!;
+                if (DELETE_MODES.includes(raw_spatial_type) || NONSPATIAL_MODES.includes(raw_spatial_type)) {
+                    continue;
+                }
+
+                // Classify before geometry validation: a fully erased loaded
+                // polygon has no valid geometry but still owes the host a deletion
+                let edit_type: ULabelEditType | null = null;
+                if (button.edits_only) {
+                    edit_type = SubmitButtons.classify_edit(
+                        <ULabelAnnotation>temp_annotation,
+                        loaded_edited_at[annotation_id],
+                    );
+                    if (edit_type === null) {
+                        continue;
+                    }
+                }
+
+                // Validate the annotation
+                try {
+                    annotation = ULabelAnnotation.from_json(temp_annotation);
+                } catch (e) {
+                    log_message(`Error validating annotation ${temp_annotation} during submit: ${e}.`, LogLevel.ERROR, true);
+                    annotation = null;
+                }
+
+                const has_geometry = annotation !== null && annotation.spatial_payload.length !== 0;
+                if (!has_geometry) {
+                    if (edit_type !== "deleted") {
+                        continue;
+                    }
+                    annotation = Object.assign(new ULabelAnnotation(), temp_annotation);
+                }
+
+                // Never echo a stale marker a host may have round-tripped through resume_from
+                delete annotation!.edit_type;
+
+                if (edit_type !== null) {
+                    annotation!.edit_type = edit_type;
+                    // Display filters must not read as deletions to the host
+                    annotation!.deprecated = edit_type === "deleted";
+                }
+
+                // Ensure annotation is within the image if required
+                if (has_geometry && !ulabel.config.allow_annotations_outside_image) {
+                    annotation!.clamp_annotation_to_image_bounds(
+                        ulabel.config["image_width"]!,
+                        ulabel.config["image_height"]!,
+                    );
+                }
+
+                submit_payload["annotations"][stkey].push(annotation!);
+            }
+        }
+
+        return submit_payload;
+    }
+
+    /**
+     * Decide how an `edits_only` payload reports an annotation, or null to omit it.
+     * Only human deletion counts; filter deprecation is display state.
+     */
+    public static classify_edit(
+        annotation: ULabelAnnotation,
+        loaded_at: string | null | undefined,
+    ): ULabelEditType | null {
+        const human_deleted = annotation.deprecated_by?.human === true;
+        if (loaded_at === undefined) {
+            return human_deleted ? null : "created";
+        }
+        if (annotation.last_edited_at === loaded_at) {
+            return null;
+        }
+        return human_deleted ? "deleted" : "modified";
+    }
+
     /**
      * Group submit buttons by row number
      *
diff --git a/src/utilities.ts b/src/utilities.ts
index 0558c5c7..78d1367f 100644
--- a/src/utilities.ts
+++ b/src/utilities.ts
@@ -43,9 +43,9 @@ export function time_function<T, R>(
     return replacement_method;
 }
 
-export function get_active_class_id(ulabel: ULabel): number | undefined {
-    // Grab the current subtask from the ulabel object
-    const current_subtask_key: string = ulabel.state.current_subtask;
+export function get_active_class_id(ulabel: ULabel, subtask_key: string | null = null): number | undefined {
+    // Grab the subtask from the ulabel object, defaulting to the current one
+    const current_subtask_key: string = subtask_key ?? ulabel.state.current_subtask;
     const current_subtask: ULabelSubtask = ulabel.subtasks[current_subtask_key];
 
     // If in single_class_mode return the only valid class id
diff --git a/src/version.js b/src/version.js
index 94675c01..80a83da4 100644
--- a/src/version.js
+++ b/src/version.js
@@ -1 +1 @@
-export const ULABEL_VERSION = "0.28.0";
+export const ULABEL_VERSION = "0.29.0";
diff --git a/tests/body_move.test.js b/tests/body_move.test.js
new file mode 100644
index 00000000..be9c3070
--- /dev/null
+++ b/tests/body_move.test.js
@@ -0,0 +1,341 @@
+// Unit tests for body-drag move: a plain left-drag on an annotation's body
+// moves it, a modifier forces a draw, and a click with no drag leaves no trace.
+const { ULabel } = require("./testing-utils/build_loader");
+
+function make_config(overrides = {}) {
+    return {
+        container_id: "container",
+        image_data: "test.jpg",
+        username: "test_user",
+        submit_buttons: [{ name: "Submit", hook: jest.fn() }],
+        subtasks: {
+            st: {
+                display_name: "A",
+                classes: [{ name: "Crop", id: 1, color: "green" }],
+                allowed_modes: ["bbox", "polygon", "delete_bbox"],
+                resume_from: null,
+            },
+        },
+        ...overrides,
+    };
+}
+
+// `current_subtask` is only set by init()/set_subtask, which need a real DOM.
+function make_ulabel(config = make_config()) {
+    const ulabel = new ULabel(config);
+    ulabel.state.current_subtask = "st";
+    return ulabel;
+}
+
+function canvas_mousedown(ulabel, modifiers = {}) {
+    return {
+        button: 0,
+        target: { id: ulabel.subtasks.st.canvas_fid },
+        ctrlKey: false,
+        metaKey: false,
+        shiftKey: false,
+        altKey: false,
+        ...modifiers,
+    };
+}
+
+function hover(ulabel, containing) {
+    ulabel.subtasks.st.state.move_candidate = {
+        annid: "a0",
+        spatial_type: "bbox",
+        access: 0,
+        distance: 0,
+        point: [5, 5],
+        containing,
+    };
+}
+
+describe("segment insert handle", () => {
+    function nearest(x, y) {
+        const ulabel = make_ulabel();
+        ulabel.get_empirical_scale = () => 1;
+        ulabel.subtasks.st.annotations = {
+            access: { l: { id: "l", spatial_type: "polyline", spatial_payload: [[10, 10], [200, 10], [200, 200]] } },
+            ordering: ["l"],
+        };
+        return ulabel.get_nearest_segment_point(x, y, Infinity, ["l"]);
+    }
+
+    test("sits at the midpoint of the hovered segment", () => {
+        expect(nearest(50, 15)).toMatchObject({ access: "0.5", point: [105, 10] });
+    });
+
+    test("projecting onto the final endpoint stays on the last segment", () => {
+        expect(nearest(210, 200)).toMatchObject({ access: "1.5", point: [200, 105] });
+    });
+});
+
+describe("get_drag_key_start body move", () => {
+    test("a containing hit starts a move", () => {
+        const ulabel = make_ulabel();
+        hover(ulabel, true);
+
+        expect(ULabel.get_drag_key_start(canvas_mousedown(ulabel), ulabel)).toBe("move");
+    });
+
+    test("a near-miss on the containing box starts a draw", () => {
+        const ulabel = make_ulabel();
+        hover(ulabel, false);
+
+        expect(ULabel.get_drag_key_start(canvas_mousedown(ulabel), ulabel)).toBe("annotation");
+    });
+
+    test("no hover candidate starts a draw", () => {
+        const ulabel = make_ulabel();
+        ulabel.subtasks.st.state.move_candidate = null;
+
+        expect(ULabel.get_drag_key_start(canvas_mousedown(ulabel), ulabel)).toBe("annotation");
+    });
+
+    test("the force-draw modifier draws over a containing hit", () => {
+        const ulabel = make_ulabel();
+        hover(ulabel, true);
+
+        expect(ULabel.get_drag_key_start(canvas_mousedown(ulabel, { altKey: true }), ulabel)).toBe("annotation");
+    });
+
+    test("allow_body_move: false restores draw-everywhere", () => {
+        const ulabel = make_ulabel(make_config({ allow_body_move: false }));
+        hover(ulabel, true);
+
+        expect(ULabel.get_drag_key_start(canvas_mousedown(ulabel), ulabel)).toBe("annotation");
+    });
+
+    test("delete modes drag over bodies without moving them", () => {
+        const ulabel = make_ulabel();
+        hover(ulabel, true);
+        ulabel.subtasks.st.state.annotation_mode = "delete_bbox";
+
+        expect(ULabel.get_drag_key_start(canvas_mousedown(ulabel), ulabel)).toBe("annotation");
+    });
+
+    test("read-only subtasks are inert", () => {
+        const ulabel = make_ulabel();
+        hover(ulabel, true);
+        ulabel.subtasks.st.read_only = true;
+
+        expect(ULabel.get_drag_key_start(canvas_mousedown(ulabel), ulabel)).toBeNull();
+    });
+
+    test("ctrl pans and shift zooms before body move is considered", () => {
+        const ulabel = make_ulabel();
+        hover(ulabel, true);
+
+        expect(ULabel.get_drag_key_start(canvas_mousedown(ulabel, { ctrlKey: true }), ulabel)).toBe("pan");
+        expect(ULabel.get_drag_key_start(canvas_mousedown(ulabel, { shiftKey: true }), ulabel)).toBe("zoom");
+    });
+
+    test("a vertex handle under the cursor still edits", () => {
+        const ulabel = make_ulabel();
+        hover(ulabel, true);
+        const handle = document.createElement("a");
+        handle.className = "editable";
+
+        expect(ULabel.get_drag_key_start({ button: 0, target: handle }, ulabel)).toBe("edit");
+    });
+});
+
+describe("get_edit_candidates containing hits per spatial type", () => {
+    function load(ulabel, annotation) {
+        ulabel.subtasks.st.annotations = {
+            access: { [annotation.id]: annotation },
+            ordering: [annotation.id],
+        };
+        ulabel.get_empirical_scale = () => 1;
+        ulabel.get_subtask_line_size = () => 4;
+        ulabel.state.current_frame = 0;
+    }
+
+    function containing_at(ulabel, x, y) {
+        return ulabel.get_edit_candidates(x, y, 20).best?.containing ?? null;
+    }
+
+    test("contour: on the stroke moves, inside its box but off the stroke does not", () => {
+        const ulabel = make_ulabel();
+        load(ulabel, {
+            id: "c", spatial_type: "contour", deprecated: false,
+            spatial_payload: [[10, 10], [50, 10], [50, 50]],
+            containing_box: { tlx: 10, tly: 10, brx: 50, bry: 50 },
+            classification_payloads: [{ class_id: 1, confidence: 1 }],
+        });
+
+        expect(containing_at(ulabel, 30, 11)).toBe(true);
+        expect(containing_at(ulabel, 20, 40)).toBe(false);
+    });
+
+    test("tbar: stem and cross bar move, the empty quadrant does not", () => {
+        const ulabel = make_ulabel();
+        // Stem from (400,300) straight down to (400,600); cross bar spans x 250..550 at y=300
+        load(ulabel, {
+            id: "t", spatial_type: "tbar", deprecated: false,
+            spatial_payload: [[400, 300], [400, 600]],
+            containing_box: null,
+            classification_payloads: [{ class_id: 1, confidence: 1 }],
+        });
+        ulabel.rebuild_containing_box("t", false, "st");
+
+        const box = ulabel.subtasks.st.annotations.access.t.containing_box;
+        expect(box.tlx).toBeLessThanOrEqual(250);
+        expect(box.brx).toBeGreaterThanOrEqual(550);
+
+        expect(containing_at(ulabel, 400, 450)).toBe(true);
+        expect(containing_at(ulabel, 280, 300)).toBe(true);
+        expect(containing_at(ulabel, 520, 300)).toBe(true);
+        expect(containing_at(ulabel, 500, 500)).toBe(false);
+    });
+
+    test("bbox3: inside the x/y box on a covered frame moves", () => {
+        const ulabel = make_ulabel();
+        load(ulabel, {
+            id: "b3", spatial_type: "bbox3", deprecated: false,
+            spatial_payload: [[10, 10, 0], [50, 50, 2]],
+            containing_box: { tlx: 10, tly: 10, brx: 50, bry: 50 },
+            classification_payloads: [{ class_id: 1, confidence: 1 }],
+        });
+
+        expect(containing_at(ulabel, 30, 30)).toBe(true);
+        expect(containing_at(ulabel, 55, 30)).toBe(false);
+    });
+});
+
+describe("zero-diff body click", () => {
+    function load_bbox(ulabel) {
+        const annotation = {
+            id: "a0",
+            spatial_type: "bbox",
+            spatial_payload: [[10, 10], [50, 50]],
+            containing_box: { tlx: 10, tly: 10, brx: 50, bry: 50 },
+            classification_payloads: [{ class_id: 1, confidence: 1 }],
+            deprecated: false,
+            last_edited_at: "before",
+            last_edited_by: "someone",
+        };
+        ulabel.subtasks.st.annotations = {
+            access: { a0: annotation },
+            ordering: ["a0"],
+        };
+        return annotation;
+    }
+
+    function stub_rendering(ulabel) {
+        ulabel.redraw_annotation = jest.fn();
+        ulabel.redraw_all_annotations_in_annotation_context = jest.fn();
+        ulabel.rebuild_containing_box = jest.fn();
+        ulabel.update_filter_distance_during_polyline_move = jest.fn();
+        ulabel.update_filter_distance = jest.fn();
+        ulabel.suggest_edits = jest.fn();
+        ulabel.toolbox = { redraw_update_items: jest.fn() };
+    }
+
+    function click_body(ulabel, dx = 0, dy = 0) {
+        hover(ulabel, true);
+        ulabel.drag_state.move.mouse_start = [100, 100, 0];
+        ulabel.begin_move({ clientX: 100, clientY: 100 });
+        ulabel.finish_move({ clientX: 100 + dx, clientY: 100 + dy });
+    }
+
+    test("leaves the undo stream, redo stack and saved state untouched", () => {
+        const ulabel = make_ulabel();
+        const annotation = load_bbox(ulabel);
+        stub_rendering(ulabel);
+        const undone = { act_type: "delete_annotation", annotation_id: "zz", undo_payload: "{}", redo_payload: "{}" };
+        ulabel.subtasks.st.actions.undone_stack = [undone];
+        ulabel.set_saved(true);
+
+        click_body(ulabel);
+
+        expect(ulabel.subtasks.st.actions.stream).toEqual([]);
+        expect(ulabel.subtasks.st.actions.undone_stack).toEqual([undone]);
+        expect(ulabel.state.edited).toBe(false);
+        expect(annotation.last_edited_at).toBe("before");
+        expect(annotation.last_edited_by).toBe("someone");
+        expect(annotation.spatial_payload).toEqual([[10, 10], [50, 50]]);
+        expect(ulabel.subtasks.st.state.active_id).toBeNull();
+        expect(ulabel.subtasks.st.state.is_in_move).toBe(false);
+    });
+
+    test("a real drag still records one begin_move and marks the state edited", () => {
+        const ulabel = make_ulabel();
+        const annotation = load_bbox(ulabel);
+        stub_rendering(ulabel);
+        ulabel.set_saved(true);
+
+        click_body(ulabel, 20, 10);
+
+        expect(ulabel.subtasks.st.actions.stream.map((a) => a.act_type)).toEqual(["begin_move"]);
+        expect(ulabel.state.edited).toBe(true);
+        expect(annotation.spatial_payload).toEqual([[30, 20], [70, 60]]);
+    });
+
+    test("undo flies to where the move put the annotation back, not where it was moved to", () => {
+        const ulabel = make_ulabel();
+        load_bbox(ulabel);
+        stub_rendering(ulabel);
+        delete ulabel.rebuild_containing_box;
+        ulabel.hide_id_dialog = jest.fn();
+        ulabel.fly_to_boxes_if_offscreen = jest.fn();
+
+        click_body(ulabel, 200, 0);
+        ulabel.undo();
+
+        const [boxes] = ulabel.fly_to_boxes_if_offscreen.mock.calls.at(-1);
+        expect(boxes).toHaveLength(1);
+        expect(boxes[0].tlx).toBeLessThanOrEqual(10);
+        expect(boxes[0].brx).toBeLessThan(200);
+    });
+
+    // Ctrl+Z while the mouse is still held finishes the pending begin_move
+    // first; with no movement that drops it, and undo must stop there.
+    function hold_body(ulabel) {
+        hover(ulabel, true);
+        ulabel.drag_state.move.mouse_start = [100, 100, 0];
+        ulabel.drag_state.active_key = "move";
+        ulabel.state.last_move = { clientX: 100, clientY: 100 };
+        ulabel.begin_move({ clientX: 100, clientY: 100 });
+    }
+
+    test("undo during a stationary body click with no history does not throw", () => {
+        const ulabel = make_ulabel();
+        load_bbox(ulabel);
+        stub_rendering(ulabel);
+        ulabel.hide_id_dialog = jest.fn();
+
+        hold_body(ulabel);
+        expect(() => ulabel.undo()).not.toThrow();
+
+        expect(ulabel.subtasks.st.actions.stream).toEqual([]);
+        expect(ulabel.subtasks.st.actions.undone_stack).toEqual([]);
+        expect(ulabel.subtasks.st.state.is_in_move).toBe(false);
+    });
+
+    test("undo during a stationary body click leaves the preceding action and its redo intact", () => {
+        const ulabel = make_ulabel();
+        load_bbox(ulabel);
+        stub_rendering(ulabel);
+        ulabel.hide_id_dialog = jest.fn();
+        ulabel.destroy_annotation_context = jest.fn();
+        ulabel.get_init_canvas_context_id = jest.fn(() => "c0");
+        ulabel.subtasks.st.state.annotation_contexts = { c0: { context: {}, annotation_ids: [] } };
+        ulabel.create_annotation("bbox", [[60, 60], [80, 80]], "a1");
+        expect(ulabel.subtasks.st.actions.stream.map((a) => a.act_type)).toEqual(["create_annotation"]);
+
+        hold_body(ulabel);
+        ulabel.undo();
+
+        // Only the pending move was cancelled; a1 is still there
+        expect(ulabel.subtasks.st.actions.stream.map((a) => a.act_type)).toEqual(["create_annotation"]);
+        expect(ulabel.subtasks.st.annotations.access.a1).toBeDefined();
+        expect(ulabel.subtasks.st.actions.undone_stack).toEqual([]);
+
+        // A second undo then removes a1, and redo brings it back
+        ulabel.undo();
+        expect(ulabel.subtasks.st.annotations.access.a1).toBeUndefined();
+        ulabel.redo();
+        expect(ulabel.subtasks.st.annotations.access.a1).toBeDefined();
+    });
+});
diff --git a/tests/brush_state.test.js b/tests/brush_state.test.js
index 7b1ca8fc..637abab1 100644
--- a/tests/brush_state.test.js
+++ b/tests/brush_state.test.js
@@ -70,6 +70,19 @@ describe("set_subtask brush teardown", () => {
         expect(ulabel.subtasks.first.state.move_candidate).toBeNull();
         expect(ulabel.subtasks.first.state.edit_candidate).toBeNull();
     });
+
+    test("keeps a brush drag slot after the interaction state resets", () => {
+        const ulabel = make_switchable_ulabel();
+
+        ulabel.set_subtask("second");
+
+        // start_drag("brush", ...) writes into drag_state.brush after any reset
+        expect(ulabel.drag_state.brush).toEqual({
+            mouse_start: null,
+            offset_start: null,
+            zoom_val_start: null,
+        });
+    });
 });
 
 describe("update_brush_toolbox_display", () => {
diff --git a/tests/class_allowed_modes.test.js b/tests/class_allowed_modes.test.js
index a94b52d1..db067d2a 100644
--- a/tests/class_allowed_modes.test.js
+++ b/tests/class_allowed_modes.test.js
@@ -352,14 +352,13 @@ describe("pie class exclusion", () => {
         return annotation;
     }
 
-    // show_id_dialog's non-suppressed path needs the reid button + dialog DOM
+    // show_id_dialog's non-suppressed path needs the dialog DOM
     function scaffold_dialog_dom(ulabel) {
         const idd_id = ulabel.subtasks.st.state.idd_id;
         const idd_id_front = ulabel.subtasks.st.state.idd_id_front;
         document.body.innerHTML = `
             <div id="dialogs__st"><div id="${idd_id}" class="id_dialog"></div></div>
             <div id="front_dialogs__st"><div id="${idd_id_front}" class="id_dialog"></div></div>
-            <div id="global_edit_suggestion__st"><a class="reid_suggestion global_sub_suggestion"></a></div>
         `;
     }
 
@@ -368,7 +367,7 @@ describe("pie class exclusion", () => {
         load_annotation(ulabel, "polyline");
         scaffold_dialog_dom(ulabel);
 
-        ulabel.show_id_dialog(10, 10, "a0", true);
+        ulabel.show_id_dialog(10, 10, "a0");
 
         // Crop (bbox-only) is excluded; Row and Any remain
         expect(ulabel.subtasks.st.state.idd_displayed_class_ids).toEqual([2, 3]);
@@ -384,7 +383,7 @@ describe("pie class exclusion", () => {
         load_annotation(ulabel, "bbox");
         scaffold_dialog_dom(ulabel);
 
-        ulabel.show_id_dialog(10, 10, "a0", true);
+        ulabel.show_id_dialog(10, 10, "a0");
 
         expect(ulabel.subtasks.st.state.idd_visible).toBe(false);
     });
@@ -406,57 +405,6 @@ describe("pie class exclusion", () => {
         // class 2 sits at index 1 of the full class list
         expect(pos_evt.class_ind).toBe(1);
     });
-
-    test("the button ring collapses like single-class mode when nothing can be reassigned", () => {
-        const ulabel = make_ulabel(make_config([CROP, ROW, ANY]));
-        // bbox: only Crop and Any qualify (2 targets); polyline: Row and Any (2 targets);
-        // narrow Any to make bbox single-target
-        ulabel.subtasks.st.class_defs[2].allowed_modes = ["polyline"];
-        const annotation = load_annotation(ulabel, "bbox");
-        annotation.classification_payloads = [
-            { class_id: 1, confidence: 1 },
-            { class_id: 2, confidence: 0 },
-            { class_id: 3, confidence: 0 },
-        ];
-        annotation.containing_box = { tlx: 0, tly: 0, brx: 10, bry: 10 };
-        document.body.innerHTML = `
-            <div id="global_edit_suggestion__st" class="global_edit_suggestion mcm">
-                <a class="move_suggestion global_sub_suggestion"></a>
-                <a class="reid_suggestion global_sub_suggestion"></a>
-                <a class="delete_suggestion global_sub_suggestion"></a>
-            </div>
-        `;
-        ulabel.subtasks.st.state.visible_dialogs["global_edit_suggestion__st"] = { left: 0, top: 0, pin: "center" };
-        ulabel.config.image_width = 100;
-        ulabel.config.image_height = 100;
-
-        // bbox can only be Crop -> compact ring, no reid button
-        ulabel.show_global_edit_suggestion("a0");
-
-        const container = document.getElementById("global_edit_suggestion__st");
-        expect(container.classList.contains("mcm")).toBe(false);
-        expect(document.querySelector("a.reid_suggestion").style.display).toBe("none");
-    });
-
-    test("a thumbnail from the previous hover hides when the next annotation has no targets", () => {
-        const ulabel = make_ulabel(make_config([CROP, ROW, ANY]));
-        ulabel.subtasks.st.class_defs[2].allowed_modes = ["polyline"];
-        const annotation = load_annotation(ulabel, "bbox");
-        annotation.classification_payloads = [{ class_id: 1, confidence: 1 }];
-        annotation.containing_box = { tlx: 0, tly: 0, brx: 10, bry: 10 };
-        document.body.innerHTML = `<div id="global_edit_suggestion__st" class="global_edit_suggestion mcm"></div>`;
-        ulabel.subtasks.st.state.visible_dialogs["global_edit_suggestion__st"] = { left: 0, top: 0, pin: "center" };
-        ulabel.config.image_width = 100;
-        ulabel.config.image_height = 100;
-        // A pie left visible by the previously hovered annotation
-        ulabel.subtasks.st.state.idd_visible = true;
-        ulabel.subtasks.st.state.idd_associated_annotation = "other";
-
-        ulabel.show_global_edit_suggestion("a0");
-
-        expect(ulabel.subtasks.st.state.idd_visible).toBe(false);
-        expect(ulabel.subtasks.st.state.idd_associated_annotation).toBeNull();
-    });
 });
 
 describe("load-time class/type validation", () => {
diff --git a/tests/class_focus.test.js b/tests/class_focus.test.js
index 4b048af5..7a48140d 100644
--- a/tests/class_focus.test.js
+++ b/tests/class_focus.test.js
@@ -202,6 +202,24 @@ describe("delete modes freeze the selection", () => {
         expect(ulabel.is_annotation_defocused(make_annotation(2), "st")).toBe(false);
         expect(ulabel.is_annotation_defocused(make_annotation(1), "st")).toBe(true);
     });
+
+    test("selecting the delete class in a single-class subtask keeps the payload finite", () => {
+        const ulabel = new ULabel({
+            ...delete_config,
+            subtasks: {
+                st: { ...delete_config.subtasks.st, classes: [{ name: "Crop", id: 1, color: "green" }] },
+            },
+        });
+        ulabel.state.current_subtask = "st";
+
+        // Delete class has no index in class_ids, so every class takes the
+        // remainder share; with one class that used to be 0 / 0.
+        ulabel.set_id_dialog_payload_nopin(-1, 1.0);
+
+        const payload = ulabel.subtasks.st.state.id_payload;
+        expect(payload).toHaveLength(1);
+        expect(payload[0].confidence).toBe(0);
+    });
 });
 
 describe("set_focus_active_class", () => {
diff --git a/tests/confidence_card.test.js b/tests/confidence_card.test.js
new file mode 100644
index 00000000..798b5d07
--- /dev/null
+++ b/tests/confidence_card.test.js
@@ -0,0 +1,64 @@
+const { ULabel } = require("./testing-utils/build_loader");
+
+describe.each([0.5, 0.666])("confidence card at dialog scale %s", (scale) => {
+    test("clamps both sides, recenters, and hugs the containing box", () => {
+        document.body.innerHTML = `
+            <div id="annbox">
+                <div id="global_edit_suggestion__st" style="width: 120px;">
+                    <div id="global_annotation_confidence__st" style="width: 160px; height: 80px;"></div>
+                </div>
+            </div>
+        `;
+        const annbox = document.getElementById("annbox");
+        annbox.getBoundingClientRect = () => ({ left: 125 });
+        Object.defineProperties(annbox, {
+            clientLeft: { value: 2 },
+            clientWidth: { value: 400 },
+        });
+        annbox.scrollLeft = 200;
+        annbox.scrollTop = 100;
+
+        const subtask = {
+            single_class_mode: false,
+            annotations: {
+                access: {
+                    a0: { containing_box: { tlx: 200, tly: 200, brx: 300, bry: 300 } },
+                },
+            },
+            state: {
+                visible_dialogs: { global_edit_suggestion__st: {} },
+            },
+        };
+        const ulabel = {
+            config: { annbox_id: "annbox", image_width: 1000, image_height: 1000 },
+            state: { zoom_val: 2 },
+            subtasks: { st: subtask },
+            get_current_subtask_key: () => "st",
+            get_current_subtask: () => subtask,
+            reposition_dialogs: jest.fn(),
+            set_hovered_annotation: jest.fn(),
+        };
+        const dialog = document.getElementById("global_edit_suggestion__st");
+        Object.defineProperty(dialog, "offsetWidth", { value: 120 });
+        const card = document.getElementById("global_annotation_confidence__st");
+
+        for (const [anchor_x, expected_shift] of [[137, 80], [517, -80], [327, 0]]) {
+            dialog.getBoundingClientRect = () => ({
+                left: anchor_x - 60 * scale,
+                width: 120 * scale,
+            });
+            for (let repeat = 0; repeat < 3; repeat++) {
+                ULabel.prototype.show_global_edit_suggestion.call(ulabel, "a0");
+
+                const shift = Number.parseFloat(card.style.transform.match(/\+ ([-\d.]+)px/)[1]);
+                expect(shift).toBeCloseTo(expected_shift);
+                // Half the box's on-screen height (100 * zoom 2 / 2) plus the gap, in local units
+                expect(Number.parseFloat(card.style.bottom)).toBeCloseTo((100 + 10) / scale);
+            }
+        }
+
+        subtask.annotations.access.a0.containing_box = { tlx: 200, tly: 50, brx: 300, bry: 60 };
+        ULabel.prototype.show_global_edit_suggestion.call(ulabel, "a0");
+        expect(Number.parseFloat(card.style.top)).toBeCloseTo((10 + 10) / scale);
+    });
+});
diff --git a/tests/context_menu.test.js b/tests/context_menu.test.js
new file mode 100644
index 00000000..37ad09a7
--- /dev/null
+++ b/tests/context_menu.test.js
@@ -0,0 +1,400 @@
+// Unit tests for the right-click context menu: which items show, what they
+// call, how the menu closes, and that annotation data is rendered as text.
+const { show_context_menu, hide_context_menu, is_context_menu_open } = require("../build/context_menu");
+
+function make_annotation(overrides = {}) {
+    return {
+        id: "a0",
+        spatial_type: "bbox",
+        deprecated: false,
+        classification_payloads: [{ class_id: 1, confidence: 0.2 }, { class_id: 2, confidence: 0.8 }],
+        containing_box: { tlx: 10, tly: 20, brx: 30, bry: 60 },
+        last_edited_by: "annotator",
+        last_edited_at: "2026-09-28T00:00:00Z",
+        annotation_meta: {},
+        ...overrides,
+    };
+}
+
+function make_ulabel({ read_only = false, compatible = [1, 2], annotation = make_annotation(), copy_targets = [], focus_deprecated = false, can_restore = true } = {}) {
+    document.body.innerHTML = `<div id="container"></div>`;
+    const subtask = {
+        read_only,
+        focus_deprecated,
+        class_defs: [{ id: 1, name: "Crop" }, { id: 2, name: "Weed" }],
+        annotations: { access: { [annotation.id]: annotation } },
+        state: { edit_candidate: { annid: annotation.id }, move_candidate: null, isolated_annid: null },
+    };
+    const ulabel = {
+        config: { container_id: "container" },
+        state: { context_menu_annid: null },
+        subtasks: {
+            main: subtask,
+            pred: { display_name: "Predictions" },
+            review: { display_name: "Review" },
+        },
+        get_current_subtask: () => subtask,
+        get_current_subtask_key: () => "main",
+        is_current_subtask_read_only: () => read_only,
+        is_subtask_edit_locked: (key = "main") => {
+            const s = ulabel.subtasks[key];
+            return s.read_only === true || s.focus_deprecated === true;
+        },
+        _get_compatible_class_ids: jest.fn(() => compatible),
+        get_copy_target_subtask_keys: jest.fn(() => copy_targets),
+        copy_annotation_to_subtask: jest.fn(() => "new_id"),
+        copy_annotation_to_clipboard: jest.fn(() => ({ ulabel_annotation: 1, paste_counts: {} })),
+        find_counterparts: jest.fn(() => []),
+        delete_counterparts: jest.fn(() => []),
+        show_id_dialog: jest.fn(),
+        delete_annotation: jest.fn(),
+        is_annotation_defocused: jest.fn((ann) => ann.deprecated !== subtask.focus_deprecated),
+        can_restore_annotation: jest.fn(() => can_restore),
+        restore_annotation: jest.fn(),
+        isolate_annotation: jest.fn((annid) => {
+            subtask.state.isolated_annid = annid;
+            hide_context_menu(ulabel);
+        }),
+        hide_and_clear_action_candidates: jest.fn(() => {
+            subtask.state.edit_candidate = null;
+        }),
+    };
+    return ulabel;
+}
+
+function menu_element() {
+    return document.getElementById("ulabel-context-menu__container");
+}
+
+function item_labels() {
+    return Array.from(menu_element().querySelectorAll(".ulabel-context-menu-item")).map((el) => el.textContent);
+}
+
+function click_item(label) {
+    const item = Array.from(menu_element().querySelectorAll(".ulabel-context-menu-item")).find((el) => el.textContent === label);
+    item.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+}
+
+describe("context menu items", () => {
+    test("editable subtask with compatible classes shows all four", () => {
+        const ulabel = make_ulabel();
+        expect(show_context_menu(ulabel, "a0", 100, 100)).toBe(true);
+        expect(item_labels()).toEqual(["Change class", "Delete", "Isolate", "Details"]);
+        expect(is_context_menu_open(ulabel)).toBe(true);
+        expect(menu_element().style.display).toBe("block");
+    });
+
+    test("fewer than two compatible classes hides Change class", () => {
+        const ulabel = make_ulabel({ compatible: [2] });
+        show_context_menu(ulabel, "a0", 100, 100);
+        expect(item_labels()).toEqual(["Delete", "Isolate", "Details"]);
+    });
+
+    test("read-only subtask shows only Isolate and Details", () => {
+        const ulabel = make_ulabel({ read_only: true });
+        show_context_menu(ulabel, "a0", 100, 100);
+        expect(item_labels()).toEqual(["Isolate", "Details"]);
+    });
+
+    test("the isolate item reads Show all while the target is isolated", () => {
+        const ulabel = make_ulabel({ read_only: true });
+        ulabel.get_current_subtask().state.isolated_annid = "a0";
+        show_context_menu(ulabel, "a0", 100, 100);
+        expect(item_labels()).toEqual(["Show all", "Details"]);
+    });
+
+    test("unknown or deprecated target opens nothing", () => {
+        const ulabel = make_ulabel();
+        expect(show_context_menu(ulabel, "missing", 100, 100)).toBe(false);
+        expect(is_context_menu_open(ulabel)).toBe(false);
+
+        const deprecated = make_ulabel({ annotation: make_annotation({ deprecated: true }) });
+        expect(show_context_menu(deprecated, "a0", 100, 100)).toBe(false);
+    });
+
+    test("deprecated target under deprecated focus offers Restore, Isolate, and Details", () => {
+        const ulabel = make_ulabel({ annotation: make_annotation({ deprecated: true }), focus_deprecated: true });
+        expect(show_context_menu(ulabel, "a0", 100, 100)).toBe(true);
+        expect(item_labels()).toEqual(["Restore", "Isolate", "Details"]);
+
+        click_item("Restore");
+        expect(is_context_menu_open(ulabel)).toBe(false);
+        expect(ulabel.restore_annotation).toHaveBeenCalledWith("a0");
+    });
+
+    test("a deprecated target that cannot be restored has no Restore", () => {
+        const ulabel = make_ulabel({
+            annotation: make_annotation({ deprecated: true }),
+            focus_deprecated: true,
+            can_restore: false,
+        });
+        show_context_menu(ulabel, "a0", 100, 100);
+        expect(item_labels()).toEqual(["Isolate", "Details"]);
+        expect(ulabel.can_restore_annotation).toHaveBeenCalledWith("a0");
+    });
+
+    test("one copy target is named on flat Copy to / Move to items", () => {
+        const ulabel = make_ulabel({ copy_targets: ["pred"] });
+        show_context_menu(ulabel, "a0", 100, 100);
+        expect(item_labels()).toEqual([
+            "Change class",
+            "Copy to Predictions",
+            "Move to Predictions",
+            "Delete",
+            "Isolate",
+            "Details",
+        ]);
+        expect(ulabel.get_copy_target_subtask_keys).toHaveBeenCalledWith(ulabel.get_current_subtask().annotations.access.a0, "main");
+
+        click_item("Copy to Predictions");
+        expect(is_context_menu_open(ulabel)).toBe(false);
+        expect(ulabel.copy_annotation_to_subtask).toHaveBeenCalledWith("a0", "main", "pred", null, false, true);
+    });
+
+    test("several copy targets drill down to a list of subtask names", () => {
+        const ulabel = make_ulabel({ copy_targets: ["pred", "review"] });
+        show_context_menu(ulabel, "a0", 100, 100);
+        expect(item_labels()).toEqual([
+            "Change class",
+            "Copy to\u2026",
+            "Move to\u2026",
+            "Delete",
+            "Isolate",
+            "Details",
+        ]);
+
+        click_item("Move to\u2026");
+        expect(is_context_menu_open(ulabel)).toBe(true);
+        expect(item_labels()).toEqual(["Predictions", "Review"]);
+
+        click_item("Review");
+        expect(is_context_menu_open(ulabel)).toBe(false);
+        expect(ulabel.copy_annotation_to_subtask).toHaveBeenCalledWith("a0", "main", "review", null, true, true);
+    });
+
+    test("read-only subtask offers Copy to but not Move to", () => {
+        const ulabel = make_ulabel({ read_only: true, copy_targets: ["pred"] });
+        show_context_menu(ulabel, "a0", 100, 100);
+        expect(item_labels()).toEqual(["Copy to Predictions", "Isolate", "Details"]);
+    });
+
+    test("a menu copy also arms the clipboard, counting as the first paste into the target", () => {
+        const ulabel = make_ulabel({ copy_targets: ["pred"] });
+        const write_text = jest.fn(() => Promise.resolve());
+        Object.defineProperty(navigator, "clipboard", { value: { writeText: write_text }, configurable: true });
+        show_context_menu(ulabel, "a0", 100, 100);
+
+        click_item("Copy to Predictions");
+
+        expect(ulabel.copy_annotation_to_clipboard).toHaveBeenCalledWith("a0");
+        const envelope = ulabel.copy_annotation_to_clipboard.mock.results[0].value;
+        expect(envelope.paste_counts).toEqual({ pred: 1 });
+        expect(write_text).toHaveBeenCalledWith(JSON.stringify(envelope));
+        delete navigator.clipboard;
+    });
+
+    test("a failed system clipboard write still arms the in-memory clipboard", async () => {
+        const ulabel = make_ulabel({ copy_targets: ["pred"] });
+        Object.defineProperty(navigator, "clipboard", { value: { writeText: () => Promise.reject(new Error("denied")) }, configurable: true });
+        show_context_menu(ulabel, "a0", 100, 100);
+
+        click_item("Copy to Predictions");
+        await Promise.resolve();
+
+        expect(ulabel.copy_annotation_to_clipboard).toHaveBeenCalledWith("a0");
+        expect(ulabel.copy_annotation_to_subtask).toHaveBeenCalled();
+        delete navigator.clipboard;
+    });
+
+    test("a target that already has the annotation asks first; cancelling skips the copy", () => {
+        const ulabel = make_ulabel({ copy_targets: ["pred"] });
+        ulabel.find_counterparts.mockReturnValue(["older_copy"]);
+        ulabel.subtasks.pred.read_only = true;
+        const confirm_spy = jest.spyOn(window, "confirm").mockReturnValue(false);
+
+        show_context_menu(ulabel, "a0", 100, 100);
+        click_item("Copy to Predictions");
+        expect(ulabel.find_counterparts).toHaveBeenCalledWith("a0", "main", "pred");
+        expect(confirm_spy).toHaveBeenCalledWith("Predictions already has this annotation. Copy it there anyway?");
+        expect(is_context_menu_open(ulabel)).toBe(false);
+        expect(ulabel.copy_annotation_to_subtask).not.toHaveBeenCalled();
+        expect(ulabel.copy_annotation_to_clipboard).not.toHaveBeenCalled();
+
+        confirm_spy.mockReturnValue(true);
+        show_context_menu(ulabel, "a0", 100, 100);
+        click_item("Move to Predictions");
+        expect(confirm_spy).toHaveBeenLastCalledWith("Predictions already has this annotation. Move it there anyway?");
+        expect(ulabel.copy_annotation_to_subtask).toHaveBeenCalledWith("a0", "main", "pred", null, true, true);
+        confirm_spy.mockRestore();
+    });
+
+    test("Delete from lists writable subtasks with counterparts, even from a read-only source", () => {
+        const ulabel = make_ulabel({ read_only: true });
+        ulabel.subtasks.pred.annotations = { access: { p1: { spatial_type: "bbox" } } };
+        ulabel.subtasks.review.read_only = true;
+        ulabel.find_counterparts.mockReturnValue(["p1"]);
+
+        show_context_menu(ulabel, "a0", 100, 100);
+        expect(item_labels()).toEqual(["Delete from Predictions", "Isolate", "Details"]);
+        expect(ulabel.find_counterparts).not.toHaveBeenCalledWith("a0", "main", "review");
+
+        click_item("Delete from Predictions");
+        expect(is_context_menu_open(ulabel)).toBe(false);
+        expect(ulabel.delete_counterparts).toHaveBeenCalledWith("a0", "main", "pred", false);
+    });
+
+    test("hide_copy_to_linked leaves out Copy to / Move to for subtasks with counterparts", () => {
+        const ulabel = make_ulabel({ copy_targets: ["pred", "review"] });
+        ulabel.config.hide_copy_to_linked = true;
+        ulabel.find_counterparts.mockImplementation((annid, source_key, key) => (key === "pred" ? ["p1"] : []));
+
+        show_context_menu(ulabel, "a0", 100, 100);
+        expect(item_labels()).toEqual([
+            "Change class",
+            "Copy to Review",
+            "Move to Review",
+            "Delete from Predictions",
+            "Delete",
+            "Isolate",
+            "Details",
+        ]);
+    });
+
+    test("Delete from shows how many it would delete", () => {
+        const ulabel = make_ulabel({ read_only: true });
+        ulabel.find_counterparts.mockImplementation((annid, source_key, key) => (key === "pred" ? ["p1", "p2"] : ["r1"]));
+
+        show_context_menu(ulabel, "a0", 100, 100);
+        click_item("Delete from\u2026");
+        expect(item_labels()).toEqual(["Predictions (2)", "Review"]);
+
+        ulabel.subtasks.review.read_only = true;
+        show_context_menu(ulabel, "a0", 100, 100);
+        expect(item_labels()).toEqual(["Delete 2 from Predictions", "Isolate", "Details"]);
+    });
+
+    test("a bitmask offers Erase from where a counterpart is a bitmask, and Delete from anywhere", () => {
+        const ulabel = make_ulabel({ read_only: true, annotation: make_annotation({ spatial_type: "bitmask" }) });
+        ulabel.subtasks.pred.annotations = { access: { p1: { spatial_type: "bitmask" } } };
+        ulabel.subtasks.review.annotations = { access: { r1: { spatial_type: "polygon" } } };
+        ulabel.find_counterparts.mockImplementation((annid, source_key, key) => (key === "pred" ? ["p1"] : ["r1"]));
+
+        show_context_menu(ulabel, "a0", 100, 100);
+        expect(item_labels()).toEqual(["Erase from Predictions", "Delete from\u2026", "Isolate", "Details"]);
+
+        click_item("Erase from Predictions");
+        expect(ulabel.delete_counterparts).toHaveBeenCalledWith("a0", "main", "pred", true);
+    });
+});
+
+describe("context menu actions", () => {
+    test("Change class closes the menu and opens the pie at the box centre", () => {
+        const ulabel = make_ulabel();
+        show_context_menu(ulabel, "a0", 100, 100);
+        click_item("Change class");
+
+        expect(is_context_menu_open(ulabel)).toBe(false);
+        expect(ulabel.show_id_dialog).toHaveBeenCalledWith(20, 40, "a0", false);
+    });
+
+    test("Delete closes the menu and deletes the target", () => {
+        const ulabel = make_ulabel();
+        show_context_menu(ulabel, "a0", 100, 100);
+        click_item("Delete");
+
+        expect(is_context_menu_open(ulabel)).toBe(false);
+        expect(ulabel.delete_annotation).toHaveBeenCalledWith("a0");
+    });
+
+    test("Isolate and Show all toggle isolation of the target", () => {
+        const ulabel = make_ulabel();
+        show_context_menu(ulabel, "a0", 100, 100);
+        click_item("Isolate");
+        expect(ulabel.isolate_annotation).toHaveBeenCalledWith("a0");
+        expect(is_context_menu_open(ulabel)).toBe(false);
+
+        show_context_menu(ulabel, "a0", 100, 100);
+        click_item("Show all");
+        expect(ulabel.isolate_annotation).toHaveBeenLastCalledWith(null);
+        expect(is_context_menu_open(ulabel)).toBe(false);
+    });
+
+    test("Details replaces the items with read-only rows, text-escaped", () => {
+        const ulabel = make_ulabel({
+            annotation: make_annotation({
+                annotation_meta: { source: "<b>model</b>", nested: { a: 1 } },
+            }),
+        });
+        show_context_menu(ulabel, "a0", 100, 100);
+        click_item("Details");
+
+        expect(is_context_menu_open(ulabel)).toBe(true);
+        expect(item_labels()).toEqual([]);
+        const rows = Array.from(menu_element().querySelectorAll(".ulabel-context-menu-detail")).map((row) => [
+            row.querySelector(".ulabel-context-menu-detail-key").textContent,
+            row.querySelector(".ulabel-context-menu-detail-value").textContent,
+        ]);
+        expect(rows).toEqual([
+            ["id", "a0"],
+            ["class", "Weed (2)"],
+            ["type", "bbox"],
+            ["edited by", "annotator"],
+            ["edited at", "2026-09-28T00:00:00Z"],
+            ["source", "<b>model</b>"],
+            ["nested", "{\"a\":1}"],
+        ]);
+        expect(menu_element().querySelector("b")).toBeNull();
+    });
+
+    test("Details lists what deprecated a deprecated target", () => {
+        const ulabel = make_ulabel({
+            annotation: make_annotation({
+                deprecated: true,
+                deprecated_by: { human: true, confidence_filter: true, distance_from_row: false },
+            }),
+            focus_deprecated: true,
+        });
+        show_context_menu(ulabel, "a0", 100, 100);
+        click_item("Details");
+
+        const rows = Array.from(menu_element().querySelectorAll(".ulabel-context-menu-detail")).map((row) => [
+            row.querySelector(".ulabel-context-menu-detail-key").textContent,
+            row.querySelector(".ulabel-context-menu-detail-value").textContent,
+        ]);
+        expect(rows).toContainEqual(["deprecated by", "human, confidence_filter"]);
+    });
+});
+
+describe("context menu close", () => {
+    test("hide clears the held hover and is a no-op when closed", () => {
+        const ulabel = make_ulabel();
+        hide_context_menu(ulabel);
+        expect(ulabel.hide_and_clear_action_candidates).not.toHaveBeenCalled();
+
+        show_context_menu(ulabel, "a0", 100, 100);
+        hide_context_menu(ulabel);
+        expect(is_context_menu_open(ulabel)).toBe(false);
+        expect(menu_element().style.display).toBe("none");
+        expect(menu_element().childElementCount).toBe(0);
+        expect(ulabel.hide_and_clear_action_candidates).toHaveBeenCalledTimes(1);
+        expect(ulabel.get_current_subtask().state.edit_candidate).toBeNull();
+    });
+
+    test("a mousedown inside the menu does not reach the document", () => {
+        const ulabel = make_ulabel();
+        show_context_menu(ulabel, "a0", 100, 100);
+        const seen = jest.fn();
+        document.addEventListener("mousedown", seen);
+        menu_element().dispatchEvent(new MouseEvent("mousedown", { bubbles: true }));
+        document.removeEventListener("mousedown", seen);
+        expect(seen).not.toHaveBeenCalled();
+    });
+
+    test("reopening reuses the single element", () => {
+        const ulabel = make_ulabel();
+        show_context_menu(ulabel, "a0", 100, 100);
+        show_context_menu(ulabel, "a0", 200, 200);
+        expect(document.querySelectorAll(".ulabel-context-menu").length).toBe(1);
+        expect(menu_element().style.left).toBe("200px");
+    });
+});
diff --git a/tests/copy_annotation.test.js b/tests/copy_annotation.test.js
new file mode 100644
index 00000000..4cc6ea2f
--- /dev/null
+++ b/tests/copy_annotation.test.js
@@ -0,0 +1,791 @@
+// Unit tests for copying / cutting annotations between subtasks (CVML-261):
+// eligibility, field carry-over, class resolution, undo/redo on the target
+// stream, cut on the source stream, and the clipboard envelope.
+const { ULabel } = require("./testing-utils/build_loader");
+const { mark_deprecated } = require("../build/annotation_operators");
+
+const classes = [
+    { name: "Crop", id: 1, color: "green" },
+    { name: "Weed", id: 2, color: "red" },
+];
+const other_class = { name: "Other", id: 3, color: "blue" };
+
+function make_bbox(id, class_id = 1, extra = {}) {
+    return {
+        id,
+        spatial_type: "bbox",
+        spatial_payload: [[10, 10], [30, 30]],
+        classification_payloads: [{ class_id, confidence: 1.0 }],
+        deprecated: false,
+        text_payload: "note",
+        annotation_meta: { source: "model" },
+        last_edited_at: "2026-01-01T00:00:00.000Z",
+        last_edited_by: "host",
+        created_at: "2026-01-01T00:00:00.000Z",
+        created_by: "host",
+        ...extra,
+    };
+}
+
+// Column-major RLE: column 0, rows 0-9 set on a 100x100 image
+const MASK_RLE = { counts: [0, 10, 100 * 100 - 10], size: [100, 100] };
+
+function make_bitmask(id) {
+    return make_bbox(id, 1, { spatial_type: "bitmask", spatial_payload: JSON.parse(JSON.stringify(MASK_RLE)) });
+}
+
+function make_config(resume) {
+    return {
+        container_id: "container",
+        image_data: "test.jpg",
+        username: "test_user",
+        image_width: 100,
+        image_height: 100,
+        allow_annotations_outside_image: true,
+        submit_buttons: [{ name: "Submit", hook: jest.fn() }],
+        subtasks: {
+            gt: { display_name: "GT", classes, allowed_modes: ["bbox", "polygon", "bitmask", "whole-image"], resume_from: resume.gt ?? null },
+            pred: { display_name: "Pred", classes, allowed_modes: ["bbox", "bitmask"], resume_from: resume.pred ?? null },
+            // No Crop class here, so a Crop bbox has to change class
+            weeds: { display_name: "Weeds", classes: [classes[1], other_class], allowed_modes: ["bbox"], resume_from: resume.weeds ?? null },
+            // Same class names under different ids
+            renamed: {
+                display_name: "Renamed",
+                classes: [
+                    { name: "Crop", id: 7, color: "green" },
+                    { name: "Weed", id: 8, color: "red" },
+                ],
+                allowed_modes: ["bbox"],
+                resume_from: null,
+            },
+            // Per-class modes: only Weed may be a bbox
+            mixed: {
+                display_name: "Mixed",
+                classes: [
+                    { ...classes[0], allowed_modes: ["polygon"] },
+                    { ...classes[1], allowed_modes: ["bbox"] },
+                ],
+                allowed_modes: ["polygon", "bbox"],
+                resume_from: null,
+            },
+            ro: { display_name: "RO", classes, allowed_modes: ["bbox"], read_only: true, resume_from: resume.ro ?? null },
+        },
+    };
+}
+
+function make_ulabel(resume = {}, current = "gt") {
+    const ulabel = new ULabel(make_config(resume));
+    ulabel.state.current_subtask = current;
+    for (const name of [
+        "redraw_annotation",
+        "redraw_all_annotations",
+        "update_filter_distance",
+        "suggest_edits",
+        "destroy_polygon_ender",
+        "destroy_annotation_context",
+        "hide_id_dialog",
+        "hide_context_menu",
+        "show_id_dialog",
+        "update_frame",
+    ]) {
+        ulabel[name] = jest.fn();
+    }
+    ulabel.set_subtask = jest.fn((key) => {
+        ulabel.state.current_subtask = key;
+    });
+    ulabel.toolbox = { redraw_update_items: jest.fn() };
+    ulabel.get_init_canvas_context_id = jest.fn(() => "c0");
+    return ulabel;
+}
+
+function only_annotation(ulabel, subtask_key) {
+    const subtask = ulabel.subtasks[subtask_key];
+    expect(subtask.annotations.ordering).toHaveLength(1);
+    return subtask.annotations.access[subtask.annotations.ordering[0]];
+}
+
+function action_types(ulabel, subtask_key) {
+    return ulabel.subtasks[subtask_key].actions.stream.map((action) => action.act_type);
+}
+
+function get_class(ulabel, subtask_key, annotation_id) {
+    const payloads = ulabel.subtasks[subtask_key].annotations.access[annotation_id].classification_payloads;
+    return payloads.find((payload) => payload.confidence === 1.0).class_id;
+}
+
+describe("eligibility", () => {
+    test("targets are the other writable subtasks with a class that allows the spatial type", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1")] });
+        const bbox = ulabel.subtasks.gt.annotations.access.g1;
+
+        expect(ulabel.get_copy_target_subtask_keys(bbox)).toEqual(["pred", "weeds", "renamed", "mixed"]);
+        expect(ulabel.get_copy_target_subtask_keys(bbox, "pred")).toEqual(["gt", "weeds", "renamed", "mixed"]);
+    });
+
+    test("a polygon is only offered where some class allows polygons", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("poly", 1, { spatial_type: "polygon", spatial_payload: [[[0, 0], [10, 0], [10, 10], [0, 0]]] })] });
+
+        expect(ulabel.get_copy_target_subtask_keys(ulabel.subtasks.gt.annotations.access.poly)).toEqual(["mixed"]);
+    });
+
+    test("nonspatial and delete-shape annotations have no targets", () => {
+        const ulabel = make_ulabel();
+
+        expect(ulabel.get_copy_target_subtask_keys({ spatial_type: "whole-image", spatial_payload: null })).toEqual([]);
+        expect(ulabel.get_copy_target_subtask_keys({ spatial_type: "delete_bbox", spatial_payload: [[0, 0], [1, 1]] })).toEqual([]);
+    });
+
+    test("a read-only subtask is never a target", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1")] });
+
+        expect(ulabel.can_paste_into_subtask(ulabel.subtasks.gt.annotations.access.g1, "ro")).toBe(false);
+    });
+});
+
+describe("copy_annotation", () => {
+    test("copies geometry and metadata with a fresh id, stamps and deprecation state", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1", 2, { edit_type: "modified" })] });
+
+        const new_id = ulabel.copy_annotation("g1", "pred");
+
+        const copy = only_annotation(ulabel, "pred");
+        const source = ulabel.subtasks.gt.annotations.access.g1;
+        expect(new_id).toBe(copy.id);
+        expect(new_id).not.toBe("g1");
+        expect(copy.spatial_payload).toEqual(source.spatial_payload);
+        expect(copy.spatial_payload).not.toBe(source.spatial_payload);
+        expect(copy.classification_payloads).toEqual([
+            { class_id: 1, confidence: 0.0 },
+            { class_id: 2, confidence: 1.0 },
+        ]);
+        expect(copy.text_payload).toBe("note");
+        expect(copy.annotation_meta).toEqual({ source: "model", copied_from: { subtask_key: "gt", annotation_id: "g1" } });
+        expect(copy.deprecated).toBe(false);
+        expect(copy.deprecated_by).toEqual({ human: false });
+        expect(copy.created_by).toBe("test_user");
+        expect(copy.last_edited_by).toBe("test_user");
+        expect(copy.created_at).not.toBe(source.created_at);
+        expect(copy.edit_type).toBeUndefined();
+        expect(copy.canvas_id).toBe("c0");
+        ulabel.rebuild_containing_box("g1", false, "gt");
+        expect(copy.containing_box).toEqual(source.containing_box);
+        // Source is untouched
+        expect(source.deprecated).toBe(false);
+        expect(source.last_edited_at).toBe("2026-01-01T00:00:00.000Z");
+    });
+
+    test("records paste_annotation on the target stream only", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1")] });
+
+        ulabel.copy_annotation("g1", "pred");
+
+        expect(action_types(ulabel, "gt")).toEqual([]);
+        expect(action_types(ulabel, "pred")).toEqual(["paste_annotation"]);
+        expect(ulabel.redraw_annotation).toHaveBeenCalledWith(expect.any(String), "pred");
+        expect(ulabel.toolbox.redraw_update_items).toHaveBeenCalled();
+    });
+
+    test("copying from a read-only subtask is allowed", () => {
+        const ulabel = make_ulabel({ ro: [make_bbox("r1")] }, "ro");
+
+        expect(ulabel.copy_annotation("r1", "gt")).not.toBeNull();
+        expect(only_annotation(ulabel, "gt").spatial_payload).toEqual([[10, 10], [30, 30]]);
+    });
+
+    test("refuses a target without a compatible class", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1")] });
+
+        expect(ulabel.copy_annotation("g1", "ro")).toBeNull();
+        expect(ulabel.subtasks.ro.annotations.ordering).toEqual([]);
+    });
+
+    test("refuses an explicit class that cannot take the spatial type", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1")] });
+
+        expect(ulabel.copy_annotation("g1", "mixed", 1)).toBeNull();
+        expect(ulabel.subtasks.mixed.annotations.ordering).toEqual([]);
+    });
+
+    test("the copy is not hidden by an isolation in the target", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1")], pred: [make_bbox("p1")] });
+        ulabel.isolate_annotation("p1", "pred", false);
+
+        ulabel.copy_annotation("g1", "pred");
+
+        expect(ulabel.get_isolated_annotation_id("pred")).toBeNull();
+    });
+});
+
+describe("class resolution", () => {
+    test("keeps the source class when the target allows it", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1", 2)] });
+        ulabel.set_active_class(1, "pred", false);
+
+        ulabel.copy_annotation("g1", "pred");
+
+        expect(ulabel.resolve_paste_class_id(ulabel.subtasks.gt.annotations.access.g1, "pred")).toBe(2);
+        expect(only_annotation(ulabel, "pred").classification_payloads[1]).toEqual({ class_id: 2, confidence: 1.0 });
+    });
+
+    test("falls back to the target's active class", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1", 1)] });
+        ulabel.set_active_class(3, "weeds", false);
+
+        ulabel.copy_annotation("g1", "weeds");
+
+        expect(only_annotation(ulabel, "weeds").classification_payloads).toEqual([
+            { class_id: 2, confidence: 0.0 },
+            { class_id: 3, confidence: 1.0 },
+        ]);
+    });
+
+    test("matches the source class by name when the id differs", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1", 2)] });
+        ulabel.set_active_class(7, "renamed", false);
+
+        const new_id = ulabel.copy_annotation_to_subtask("g1", "gt", "renamed", null, false, true);
+
+        expect(ulabel.match_paste_class_id(ulabel.subtasks.gt.annotations.access.g1, "renamed", "Weed")).toBe(8);
+        expect(ulabel.match_paste_class_id(ulabel.subtasks.gt.annotations.access.g1, "renamed")).toBeNull();
+        expect(ulabel.subtasks.renamed.annotations.access[new_id].classification_payloads).toEqual([
+            { class_id: 7, confidence: 0.0 },
+            { class_id: 8, confidence: 1.0 },
+        ]);
+        // A match means no class pie
+        expect(ulabel.show_id_dialog).not.toHaveBeenCalled();
+    });
+
+    test("falls back to the first compatible class when the active class cannot take the type", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1", 1)] });
+        ulabel.set_active_class(1, "mixed", false);
+
+        ulabel.copy_annotation("g1", "mixed");
+
+        expect(only_annotation(ulabel, "mixed").classification_payloads).toEqual([
+            { class_id: 1, confidence: 0.0 },
+            { class_id: 2, confidence: 1.0 },
+        ]);
+    });
+
+    test("an explicit class wins", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1", 1)] });
+
+        ulabel.copy_annotation("g1", "pred", 2);
+
+        expect(only_annotation(ulabel, "pred").classification_payloads[1]).toEqual({ class_id: 2, confidence: 1.0 });
+    });
+});
+
+describe("undo / redo", () => {
+    test("undo on the target removes the copy; redo restores it with the same id and class", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1", 2)] });
+        const new_id = ulabel.copy_annotation("g1", "pred");
+
+        ulabel.state.current_subtask = "pred";
+        ulabel.undo();
+
+        expect(ulabel.subtasks.pred.annotations.ordering).toEqual([]);
+        expect(ulabel.subtasks.pred.annotations.access[new_id]).toBeUndefined();
+        expect(ulabel.destroy_annotation_context).toHaveBeenCalledWith(new_id, "pred");
+
+        ulabel.redo();
+
+        const restored = only_annotation(ulabel, "pred");
+        expect(restored.id).toBe(new_id);
+        expect(restored.classification_payloads[1]).toEqual({ class_id: 2, confidence: 1.0 });
+        expect(restored.spatial_payload).toEqual([[10, 10], [30, 30]]);
+        expect(action_types(ulabel, "pred")).toEqual(["paste_annotation"]);
+    });
+
+    test("undo on the source stream has nothing to undo after a copy", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1")] });
+        ulabel.copy_annotation("g1", "pred");
+
+        ulabel.undo();
+
+        expect(ulabel.subtasks.pred.annotations.ordering).toHaveLength(1);
+    });
+
+    test("re-picking the copy's current class records nothing and still closes the pie", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1", 2)] });
+        const new_id = ulabel.copy_annotation("g1", "pred");
+        ulabel.state.current_subtask = "pred";
+        ulabel.edit_text_payload(new_id, "changed");
+        ulabel.undo();
+        expect(ulabel.subtasks.pred.actions.undone_stack).toHaveLength(1);
+
+        ulabel.subtasks.pred.state.id_payload = [{ class_id: 1, confidence: 0.0 }, { class_id: 2, confidence: 1.0 }];
+        ulabel.assign_annotation_id(new_id);
+
+        expect(action_types(ulabel, "pred")).toEqual(["paste_annotation"]);
+        expect(ulabel.subtasks.pred.actions.undone_stack).toHaveLength(1);
+        expect(ulabel.hide_id_dialog).toHaveBeenCalled();
+    });
+});
+
+describe("cut", () => {
+    test("is one move_annotation action on the source stream; undo reverts both halves", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1")] });
+
+        const new_id = ulabel.copy_annotation_to_subtask("g1", "gt", "pred", null, true);
+
+        expect(new_id).not.toBeNull();
+        expect(ulabel.subtasks.gt.annotations.access.g1.deprecated).toBe(true);
+        expect(ulabel.subtasks.gt.annotations.access.g1.deprecated_by.human).toBe(true);
+        expect(action_types(ulabel, "gt")).toEqual(["move_annotation"]);
+        expect(action_types(ulabel, "pred")).toEqual([]);
+        expect(ulabel.subtasks.gt.actions.stream[0].affected).toEqual([{ annotation_id: new_id, subtask_key: "pred" }]);
+
+        ulabel.undo();
+        expect(ulabel.subtasks.gt.annotations.access.g1.deprecated).toBe(false);
+        expect(ulabel.subtasks.gt.annotations.access.g1.last_edited_at).toBe("2026-01-01T00:00:00.000Z");
+        expect(ulabel.subtasks.pred.annotations.ordering).toEqual([]);
+        expect(ulabel.destroy_annotation_context).toHaveBeenCalledWith(new_id, "pred");
+
+        ulabel.redo();
+        expect(ulabel.subtasks.gt.annotations.access.g1.deprecated).toBe(true);
+        const restored = only_annotation(ulabel, "pred");
+        expect(restored.id).toBe(new_id);
+        expect(restored.spatial_payload).toEqual([[10, 10], [30, 30]]);
+        expect(action_types(ulabel, "gt")).toEqual(["move_annotation"]);
+        expect(action_types(ulabel, "pred")).toEqual([]);
+    });
+
+    test("undoing the move forgets the target's history about the copy", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1", 1)] });
+        const new_id = ulabel.copy_annotation_to_subtask("g1", "gt", "pred", null, true);
+
+        // Edit the copy twice in the target and undo one edit
+        ulabel.state.current_subtask = "pred";
+        ulabel.edit_text_payload(new_id, "first");
+        ulabel.subtasks.pred.state.id_payload = [{ class_id: 1, confidence: 0.0 }, { class_id: 2, confidence: 1.0 }];
+        ulabel.assign_annotation_id(new_id);
+        ulabel.undo();
+        expect(action_types(ulabel, "pred")).toEqual(["edit_text_payload"]);
+        expect(ulabel.subtasks.pred.actions.undone_stack.map((action) => action.act_type)).toEqual(["assign_annotation_id"]);
+
+        // Undo the move from the source: the copy and its history are gone
+        ulabel.state.current_subtask = "gt";
+        ulabel.undo();
+        expect(ulabel.subtasks.pred.annotations.access[new_id]).toBeUndefined();
+        expect(ulabel.subtasks.pred.actions.stream).toEqual([]);
+        expect(ulabel.subtasks.pred.actions.undone_stack).toEqual([]);
+
+        // Nothing left to replay in the target
+        ulabel.state.current_subtask = "pred";
+        expect(() => ulabel.undo()).not.toThrow();
+        expect(() => ulabel.redo()).not.toThrow();
+        expect(ulabel.subtasks.pred.annotations.ordering).toEqual([]);
+    });
+
+    test("undoing the first of chained moves also drops the copies made by later moves", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1")] });
+        const c1 = ulabel.copy_annotation_to_subtask("g1", "gt", "pred", null, true);
+        ulabel.state.current_subtask = "pred";
+        const c2 = ulabel.copy_annotation_to_subtask(c1, "pred", "gt", null, true);
+        expect(ulabel.subtasks.gt.annotations.ordering).toEqual(["g1", c2]);
+
+        ulabel.state.current_subtask = "gt";
+        ulabel.undo();
+
+        expect(ulabel.subtasks.gt.annotations.ordering).toEqual(["g1"]);
+        expect(ulabel.subtasks.gt.annotations.access.g1.deprecated).toBe(false);
+        expect(ulabel.subtasks.pred.annotations.ordering).toEqual([]);
+        expect(action_types(ulabel, "gt")).toEqual([]);
+        expect(action_types(ulabel, "pred")).toEqual([]);
+        expect(ulabel.destroy_annotation_context).toHaveBeenCalledWith(c2, "gt");
+
+        // Redo replays only the first move
+        ulabel.redo();
+        expect(ulabel.subtasks.gt.annotations.ordering).toEqual(["g1"]);
+        expect(ulabel.subtasks.gt.annotations.access.g1.deprecated).toBe(true);
+        expect(ulabel.subtasks.pred.annotations.ordering).toEqual([c1]);
+    });
+
+    test("a cut from a read-only source only copies", () => {
+        const ulabel = make_ulabel({ ro: [make_bbox("r1")] }, "ro");
+
+        expect(ulabel.copy_annotation_to_subtask("r1", "ro", "gt", null, true)).not.toBeNull();
+
+        expect(ulabel.subtasks.ro.annotations.access.r1.deprecated).toBe(false);
+        expect(action_types(ulabel, "ro")).toEqual([]);
+        expect(action_types(ulabel, "gt")).toEqual(["paste_annotation"]);
+        expect(ulabel.subtasks.gt.annotations.ordering).toHaveLength(1);
+    });
+});
+
+describe("class choice", () => {
+    test("an unmatched class with several options switches to the target and opens the class pie on the copy", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1", 1)] });
+
+        const new_id = ulabel.copy_annotation_to_subtask("g1", "gt", "weeds", null, false, true);
+
+        expect(ulabel.set_subtask).toHaveBeenCalledWith("weeds");
+        expect(ulabel.show_id_dialog).toHaveBeenCalledWith(20, 20, new_id, false);
+    });
+
+    test("a class matched by id opens no pie", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1", 1)] });
+
+        ulabel.copy_annotation_to_subtask("g1", "gt", "pred", null, false, true);
+
+        expect(ulabel.set_subtask).not.toHaveBeenCalled();
+        expect(ulabel.show_id_dialog).not.toHaveBeenCalled();
+    });
+
+    test("an explicit class opens no pie", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1", 1)] });
+
+        ulabel.copy_annotation_to_subtask("g1", "gt", "weeds", 3, false, true);
+
+        expect(ulabel.show_id_dialog).not.toHaveBeenCalled();
+    });
+
+    test("a single compatible class stays in the source subtask without a pie", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1")] });
+
+        ulabel.copy_annotation_to_subtask("g1", "gt", "mixed", null, false, true);
+
+        expect(ulabel.set_subtask).not.toHaveBeenCalled();
+        expect(ulabel.show_id_dialog).not.toHaveBeenCalled();
+        expect(ulabel.state.current_subtask).toBe("gt");
+    });
+
+    test("paste_class_choice off: an unmatched class takes the target's active class without a pie", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1", 1)] });
+        ulabel.config.paste_class_choice = false;
+        ulabel.set_active_class(3, "weeds", false);
+
+        const new_id = ulabel.copy_annotation_to_subtask("g1", "gt", "weeds", null, false, true);
+
+        expect(get_class(ulabel, "weeds", new_id)).toBe(3);
+        expect(ulabel.show_id_dialog).not.toHaveBeenCalled();
+        expect(ulabel.set_subtask).not.toHaveBeenCalled();
+
+        // ctrl+v honours it too
+        ulabel.subtasks.gt.state.edit_candidate = { annid: "g1", spatial_type: "bbox" };
+        ulabel.copy_annotation_to_clipboard();
+        ulabel.state.current_subtask = "weeds";
+        const pasted = ulabel.paste_annotation_from_clipboard();
+        expect(get_class(ulabel, "weeds", pasted)).toBe(3);
+        expect(ulabel.show_id_dialog).not.toHaveBeenCalled();
+    });
+});
+
+describe("paste_switch_to_target", () => {
+    test("off by default: a matched copy stays in the source subtask", () => {
+        const ulabel = make_ulabel({ ro: [make_bbox("r1")] }, "ro");
+
+        expect(ulabel.get_paste_switch_to_target()).toBe(false);
+        ulabel.copy_annotation_to_subtask("r1", "ro", "pred", null, false, true);
+
+        expect(ulabel.set_subtask).not.toHaveBeenCalled();
+        expect(ulabel.state.current_subtask).toBe("ro");
+    });
+
+    test("on: a matched copy switches to the target; the pie, when it opens, opens there", () => {
+        const ulabel = make_ulabel({ ro: [make_bbox("r1")] }, "ro");
+        ulabel.set_paste_switch_to_target(true);
+        expect(ulabel.get_paste_switch_to_target()).toBe(true);
+
+        ulabel.copy_annotation_to_subtask("r1", "ro", "pred", null, false, true);
+        expect(ulabel.set_subtask).toHaveBeenCalledTimes(1);
+        expect(ulabel.set_subtask).toHaveBeenCalledWith("pred");
+        expect(ulabel.show_id_dialog).not.toHaveBeenCalled();
+
+        ulabel.state.current_subtask = "ro";
+        const weeds_id = ulabel.copy_annotation_to_subtask("r1", "ro", "weeds", null, false, true);
+        expect(ulabel.state.current_subtask).toBe("weeds");
+        expect(ulabel.show_id_dialog).toHaveBeenCalledWith(20, 20, weeds_id, false);
+    });
+
+    test("on: a move switches after the source is deleted and recorded", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1")] });
+        ulabel.set_paste_switch_to_target(true);
+
+        ulabel.copy_annotation_to_subtask("g1", "gt", "pred", null, true, true);
+
+        expect(ulabel.subtasks.gt.annotations.access.g1.deprecated).toBe(true);
+        expect(action_types(ulabel, "gt")).toEqual(["move_annotation"]);
+        expect(ulabel.state.current_subtask).toBe("pred");
+    });
+});
+
+describe("find_pasted_copy", () => {
+    test("finds the live copy by provenance; undo clears it, redo re-arms it", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1")] });
+        expect(ulabel.find_pasted_copy("g1", "gt", "pred")).toBeNull();
+
+        const new_id = ulabel.copy_annotation("g1", "pred");
+        expect(ulabel.find_pasted_copy("g1", "gt", "pred")).toBe(new_id);
+        expect(ulabel.find_pasted_copy("g1", "pred", "pred")).toBeNull();
+        expect(ulabel.find_pasted_copy(new_id, "pred", "gt")).toBeNull();
+
+        ulabel.state.current_subtask = "pred";
+        ulabel.undo();
+        expect(ulabel.find_pasted_copy("g1", "gt", "pred")).toBeNull();
+        ulabel.redo();
+        expect(ulabel.find_pasted_copy("g1", "gt", "pred")).toBe(new_id);
+
+        ulabel.delete_annotation(new_id);
+        expect(ulabel.find_pasted_copy("g1", "gt", "pred")).toBeNull();
+    });
+
+    test("a copy hidden by a filter still counts", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1")] });
+        const new_id = ulabel.copy_annotation("g1", "pred");
+        const copy = ulabel.subtasks.pred.annotations.access[new_id];
+
+        mark_deprecated(copy, true, "confidence_filter");
+        expect(copy.deprecated).toBe(true);
+        expect(ulabel.find_pasted_copy("g1", "gt", "pred")).toBe(new_id);
+
+        mark_deprecated(copy, true, "human");
+        expect(ulabel.find_pasted_copy("g1", "gt", "pred")).toBeNull();
+    });
+
+    test("a clipboard paste is stamped with the envelope's source", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1")] });
+        ulabel.subtasks.gt.state.edit_candidate = { annid: "g1", spatial_type: "bbox" };
+        const text = JSON.stringify(ulabel.copy_annotation_to_clipboard());
+
+        ulabel.state.current_subtask = "pred";
+        const new_id = ulabel.paste_annotation_from_clipboard(JSON.parse(text));
+
+        expect(ulabel.subtasks.pred.annotations.access[new_id].annotation_meta.copied_from).toEqual({ subtask_key: "gt", annotation_id: "g1" });
+        expect(ulabel.find_pasted_copy("g1", "gt", "pred")).toBe(new_id);
+    });
+
+    test("a string annotation_meta is replaced by the stamp", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1", 1, { annotation_meta: "opaque" })] });
+
+        const new_id = ulabel.copy_annotation("g1", "pred");
+
+        expect(ulabel.subtasks.pred.annotations.access[new_id].annotation_meta).toEqual({ copied_from: { subtask_key: "gt", annotation_id: "g1" } });
+    });
+});
+
+describe("bitmask", () => {
+    test("the copy gets its own mask, re-encoded and optionally shifted", () => {
+        const ulabel = make_ulabel({ gt: [make_bitmask("m1")] });
+        const source = ulabel.subtasks.gt.annotations.access.m1;
+
+        const new_id = ulabel.paste_annotation(source, "pred", null, [20, 20]);
+
+        const copy = ulabel.subtasks.pred.annotations.access[new_id];
+        expect(copy.containing_box).toEqual({ tlx: 20, tly: 20, brx: 20, bry: 29 });
+        expect(ulabel.get_bitmask(copy)).not.toBe(ulabel.get_bitmask(source));
+        expect(source.containing_box).toEqual({ tlx: 0, tly: 0, brx: 0, bry: 9 });
+        expect(source.spatial_payload).toEqual(MASK_RLE);
+        expect(copy.spatial_payload).not.toEqual(MASK_RLE);
+    });
+});
+
+describe("clipboard", () => {
+    function hover(ulabel, subtask_key, annid) {
+        ulabel.subtasks[subtask_key].state.edit_candidate = { annid, spatial_type: "bbox" };
+    }
+
+    test("copy fills the envelope from the hovered annotation", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1")] });
+        hover(ulabel, "gt", "g1");
+
+        const envelope = ulabel.copy_annotation_to_clipboard();
+
+        expect(envelope).toMatchObject({
+            ulabel_annotation: 1,
+            image_width: 100,
+            image_height: 100,
+            source_subtask_key: "gt",
+            source_class_name: "Crop",
+            annotation: { id: "g1", spatial_type: "bbox" },
+        });
+        expect(ulabel.state.clipboard).toBe(envelope);
+        expect(ulabel.subtasks.gt.annotations.access.g1.deprecated).toBe(false);
+    });
+
+    test("copy without a hovered annotation is a no-op", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1")] });
+
+        expect(ulabel.copy_annotation_to_clipboard()).toBeNull();
+        expect(ulabel.state.clipboard).toBeNull();
+    });
+
+    test("cut deletes the source; cut on a read-only subtask does nothing", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1")], ro: [make_bbox("r1")] });
+        hover(ulabel, "gt", "g1");
+
+        expect(ulabel.copy_annotation_to_clipboard(null, true)).not.toBeNull();
+        expect(ulabel.subtasks.gt.annotations.access.g1.deprecated).toBe(true);
+        expect(action_types(ulabel, "gt")).toEqual(["delete_annotation"]);
+
+        ulabel.state.current_subtask = "ro";
+        hover(ulabel, "ro", "r1");
+        expect(ulabel.copy_annotation_to_clipboard(null, true)).toBeNull();
+        expect(ulabel.subtasks.ro.annotations.access.r1.deprecated).toBe(false);
+    });
+
+    test("paste into another subtask keeps the coordinates", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1")] });
+        hover(ulabel, "gt", "g1");
+        ulabel.copy_annotation_to_clipboard();
+
+        ulabel.state.current_subtask = "pred";
+        const new_id = ulabel.paste_annotation_from_clipboard();
+
+        expect(ulabel.subtasks.pred.annotations.access[new_id].spatial_payload).toEqual([[10, 10], [30, 30]]);
+        // The class id exists in the target: no pie
+        expect(ulabel.show_id_dialog).not.toHaveBeenCalled();
+
+        // No Crop in weeds: the pie opens on the copy
+        ulabel.state.current_subtask = "weeds";
+        const weeds_id = ulabel.paste_annotation_from_clipboard();
+        expect(ulabel.show_id_dialog).toHaveBeenCalledWith(20, 20, weeds_id, false);
+    });
+
+    test("paste matches the source class by name from the envelope", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1", 2)] });
+        hover(ulabel, "gt", "g1");
+        const text = JSON.stringify(ulabel.copy_annotation_to_clipboard());
+
+        ulabel.state.current_subtask = "renamed";
+        const new_id = ulabel.paste_annotation_from_clipboard(JSON.parse(text));
+
+        expect(ulabel.subtasks.renamed.annotations.access[new_id].classification_payloads[1]).toEqual({ class_id: 8, confidence: 1.0 });
+        expect(ulabel.show_id_dialog).not.toHaveBeenCalled();
+    });
+
+    test("paste back into the source subtask is offset and keeps the class without a pie", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1")] });
+        hover(ulabel, "gt", "g1");
+        ulabel.copy_annotation_to_clipboard();
+
+        const new_id = ulabel.paste_annotation_from_clipboard();
+
+        expect(ulabel.subtasks.gt.annotations.access[new_id].spatial_payload).toEqual([[30, 30], [50, 50]]);
+        expect(ulabel.subtasks.gt.annotations.ordering).toEqual(["g1", new_id]);
+        expect(ulabel.show_id_dialog).not.toHaveBeenCalled();
+    });
+
+    test("repeated pastes cascade per target subtask; a new copy resets the offset", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1")] });
+        hover(ulabel, "gt", "g1");
+        ulabel.copy_annotation_to_clipboard();
+
+        ulabel.paste_annotation_from_clipboard();
+        const second = ulabel.paste_annotation_from_clipboard();
+        expect(ulabel.subtasks.gt.annotations.access[second].spatial_payload).toEqual([[50, 50], [70, 70]]);
+
+        // Another subtask: the first paste keeps the coordinates, repeats are nudged
+        ulabel.state.current_subtask = "pred";
+        const first_pred = ulabel.paste_annotation_from_clipboard();
+        const second_pred = ulabel.paste_annotation_from_clipboard();
+        expect(ulabel.subtasks.pred.annotations.access[first_pred].spatial_payload).toEqual([[10, 10], [30, 30]]);
+        expect(ulabel.subtasks.pred.annotations.access[second_pred].spatial_payload).toEqual([[30, 30], [50, 50]]);
+
+        // The counts are independent
+        ulabel.state.current_subtask = "gt";
+        const third = ulabel.paste_annotation_from_clipboard();
+        expect(ulabel.subtasks.gt.annotations.access[third].spatial_payload).toEqual([[70, 70], [90, 90]]);
+
+        hover(ulabel, "gt", "g1");
+        ulabel.copy_annotation_to_clipboard();
+        const fresh = ulabel.paste_annotation_from_clipboard();
+        expect(ulabel.subtasks.gt.annotations.access[fresh].spatial_payload).toEqual([[30, 30], [50, 50]]);
+    });
+
+    test("pastes of the same copy read back from the system clipboard still cascade", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1")] });
+        hover(ulabel, "gt", "g1");
+        const text = JSON.stringify(ulabel.copy_annotation_to_clipboard());
+
+        ulabel.paste_annotation_from_clipboard(JSON.parse(text));
+        const second = ulabel.paste_annotation_from_clipboard(JSON.parse(text));
+        expect(ulabel.subtasks.gt.annotations.access[second].spatial_payload).toEqual([[50, 50], [70, 70]]);
+
+        // A newer copy of the same annotation from another instance is not the cached one
+        const parsed = JSON.parse(text);
+        const newer = {
+            ...parsed,
+            copy_id: "another-copy",
+            annotation: { ...parsed.annotation, text_payload: "edited", spatial_payload: [[0, 0], [5, 5]] },
+        };
+        const third = ulabel.paste_annotation_from_clipboard(newer);
+        expect(ulabel.subtasks.gt.annotations.access[third].text_payload).toBe("edited");
+        expect(ulabel.subtasks.gt.annotations.access[third].spatial_payload).toEqual([[20, 20], [25, 25]]);
+        expect(ulabel.state.clipboard).toBe(newer);
+    });
+
+    test("paste refuses an envelope for a different image size", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1")] });
+        hover(ulabel, "gt", "g1");
+        const envelope = ulabel.copy_annotation_to_clipboard();
+
+        // A newer copy from an instance showing a different image
+        const foreign = { ...envelope, copy_id: "elsewhere", copied_at: envelope.copied_at + 1, image_width: 200 };
+        expect(ulabel.paste_annotation_from_clipboard(foreign)).toBeNull();
+        expect(ulabel.subtasks.gt.annotations.ordering).toEqual(["g1"]);
+        expect(ulabel.state.clipboard).toBe(envelope);
+    });
+
+    test("a stale incompatible system payload does not block the newer in-memory copy", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1"), make_bbox("poly", 1, { spatial_type: "polygon", spatial_payload: [[[0, 0], [10, 0], [10, 10], [0, 0]]] })] });
+        const now = jest.spyOn(Date, "now").mockReturnValue(1000);
+        hover(ulabel, "gt", "poly");
+        const stale_polygon = JSON.stringify(ulabel.copy_annotation_to_clipboard());
+        const stale_other_image = JSON.stringify({ ...JSON.parse(stale_polygon), copy_id: "other-image", image_width: 200 });
+
+        now.mockReturnValue(2000);
+        const newer = ulabel.copy_annotation_to_clipboard("g1");
+
+        // No class in pred takes a polygon, and the other payload is for another image
+        ulabel.state.current_subtask = "pred";
+        const first = ulabel.paste_annotation_from_clipboard(JSON.parse(stale_polygon));
+        const second = ulabel.paste_annotation_from_clipboard(JSON.parse(stale_other_image));
+        expect(first).not.toBeNull();
+        expect(second).not.toBeNull();
+        expect(ulabel.subtasks.pred.annotations.access[first].spatial_type).toBe("bbox");
+        expect(ulabel.subtasks.pred.annotations.access[second].spatial_payload).toEqual([[30, 30], [50, 50]]);
+        expect(ulabel.state.clipboard).toBe(newer);
+        now.mockRestore();
+    });
+
+    test("a newer in-memory copy wins over a stale system clipboard payload", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1"), make_bbox("g2", 2)] });
+        const now = jest.spyOn(Date, "now").mockReturnValue(1000);
+        hover(ulabel, "gt", "g1");
+        const stale_text = JSON.stringify(ulabel.copy_annotation_to_clipboard());
+
+        // A later copy that never reached the system clipboard
+        now.mockReturnValue(2000);
+        const newer = ulabel.copy_annotation_to_clipboard("g2");
+
+        ulabel.state.current_subtask = "pred";
+        const pasted = ulabel.paste_annotation_from_clipboard(JSON.parse(stale_text));
+        expect(get_class(ulabel, "pred", pasted)).toBe(2);
+        expect(ulabel.state.clipboard).toBe(newer);
+
+        // A newer payload from elsewhere still wins
+        const other = { ...JSON.parse(stale_text), copy_id: "elsewhere", copied_at: 3000 };
+        const second = ulabel.paste_annotation_from_clipboard(other);
+        expect(get_class(ulabel, "pred", second)).toBe(1);
+        expect(ulabel.state.clipboard).toBe(other);
+        now.mockRestore();
+    });
+
+    test("paste refuses when no class in the current subtask fits", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("poly", 1, { spatial_type: "polygon", spatial_payload: [[[0, 0], [10, 0], [10, 10], [0, 0]]] })] });
+        hover(ulabel, "gt", "poly");
+        ulabel.copy_annotation_to_clipboard();
+
+        ulabel.state.current_subtask = "pred";
+        expect(ulabel.paste_annotation_from_clipboard()).toBeNull();
+        expect(ulabel.subtasks.pred.annotations.ordering).toEqual([]);
+    });
+
+    test("paste with an empty clipboard is a no-op", () => {
+        const ulabel = make_ulabel();
+
+        expect(ulabel.paste_annotation_from_clipboard()).toBeNull();
+    });
+});
diff --git a/tests/counterparts.test.js b/tests/counterparts.test.js
new file mode 100644
index 00000000..6e624437
--- /dev/null
+++ b/tests/counterparts.test.js
@@ -0,0 +1,448 @@
+// Unit tests for cross-subtask counterparts: find_counterparts (copied_from and
+// annotation_link_meta_key), link-key stripping on copy, and delete_counterparts
+// (vector delete, bitmask erase) with undo/redo on the target stream.
+const { ULabel } = require("./testing-utils/build_loader");
+const { mark_deprecated } = require("../build/annotation_operators");
+
+const classes = [
+    { name: "Crop", id: 1, color: "green" },
+    { name: "Weed", id: 2, color: "red" },
+];
+
+function make_annotation(id, spatial_type, spatial_payload, meta = {}) {
+    return {
+        id,
+        spatial_type,
+        spatial_payload,
+        classification_payloads: [{ class_id: 1, confidence: 1.0 }],
+        deprecated: false,
+        annotation_meta: meta,
+    };
+}
+
+function make_bbox(id, meta = {}) {
+    return make_annotation(id, "bbox", [[10, 10], [30, 30]], meta);
+}
+
+// Column-major RLE on a 100x100 image: column 0, rows [start, start + length)
+function column_rle(start, length) {
+    return { counts: [start, length, 100 * 100 - start - length], size: [100, 100] };
+}
+
+function make_bitmask(id, start, length, meta = {}) {
+    return make_annotation(id, "bitmask", column_rle(start, length), meta);
+}
+
+function make_ulabel(resume = {}, extra_config = {}) {
+    const modes = ["bbox", "bitmask", "point"];
+    const ulabel = new ULabel({
+        container_id: "container",
+        image_data: "test.jpg",
+        username: "test_user",
+        image_width: 100,
+        image_height: 100,
+        submit_buttons: [{ name: "Submit", hook: jest.fn() }],
+        annotation_link_meta_key: "hash",
+        subtasks: {
+            gt: { display_name: "GT", classes, allowed_modes: modes, resume_from: resume.gt ?? null },
+            diff: { display_name: "Diff", classes, allowed_modes: modes, read_only: true, resume_from: resume.diff ?? null },
+            ro: { display_name: "RO", classes, allowed_modes: modes, read_only: true, resume_from: resume.ro ?? null },
+        },
+        ...extra_config,
+    });
+    ulabel.state.current_subtask = "diff";
+    for (const name of [
+        "redraw_annotation",
+        "redraw_multiple_spatial_annotations",
+        "update_filter_distance",
+        "hide_id_dialog",
+        "hide_context_menu",
+        "update_frame",
+        "destroy_annotation_context",
+    ]) {
+        ulabel[name] = jest.fn();
+    }
+    ulabel.toolbox = { redraw_update_items: jest.fn() };
+    ulabel.get_init_canvas_context_id = jest.fn(() => "c0");
+    return ulabel;
+}
+
+function gt(ulabel, id) {
+    return ulabel.subtasks.gt.annotations.access[id];
+}
+
+function action_types(ulabel, subtask_key) {
+    return ulabel.subtasks[subtask_key].actions.stream.map((action) => action.act_type);
+}
+
+describe("find_counterparts", () => {
+    test("links by a shared string or array value", () => {
+        const ulabel = make_ulabel({
+            gt: [make_bbox("g1", { hash: "h1" }), make_bbox("g2", { hash: "h2" }), make_bbox("g3", { hash: "h3" })],
+            diff: [make_bbox("d1", { hash: ["h1", "h2"] }), make_bbox("d2", { hash: "h3" }), make_bbox("d3", {})],
+        });
+
+        expect(ulabel.find_counterparts("d1", "diff", "gt")).toEqual(["g1", "g2"]);
+        expect(ulabel.find_counterparts("d2", "diff", "gt")).toEqual(["g3"]);
+        expect(ulabel.find_counterparts("d3", "diff", "gt")).toEqual([]);
+        expect(ulabel.find_counterparts("d1", "diff", "diff")).toEqual([]);
+        expect(ulabel.find_counterparts("missing", "diff", "gt")).toEqual([]);
+    });
+
+    test("without a link key only copied_from links", () => {
+        const ulabel = make_ulabel({
+            gt: [make_bbox("g1", { hash: "h1" })],
+            diff: [make_bbox("d1", { hash: "h1" })],
+        }, { annotation_link_meta_key: null });
+
+        expect(ulabel.find_counterparts("d1", "diff", "gt")).toEqual([]);
+        const copy_id = ulabel.copy_annotation("d1", "gt");
+        expect(ulabel.find_counterparts("d1", "diff", "gt")).toEqual([copy_id]);
+    });
+
+    test("copied_from links both ways", () => {
+        const ulabel = make_ulabel({ diff: [make_bbox("d1")] });
+        const copy_id = ulabel.copy_annotation("d1", "gt");
+
+        expect(ulabel.find_counterparts("d1", "diff", "gt")).toEqual([copy_id]);
+        expect(ulabel.find_counterparts(copy_id, "gt", "diff")).toEqual(["d1"]);
+    });
+
+    test("human-deleted counterparts are skipped; filter-hidden ones count", () => {
+        const ulabel = make_ulabel({
+            gt: [make_bbox("g1", { hash: "h1" })],
+            diff: [make_bbox("d1", { hash: "h1" })],
+        });
+
+        mark_deprecated(gt(ulabel, "g1"), true, "confidence_filter");
+        expect(ulabel.find_counterparts("d1", "diff", "gt")).toEqual(["g1"]);
+        mark_deprecated(gt(ulabel, "g1"), true, "human");
+        expect(ulabel.find_counterparts("d1", "diff", "gt")).toEqual([]);
+    });
+});
+
+describe("copy", () => {
+    test("drops the link key and keeps the rest of annotation_meta", () => {
+        const ulabel = make_ulabel({ diff: [make_bbox("d1", { hash: ["h1"], area: 4 })] });
+
+        const copy_id = ulabel.copy_annotation("d1", "gt");
+
+        expect(gt(ulabel, copy_id).annotation_meta).toEqual({ area: 4, copied_from: { subtask_key: "diff", annotation_id: "d1" } });
+        expect(ulabel.subtasks.diff.annotations.access.d1.annotation_meta.hash).toEqual(["h1"]);
+    });
+});
+
+describe("delete_counterparts", () => {
+    test("deletes vector counterparts as one undoable action on the target stream", () => {
+        const on_annotation_change = jest.fn();
+        const ulabel = make_ulabel({
+            gt: [make_bbox("g1", { hash: "h1" }), make_bbox("g2", { hash: "h2" }), make_bbox("g3", {})],
+            diff: [make_bbox("d1", { hash: ["h1", "h2"] })],
+        }, { on_annotation_change });
+
+        expect(ulabel.delete_counterparts("d1", "diff", "gt")).toEqual(["g1", "g2"]);
+
+        expect(gt(ulabel, "g1").deprecated).toBe(true);
+        expect(gt(ulabel, "g2").deprecated).toBe(true);
+        expect(gt(ulabel, "g3").deprecated).toBe(false);
+        expect(action_types(ulabel, "gt")).toEqual(["delete_counterparts"]);
+        expect(action_types(ulabel, "diff")).toEqual([]);
+        expect(on_annotation_change).toHaveBeenLastCalledWith(expect.objectContaining({
+            subtask_key: "gt",
+            annotation_id: "d1",
+            act_type: "delete_counterparts",
+            kind: "do",
+            affected: [{ annotation_id: "g1", subtask_key: "gt" }, { annotation_id: "g2", subtask_key: "gt" }],
+        }));
+        expect(gt(ulabel, "g1").last_edited_by).toBe("test_user");
+
+        ulabel.state.current_subtask = "gt";
+        ulabel.undo();
+        expect(gt(ulabel, "g1").deprecated).toBe(false);
+        expect(gt(ulabel, "g2").deprecated).toBe(false);
+        expect(action_types(ulabel, "gt")).toEqual([]);
+
+        ulabel.redo();
+        expect(gt(ulabel, "g1").deprecated).toBe(true);
+        expect(gt(ulabel, "g2").deprecated).toBe(true);
+        expect(action_types(ulabel, "gt")).toEqual(["delete_counterparts"]);
+        expect(on_annotation_change).toHaveBeenLastCalledWith(expect.objectContaining({ kind: "redo", subtask_key: "gt" }));
+    });
+
+    test("erases a bitmask from its bitmask counterparts; an emptied mask is deleted", () => {
+        const ulabel = make_ulabel({
+            gt: [
+                make_bitmask("partial", 0, 10, { hash: "h1" }),
+                make_bitmask("covered", 2, 3, { hash: "h2" }),
+                make_bbox("box", { hash: "h1" }),
+            ],
+            diff: [make_bitmask("d1", 0, 5, { hash: ["h1", "h2"] })],
+        });
+
+        expect(ulabel.delete_counterparts("d1", "diff", "gt")).toEqual(["partial", "covered"]);
+
+        expect(gt(ulabel, "partial").deprecated).toBe(false);
+        expect(gt(ulabel, "partial").containing_box).toEqual({ tlx: 0, tly: 5, brx: 0, bry: 9 });
+        expect(ulabel.get_bitmask(gt(ulabel, "partial")).get_bounding_box()).toMatchObject({ tly: 5, bry: 9 });
+        expect(gt(ulabel, "covered").deprecated).toBe(true);
+        expect(ulabel.get_bitmask(gt(ulabel, "covered")).is_empty()).toBe(true);
+        expect(gt(ulabel, "box").deprecated).toBe(false);
+        expect(ulabel.get_bitmask(ulabel.subtasks.diff.annotations.access.d1).get_bounding_box()).toMatchObject({ tly: 0, bry: 4 });
+
+        ulabel.state.current_subtask = "gt";
+        ulabel.undo();
+        expect(gt(ulabel, "partial").containing_box).toEqual({ tlx: 0, tly: 0, brx: 0, bry: 9 });
+        expect(gt(ulabel, "covered").deprecated).toBe(false);
+        expect(gt(ulabel, "covered").containing_box).toEqual({ tlx: 0, tly: 2, brx: 0, bry: 4 });
+
+        ulabel.redo();
+        expect(gt(ulabel, "partial").containing_box).toEqual({ tlx: 0, tly: 5, brx: 0, bry: 9 });
+        expect(gt(ulabel, "covered").deprecated).toBe(true);
+    });
+
+    test("erase=false deletes every counterpart of a bitmask; a non-bitmask cannot erase", () => {
+        const ulabel = make_ulabel({
+            gt: [make_bitmask("far", 50, 10, { hash: "h1" }), make_bbox("box", { hash: "h1" }), make_bbox("other", {})],
+            diff: [make_bitmask("d1", 0, 5, { hash: "h1" }), make_bbox("d2", { hash: "h1" })],
+        });
+
+        expect(ulabel.delete_counterparts("d2", "diff", "gt", true)).toEqual([]);
+        expect(action_types(ulabel, "gt")).toEqual([]);
+
+        expect(ulabel.delete_counterparts("d1", "diff", "gt", false)).toEqual(["far", "box"]);
+        expect(gt(ulabel, "far").deprecated).toBe(true);
+        expect(gt(ulabel, "box").deprecated).toBe(true);
+        expect(gt(ulabel, "other").deprecated).toBe(false);
+        expect(ulabel.get_bitmask(gt(ulabel, "far")).is_empty()).toBe(false);
+
+        ulabel.state.current_subtask = "gt";
+        ulabel.undo();
+        expect(gt(ulabel, "far").deprecated).toBe(false);
+        expect(gt(ulabel, "box").deprecated).toBe(false);
+    });
+
+    test("records nothing when no counterpart changes", () => {
+        const ulabel = make_ulabel({
+            gt: [make_bitmask("far", 50, 10, { hash: "h1" })],
+            diff: [make_bitmask("d1", 0, 5, { hash: "h1" }), make_bbox("d2", {})],
+        });
+
+        expect(ulabel.delete_counterparts("d1", "diff", "gt")).toEqual([]);
+        expect(ulabel.delete_counterparts("d2", "diff", "gt")).toEqual([]);
+        expect(action_types(ulabel, "gt")).toEqual([]);
+    });
+
+    test("paste_switch_to_target switches to the target only when something changed", () => {
+        const ulabel = make_ulabel({
+            gt: [make_bbox("g1", { hash: "h1" })],
+            diff: [make_bbox("d1", { hash: "h1" }), make_bbox("d2", {})],
+        }, { paste_switch_to_target: true });
+        ulabel.set_subtask = jest.fn();
+
+        ulabel.delete_counterparts("d2", "diff", "gt");
+        expect(ulabel.set_subtask).not.toHaveBeenCalled();
+
+        ulabel.delete_counterparts("d1", "diff", "gt");
+        expect(ulabel.set_subtask).toHaveBeenCalledWith("gt");
+    });
+
+    test("deleted counterparts are redrawn once stamping brings them into combined focus", () => {
+        const ulabel = make_ulabel({
+            gt: [make_bbox("g1", { hash: "h1" })],
+            diff: [make_bbox("d1", { hash: "h1" })],
+        });
+        ulabel.subtasks.gt.focus_deprecated = true;
+        ulabel.subtasks.gt.focus_edited = true;
+        const focused_at_redraw = [];
+        ulabel.redraw_annotation = jest.fn((id, key) => {
+            if (key === "gt") focused_at_redraw.push(!ulabel.is_annotation_defocused(gt(ulabel, id), key));
+        });
+
+        ulabel.delete_counterparts("d1", "diff", "gt");
+
+        expect(focused_at_redraw.at(-1)).toBe(true);
+    });
+
+    test("a read-only target is left alone", () => {
+        const ulabel = make_ulabel({
+            ro: [make_bbox("r1", { hash: "h1" })],
+            gt: [make_bbox("g1", { hash: "h1" })],
+        });
+        ulabel.state.current_subtask = "gt";
+
+        expect(ulabel.delete_counterparts("g1", "gt", "ro")).toEqual([]);
+        expect(ulabel.subtasks.ro.annotations.access.r1.deprecated).toBe(false);
+        expect(action_types(ulabel, "ro")).toEqual([]);
+    });
+});
+
+describe("fly to undo/redo changes", () => {
+    test("passes where the undo/redo left its annotations, or where they were if none remain", () => {
+        const ulabel = make_ulabel({
+            // An unrelated gt annotation sharing the diff source's id
+            gt: [make_bbox("g1", { hash: "h1" }), make_annotation("d1", "bbox", [[70, 70], [90, 90]])],
+            diff: [make_bbox("d1", { hash: "h1" })],
+        });
+        ulabel.fly_to_boxes_if_offscreen = jest.fn();
+        ulabel.state.current_subtask = "gt";
+        ulabel.create_annotation("bbox", [[50, 50], [60, 60]], "n1");
+        const n1_box = { ...gt(ulabel, "n1").containing_box };
+        const g1_box = { ...gt(ulabel, "g1").containing_box };
+
+        ulabel.undo();
+        expect(ulabel.fly_to_boxes_if_offscreen).toHaveBeenLastCalledWith([n1_box]);
+        ulabel.redo();
+        expect(ulabel.fly_to_boxes_if_offscreen).toHaveBeenLastCalledWith([n1_box]);
+
+        ulabel.state.current_subtask = "diff";
+        ulabel.delete_counterparts("d1", "diff", "gt");
+        ulabel.undo();
+        // The action's own id is the diff source; only the affected counterpart counts
+        expect(ulabel.fly_to_boxes_if_offscreen).toHaveBeenLastCalledWith([g1_box]);
+    });
+
+    test("fly_to_on_undo: false never moves the view", () => {
+        const ulabel = make_ulabel({}, { fly_to_on_undo: false });
+        ulabel.fly_to_boxes_if_offscreen = jest.fn();
+        ulabel.state.current_subtask = "gt";
+        ulabel.create_annotation("bbox", [[50, 50], [60, 60]], "n1");
+        ulabel.undo();
+        ulabel.redo();
+        expect(ulabel.fly_to_boxes_if_offscreen).not.toHaveBeenCalled();
+    });
+});
+
+describe("undo/redo from a read-only subtask", () => {
+    function setup() {
+        const on_annotation_change = jest.fn();
+        const ulabel = make_ulabel({
+            gt: [make_bbox("g1", { hash: "h1" })],
+            diff: [make_bbox("d1", { hash: "h1" })],
+        }, { on_annotation_change });
+        ulabel.delete_counterparts("d1", "diff", "gt");
+        ulabel.state.current_subtask = "diff";
+        ulabel.set_subtask = jest.fn((key) => {
+            ulabel.state.current_subtask = key;
+        });
+        return { ulabel, on_annotation_change };
+    }
+
+    test("runs on the sole writable subtask in place", () => {
+        const { ulabel, on_annotation_change } = setup();
+
+        ulabel.undo();
+        expect(gt(ulabel, "g1").deprecated).toBe(false);
+        expect(ulabel.get_current_subtask_key()).toBe("diff");
+        expect(ulabel.toolbox.redraw_update_items).toHaveBeenCalled();
+        expect(on_annotation_change).toHaveBeenLastCalledWith(expect.objectContaining({ kind: "undo", subtask_key: "gt", from_subtask_key: "diff" }));
+
+        ulabel.redo();
+        expect(gt(ulabel, "g1").deprecated).toBe(true);
+        expect(ulabel.get_current_subtask_key()).toBe("diff");
+        expect(ulabel.set_subtask).not.toHaveBeenCalled();
+        expect(on_annotation_change).toHaveBeenLastCalledWith(expect.objectContaining({ kind: "redo", from_subtask_key: "diff" }));
+
+        ulabel.state.current_subtask = "gt";
+        ulabel.undo();
+        expect(on_annotation_change).toHaveBeenLastCalledWith(expect.objectContaining({ kind: "undo", from_subtask_key: null }));
+    });
+
+    test("switches to the writable subtask with paste_switch_to_target, only when there is something to do", () => {
+        const { ulabel } = setup();
+        ulabel.config.paste_switch_to_target = true;
+        const on_annotation_change = ulabel.config.on_annotation_change;
+
+        ulabel.redo();
+        expect(ulabel.set_subtask).not.toHaveBeenCalled();
+
+        ulabel.undo();
+        expect(ulabel.set_subtask).toHaveBeenCalledWith("gt");
+        expect(gt(ulabel, "g1").deprecated).toBe(false);
+        expect(on_annotation_change).toHaveBeenLastCalledWith(expect.objectContaining({ kind: "undo", from_subtask_key: "diff" }));
+        expect(ulabel.state.undo_redo_from_subtask).toBeNull();
+    });
+
+    test("does nothing with more than one writable subtask", () => {
+        const { ulabel } = setup();
+        ulabel.subtasks.ro.read_only = false;
+
+        ulabel.undo();
+        expect(gt(ulabel, "g1").deprecated).toBe(true);
+    });
+
+    test("does nothing when the top action was triggered in the writable subtask", () => {
+        const { ulabel } = setup();
+        ulabel.state.current_subtask = "gt";
+        ulabel.create_annotation("bbox", [[50, 50], [60, 60]], "n1");
+        ulabel.state.current_subtask = "diff";
+
+        ulabel.undo();
+        expect(gt(ulabel, "g1").deprecated).toBe(true);
+        expect(gt(ulabel, "n1")).toBeDefined();
+
+        ulabel.state.current_subtask = "gt";
+        ulabel.undo();
+        ulabel.state.current_subtask = "diff";
+        ulabel.undo();
+        expect(gt(ulabel, "n1")).toBeUndefined();
+        expect(gt(ulabel, "g1").deprecated).toBe(false);
+
+        // The Delete from is on top of the redo stack; the create beneath it was undone in gt
+        ulabel.redo();
+        expect(gt(ulabel, "g1").deprecated).toBe(true);
+        ulabel.redo();
+        expect(gt(ulabel, "n1")).toBeUndefined();
+    });
+
+    test("undoes a Copy to sent from the read-only subtask, but not a paste made in the writable one", () => {
+        const { ulabel } = setup();
+        const copy_id = ulabel.copy_annotation_to_subtask("d1", "diff", "gt");
+        ulabel.undo();
+        expect(gt(ulabel, copy_id)).toBeUndefined();
+        ulabel.redo();
+        expect(gt(ulabel, copy_id)).toBeDefined();
+        ulabel.undo();
+        expect(gt(ulabel, copy_id)).toBeUndefined();
+
+        ulabel.state.current_subtask = "gt";
+        const pasted_id = ulabel.paste_annotation(ulabel.subtasks.diff.annotations.access.d1, "gt", null, [0, 0], true, "diff");
+        ulabel.state.current_subtask = "diff";
+        ulabel.undo();
+        expect(gt(ulabel, pasted_id)).toBeDefined();
+    });
+
+    test("reports a blocked undo/redo to on_undo_redo_blocked, but not an empty history", () => {
+        const on_undo_redo_blocked = jest.fn();
+        const ulabel = make_ulabel({ gt: [make_bbox("g1")] }, { on_undo_redo_blocked });
+        ulabel.undo();
+        ulabel.redo();
+        expect(on_undo_redo_blocked).not.toHaveBeenCalled();
+
+        ulabel.state.current_subtask = "gt";
+        ulabel.delete_annotation("g1");
+        ulabel.state.current_subtask = "diff";
+        ulabel.undo();
+        expect(on_undo_redo_blocked).toHaveBeenLastCalledWith("undo", "gt", "diff", "gt");
+
+        ulabel.state.current_subtask = "gt";
+        ulabel.undo();
+        ulabel.state.current_subtask = "diff";
+        ulabel.redo();
+        expect(on_undo_redo_blocked).toHaveBeenLastCalledWith("redo", "gt", "diff", "gt");
+        expect(on_undo_redo_blocked).toHaveBeenCalledTimes(2);
+    });
+
+    test("does nothing for an action triggered from another read-only subtask", () => {
+        const ulabel = make_ulabel({ ro: [make_bbox("r1")] });
+        ulabel.state.current_subtask = "ro";
+        const copy_id = ulabel.copy_annotation_to_subtask("r1", "ro", "gt");
+        ulabel.state.current_subtask = "diff";
+
+        ulabel.undo();
+        expect(gt(ulabel, copy_id)).toBeDefined();
+
+        ulabel.state.current_subtask = "ro";
+        ulabel.undo();
+        expect(gt(ulabel, copy_id)).toBeUndefined();
+    });
+});
diff --git a/tests/deprecated_focus.test.js b/tests/deprecated_focus.test.js
new file mode 100644
index 00000000..0dce8384
--- /dev/null
+++ b/tests/deprecated_focus.test.js
@@ -0,0 +1,377 @@
+// Deprecated focus: with `focus_deprecated`, only deprecated annotations are in focus; Restore undeletes
+const { ULabel } = require("./testing-utils/build_loader");
+
+const LOADED_AT = "2026-01-01T00:00:00.000Z";
+
+function make_annotation(id, overrides = {}) {
+    return {
+        id,
+        spatial_type: "bbox",
+        spatial_payload: [[10, 10], [30, 30]],
+        containing_box: { tlx: 10, tly: 10, brx: 30, bry: 30 },
+        classification_payloads: [{ class_id: 1, confidence: 1.0 }],
+        deprecated: false,
+        last_edited_at: LOADED_AT,
+        last_edited_by: "host",
+        ...overrides,
+    };
+}
+
+function make_ulabel(resume = [], config_overrides = {}, subtask_overrides = {}) {
+    const ulabel = new ULabel({
+        container_id: "container",
+        image_data: "test.jpg",
+        username: "test_user",
+        image_width: 100,
+        image_height: 100,
+        submit_buttons: [{ name: "Submit", hook: jest.fn() }],
+        subtasks: {
+            gt: {
+                display_name: "GT",
+                classes: [
+                    { name: "Crop", id: 1, color: "green" },
+                    { name: "Weed", id: 2, color: "red" },
+                ],
+                allowed_modes: ["bbox"],
+                resume_from: resume,
+                ...subtask_overrides,
+            },
+        },
+        ...config_overrides,
+    });
+    ulabel.state.current_subtask = "gt";
+    for (const name of [
+        "redraw_annotation",
+        "redraw_all_annotations",
+        "rebuild_containing_box",
+        "update_filter_distance",
+        "suggest_edits",
+        "destroy_polygon_ender",
+        "destroy_annotation_context",
+        "hide_id_dialog",
+        "update_frame",
+        "recolor_active_polygon_ender",
+        "recolor_brush_circle",
+    ]) {
+        ulabel[name] = jest.fn();
+    }
+    ulabel.toolbox = { redraw_update_items: jest.fn() };
+    ulabel.get_init_canvas_context_id = jest.fn(() => "c0");
+    return ulabel;
+}
+
+function ann(ulabel, id) {
+    return ulabel.subtasks.gt.annotations.access[id];
+}
+
+function defocused(ulabel, id) {
+    return ulabel.is_annotation_defocused(ann(ulabel, id), "gt");
+}
+
+function reclassify(ulabel, id) {
+    ulabel.subtasks.gt.state.id_payload = [{ class_id: 1, confidence: 0.0 }, { class_id: 2, confidence: 1.0 }];
+    ulabel.assign_annotation_id(id);
+}
+
+describe("deprecated focus", () => {
+    test("is off by default and read from the subtask config", () => {
+        expect(make_ulabel().subtasks.gt.focus_deprecated).toBe(false);
+        expect(make_ulabel([], {}, { focus_deprecated: true }).subtasks.gt.focus_deprecated).toBe(true);
+    });
+
+    test("swaps which of live and deprecated annotations are in focus", () => {
+        const ulabel = make_ulabel([make_annotation("live"), make_annotation("gone", { deprecated: true })]);
+        expect(defocused(ulabel, "live")).toBe(false);
+        expect(defocused(ulabel, "gone")).toBe(true);
+
+        ulabel.set_focus_deprecated("gt", true, false);
+
+        expect(defocused(ulabel, "live")).toBe(true);
+        expect(defocused(ulabel, "gone")).toBe(false);
+    });
+
+    test("with edit focus, keeps only deletions of loaded annotations", () => {
+        const ulabel = make_ulabel(
+            [
+                make_annotation("deleted"),
+                make_annotation("filtered", { deprecated: true, deprecated_by: { confidence_filter: true } }),
+            ],
+            {},
+            { focus_deprecated: true, focus_edited: true },
+        );
+        ulabel.create_annotation("bbox", [[0, 0], [10, 10]], "fleeting");
+        ulabel.delete_annotation("deleted");
+        ulabel.delete_annotation("fleeting");
+
+        expect(defocused(ulabel, "deleted")).toBe(false);
+        expect(defocused(ulabel, "filtered")).toBe(true);
+        expect(defocused(ulabel, "fleeting")).toBe(true);
+    });
+
+    test("set_focus_deprecated reports only changes and releases a deprecated isolation when turned off", () => {
+        const on_focus_deprecated_change = jest.fn();
+        const ulabel = make_ulabel(
+            [make_annotation("gone", { deprecated: true })],
+            { on_focus_deprecated_change },
+        );
+        expect(ulabel.isolate_annotation("gone")).toBe(false);
+
+        ulabel.set_focus_deprecated("gt", true);
+        ulabel.set_focus_deprecated("gt", true);
+        expect(on_focus_deprecated_change).toHaveBeenCalledTimes(1);
+        expect(on_focus_deprecated_change).toHaveBeenCalledWith("gt", true);
+        expect(ulabel.isolate_annotation("gone")).toBe(true);
+
+        ulabel.set_focus_deprecated("gt", false);
+        expect(ulabel.get_isolated_annotation_id("gt")).toBeNull();
+        expect(on_focus_deprecated_change).toHaveBeenLastCalledWith("gt", false);
+    });
+
+    test("navigation skips deprecated annotations outside deprecated focus", () => {
+        const ulabel = make_ulabel([make_annotation("gone", { deprecated: true })]);
+        expect(ulabel.fly_to_annotation_id("gone", "gt")).toBe(false);
+    });
+
+    test("locks user edits like read-only while Restore stays available", () => {
+        const ulabel = make_ulabel([make_annotation("gone", { deprecated: true, deprecated_by: { human: true } })]);
+        const canvas_click = { button: 0, target: { id: ulabel.subtasks.gt.canvas_fid } };
+        expect(ulabel.is_subtask_edit_locked()).toBe(false);
+        expect(ULabel.get_drag_key_start(canvas_click, ulabel)).toBe("annotation");
+
+        ulabel.set_focus_deprecated("gt", true, false);
+
+        expect(ulabel.is_subtask_edit_locked()).toBe(true);
+        expect(ULabel.get_drag_key_start(canvas_click, ulabel)).toBeNull();
+        expect(ulabel.can_restore_annotation("gone")).toBe(true);
+    });
+
+    test("turning deprecated focus on discards the drawing in progress", () => {
+        const ulabel = make_ulabel([], {}, { allowed_modes: ["bbox", "polyline"] });
+        const subtask = ulabel.subtasks.gt;
+        ulabel.create_annotation("polyline", [[10, 10], [30, 30]], "draw");
+        subtask.state.active_id = "draw";
+        subtask.state.is_in_progress = true;
+
+        ulabel.set_focus_deprecated("gt", true, false);
+
+        expect(subtask.state.is_in_progress).toBe(false);
+        expect(subtask.annotations.access.draw).toBeUndefined();
+    });
+
+    test("the polygon brush ignores live polygons dimmed by deprecated focus", () => {
+        const square = [[[10, 10], [30, 10], [30, 30], [10, 30], [10, 10]]];
+        const ulabel = make_ulabel(
+            [make_annotation("g1", { spatial_type: "polygon", spatial_payload: square })],
+            {},
+            { allowed_modes: ["bbox", "polygon"], focus_deprecated: true },
+        );
+        for (const name of ["move_brush_circle", "update_id_toolbox_display", "recolor_brush_circle"]) {
+            ulabel[name] = jest.fn();
+        }
+        ulabel.get_global_mouse_x = () => 20;
+        ulabel.get_global_mouse_y = () => 20;
+        ulabel.get_brush_circle_spatial_payload = () => [[[0, 0], [20, 0], [20, 20], [0, 20], [0, 0]]];
+        ulabel.subtasks.gt.state.is_in_erase_mode = true;
+
+        ulabel.begin_brush({});
+
+        expect(ann(ulabel, "g1").spatial_payload).toEqual(square);
+        expect(ulabel.subtasks.gt.actions.stream).toEqual([]);
+        expect(ulabel.subtasks.gt.state.active_id).toBeNull();
+    });
+
+    test("the bitmask brush ignores live masks dimmed by deprecated focus", () => {
+        // Column 0, rows 0-49 of a 100x100 column-major RLE
+        const mask = { counts: [0, 50, 100 * 100 - 50], size: [100, 100] };
+        const ulabel = make_ulabel(
+            [make_annotation("m1", { spatial_type: "bitmask", spatial_payload: mask })],
+            {},
+            { allowed_modes: ["bbox", "bitmask"] },
+        );
+        expect(ulabel.find_bitmask_under_brush(0, 10, 5)).toBe("m1");
+
+        ulabel.set_focus_deprecated("gt", true, false);
+
+        expect(ulabel.find_bitmask_under_brush(0, 10, 5)).toBeNull();
+        expect(ulabel.find_bitmask_under_brush(0, 10, 5, 1)).toBeNull();
+    });
+});
+
+describe("restore", () => {
+    test("is offered only for human-only deletions on writable subtasks", () => {
+        const ulabel = make_ulabel([
+            make_annotation("live"),
+            make_annotation("human", { deprecated: true, deprecated_by: { human: true } }),
+            make_annotation("both", { deprecated: true, deprecated_by: { human: true, confidence_filter: true } }),
+            make_annotation("filter", { deprecated: true, deprecated_by: { distance_from_row: true } }),
+        ]);
+        expect(ulabel.can_restore_annotation("live")).toBe(false);
+        expect(ulabel.can_restore_annotation("human")).toBe(true);
+        expect(ulabel.can_restore_annotation("both")).toBe(false);
+        expect(ulabel.can_restore_annotation("filter")).toBe(false);
+
+        ulabel.subtasks.gt.read_only = true;
+        expect(ulabel.can_restore_annotation("human")).toBe(false);
+        expect(ulabel.restore_annotation("human")).toBe(false);
+        expect(ann(ulabel, "human").deprecated).toBe(true);
+    });
+
+    test("reverts the edit stamp to before the deletion; undo and redo follow", () => {
+        const ulabel = make_ulabel([make_annotation("g1")]);
+        ulabel.delete_annotation("g1");
+        const deleted_at = ann(ulabel, "g1").last_edited_at;
+        expect(deleted_at).not.toBe(LOADED_AT);
+
+        expect(ulabel.restore_annotation("g1")).toBe(true);
+        expect(ann(ulabel, "g1").deprecated).toBe(false);
+        expect(ann(ulabel, "g1").last_edited_at).toBe(LOADED_AT);
+        expect(ann(ulabel, "g1").last_edited_by).toBe("host");
+
+        ulabel.undo();
+        expect(ann(ulabel, "g1").deprecated).toBe(true);
+        expect(ann(ulabel, "g1").last_edited_at).toBe(deleted_at);
+
+        ulabel.redo();
+        expect(ann(ulabel, "g1").deprecated).toBe(false);
+        expect(ann(ulabel, "g1").last_edited_at).toBe(LOADED_AT);
+    });
+
+    test("keeps an edit made before the deletion", () => {
+        const ulabel = make_ulabel([make_annotation("g1")], {}, { focus_edited: true });
+        reclassify(ulabel, "g1");
+        const edited_at = ann(ulabel, "g1").last_edited_at;
+        ulabel.delete_annotation("g1");
+
+        ulabel.restore_annotation("g1");
+
+        expect(ann(ulabel, "g1").last_edited_at).toBe(edited_at);
+        expect(defocused(ulabel, "g1")).toBe(false);
+    });
+
+    test("an unedited restore leaves the annotation out of edit focus", () => {
+        const ulabel = make_ulabel([make_annotation("g1")], {}, { focus_edited: true });
+        ulabel.delete_annotation("g1");
+
+        ulabel.restore_annotation("g1");
+
+        expect(defocused(ulabel, "g1")).toBe(true);
+    });
+
+    test("stamps now when no recorded action deleted it", () => {
+        const ulabel = make_ulabel([make_annotation("g1", { deprecated: true, deprecated_by: { human: true } })]);
+
+        ulabel.restore_annotation("g1");
+
+        expect(ann(ulabel, "g1").deprecated).toBe(false);
+        expect(ann(ulabel, "g1").last_edited_at).not.toBe(LOADED_AT);
+        expect(ann(ulabel, "g1").last_edited_by).toBe("test_user");
+    });
+
+    test("is not offered for geometry that cannot stand alone", () => {
+        const deleted = { deprecated: true, deprecated_by: { human: true } };
+        const ulabel = make_ulabel([
+            make_annotation("empty", { ...deleted, spatial_type: "polygon", spatial_payload: [] }),
+            make_annotation("dot", { ...deleted, spatial_type: "polyline", spatial_payload: [[10, 10]] }),
+            make_annotation("line", { ...deleted, spatial_type: "polyline", spatial_payload: [[10, 10], [30, 30]] }),
+            make_annotation("eraser", { ...deleted, spatial_type: "delete_bbox" }),
+        ], {}, { allowed_modes: ["bbox", "polygon", "polyline", "delete_bbox"] });
+
+        expect(ulabel.can_restore_annotation("empty")).toBe(false);
+        expect(ulabel.can_restore_annotation("dot")).toBe(false);
+        expect(ulabel.can_restore_annotation("line")).toBe(true);
+        expect(ulabel.can_restore_annotation("eraser")).toBe(false);
+    });
+
+    test("a vertex delete that removes the annotation restores its original shape, unedited", () => {
+        const ulabel = make_ulabel(
+            [make_annotation("p1", { spatial_type: "polyline", spatial_payload: [[10, 10], [30, 30]] })],
+            {},
+            { allowed_modes: ["bbox", "polyline"] },
+        );
+        ulabel.delete_vertex("p1", "0");
+        expect(ann(ulabel, "p1").deprecated).toBe(true);
+        expect(ann(ulabel, "p1").spatial_payload).toEqual([[10, 10], [30, 30]]);
+
+        expect(ulabel.restore_annotation("p1")).toBe(true);
+        expect(ann(ulabel, "p1").spatial_payload).toEqual([[10, 10], [30, 30]]);
+        expect(ann(ulabel, "p1").last_edited_at).toBe(LOADED_AT);
+        expect(ulabel.has_edits()).toBe(false);
+
+        ulabel.undo();
+        ulabel.undo();
+        expect(ann(ulabel, "p1").deprecated).toBe(false);
+        ulabel.redo();
+        expect(ann(ulabel, "p1").deprecated).toBe(true);
+    });
+
+    test("a brush stroke that erases a polygon is one undo step and keeps the pre-stroke shape", () => {
+        const square = [[[10, 10], [30, 10], [30, 30], [10, 30], [10, 10]]];
+        const ulabel = make_ulabel(
+            [make_annotation("g1", { spatial_type: "polygon", spatial_payload: square })],
+            {},
+            { allowed_modes: ["bbox", "polygon"] },
+        );
+        for (const name of ["move_brush_circle", "update_id_toolbox_display", "recolor_brush_circle"]) {
+            ulabel[name] = jest.fn();
+        }
+        ulabel.get_global_mouse_x = () => 20;
+        ulabel.get_global_mouse_y = () => 20;
+        // Start the stroke across an edge, then sweep over the whole polygon
+        ulabel.get_brush_circle_spatial_payload = () => [[[0, 0], [20, 0], [20, 20], [0, 20], [0, 0]]];
+        ulabel.subtasks.gt.state.is_in_erase_mode = true;
+        ulabel.begin_brush({});
+        expect(ann(ulabel, "g1").spatial_payload).not.toEqual(square);
+        ulabel.get_brush_circle_spatial_payload = () => [[[0, 0], [100, 0], [100, 100], [0, 100], [0, 0]]];
+        ulabel.state.last_brush_stroke = null;
+        ulabel.continue_brush({});
+
+        expect(ulabel.subtasks.gt.actions.stream.map((action) => action.act_type)).toEqual(["delete_annotation"]);
+        expect(ann(ulabel, "g1").deprecated).toBe(true);
+        expect(ann(ulabel, "g1").spatial_payload).toEqual(square);
+        expect(ulabel.can_restore_annotation("g1")).toBe(true);
+
+        ulabel.undo();
+        expect(ann(ulabel, "g1").deprecated).toBe(false);
+        expect(ann(ulabel, "g1").spatial_payload).toEqual(square);
+        expect(ann(ulabel, "g1").last_edited_at).toBe(LOADED_AT);
+    });
+
+    test("reports a restore_annotation change", () => {
+        const on_annotation_change = jest.fn();
+        const ulabel = make_ulabel([make_annotation("g1")], { on_annotation_change });
+        ulabel.delete_annotation("g1");
+
+        ulabel.restore_annotation("g1");
+
+        expect(on_annotation_change).toHaveBeenLastCalledWith(expect.objectContaining({
+            act_type: "restore_annotation",
+            annotation_id: "g1",
+            kind: "do",
+        }));
+    });
+});
+
+describe("cancel", () => {
+    test("removes the drawing; undo brings it back in progress and redo removes it again", () => {
+        const ulabel = make_ulabel([], {}, { allowed_modes: ["bbox", "polyline"] });
+        const subtask = ulabel.subtasks.gt;
+        ulabel.create_annotation("polyline", [[10, 10], [30, 30]], "draw");
+        subtask.state.active_id = "draw";
+        subtask.state.is_in_progress = true;
+
+        ulabel.cancel_annotation();
+        expect(subtask.annotations.access.draw).toBeUndefined();
+        expect(subtask.annotations.ordering).not.toContain("draw");
+        expect(subtask.state.is_in_progress).toBe(false);
+
+        ulabel.undo();
+        expect(ann(ulabel, "draw").deprecated).toBe(false);
+        expect(subtask.annotations.ordering).toContain("draw");
+        expect(subtask.state.active_id).toBe("draw");
+        expect(subtask.state.is_in_progress).toBe(true);
+
+        ulabel.redo();
+        expect(subtask.annotations.access.draw).toBeUndefined();
+        expect(subtask.annotations.ordering).not.toContain("draw");
+    });
+});
diff --git a/tests/e2e/annotation_list.spec.js b/tests/e2e/annotation_list.spec.js
index e30a0d13..9eae6a0c 100644
--- a/tests/e2e/annotation_list.spec.js
+++ b/tests/e2e/annotation_list.spec.js
@@ -45,9 +45,10 @@ test.describe("Annotation List UI", () => {
         await page.keyboard.press("d");
         expect(await get_annotation_list_count(page)).toBe(1);
 
-        // Show deprecated annotation
+        // Show deprecated focuses the list on the deprecated annotation
         await toggle_show_deprecated(page, true);
-        expect(await get_annotation_list_count(page)).toBe(2);
+        expect(await get_annotation_list_count(page)).toBe(1);
+        await expect(page.locator(".annotation-list-item-deprecated")).toHaveCount(1);
     });
 });
 
diff --git a/tests/e2e/api-behavior.spec.js b/tests/e2e/api-behavior.spec.js
index 1a65397d..69ac4f6e 100644
--- a/tests/e2e/api-behavior.spec.js
+++ b/tests/e2e/api-behavior.spec.js
@@ -39,7 +39,7 @@ test.describe("ULabel API Behavior", () => {
         // (the check is: if (nonspatial_id !== null))
         const result = await page.evaluate(() => {
             try {
-                window.ulabel.suggest_edits(null, null, true);
+                window.ulabel.suggest_edits(null, null);
                 return { success: true };
             } catch (e) {
                 return { success: false, error: e.message };
diff --git a/tests/e2e/basic-functionality.spec.js b/tests/e2e/basic-functionality.spec.js
index 0d5d5cac..078f68d3 100644
--- a/tests/e2e/basic-functionality.spec.js
+++ b/tests/e2e/basic-functionality.spec.js
@@ -42,6 +42,17 @@ test.describe("ULabel Basic Functionality", () => {
         await expect(page.locator("a#md-btn--point")).toHaveClass(/sel/);
     });
 
+    test("clicking toolbox anchors does not navigate to #", async ({ page }) => {
+        await wait_for_ulabel_init(page);
+        const url_before = page.url();
+
+        await page.locator("a#md-btn--bbox").click();
+        await page.locator("a#recenter-button").click();
+        await page.locator("a.night-button").click();
+
+        expect(page.url()).toBe(url_before);
+    });
+
     test("should create bbox annotation", async ({ page }) => {
         await wait_for_ulabel_init(page);
 
@@ -161,48 +172,47 @@ test.describe("ULabel Basic Functionality", () => {
     });
 
     // The edit-suggestion container is 0-height and pinned to the box centre, so
-    // its rect top IS the anchor. The card hugs the button ring: above the anchor
-    // normally, below it when there is no room above. `ring_max` is the furthest
-    // the card's near edge may sit from the anchor (half a button + gap + slack),
-    // catching regressions where the card drifts away from the ring.
+    // its rect top IS the anchor. The card hugs the containing box: above the
+    // anchor normally, below it when there is no room above. `box_max` is the
+    // furthest the card's near edge may sit from the anchor (half the box's
+    // on-screen height + gap + slack), catching regressions where the card
+    // drifts away from the box.
     const get_card_geometry = async (page, conf_id, anchor_id) => {
         return page.evaluate(({ conf, anchor }) => {
             const card = document.querySelector(conf).getBoundingClientRect();
             const es_el = document.querySelector(anchor);
             const anchor_y = es_el.getBoundingClientRect().top;
-            const scale = es_el.offsetWidth > 0 ?
-                es_el.getBoundingClientRect().width / es_el.offsetWidth :
-                1;
-            const button = es_el.querySelector("a.global_sub_suggestion");
-            const button_half = (button ? button.offsetHeight : 60) / 2;
+            const st = window.ulabel.get_current_subtask();
+            const cbox = st.annotations.access[st.state.edit_candidate.annid].containing_box;
+            const box_half = (cbox.bry - cbox.tly) / 2 * window.ulabel.state.zoom_val;
             return {
                 card_top: card.top,
                 card_bottom: card.bottom,
                 anchor_y,
-                ring_max: button_half * scale + 10 + 8,
+                box_max: box_half + 10 + 8,
             };
         }, { conf: conf_id, anchor: anchor_id });
     };
 
-    test("confidence card flips below buttons when annotation is near the top of the image", async ({ page }) => {
+    test("confidence card flips below the box when annotation is near the top of the image", async ({ page }) => {
         await wait_for_ulabel_init(page);
 
         const subtask_key = await page.evaluate(() => window.ulabel.get_current_subtask_key());
         const conf_id = `#global_annotation_confidence__${subtask_key}`;
         const anchor_id = `#global_edit_suggestion__${subtask_key}`;
 
-        // Annotation well away from the top -> card above the buttons and box
+        // Annotation well away from the top -> card above the box
         await draw_bbox(page, [400, 400], [500, 500]);
         await page.waitForTimeout(100);
         await page.mouse.move(450, 450);
         await page.waitForTimeout(200);
 
         const mid = await get_card_geometry(page, conf_id, anchor_id);
-        // Card hugs the button ring above the anchor regardless of box size
+        // Card hugs the top edge of the box
         expect(mid.card_bottom).toBeLessThanOrEqual(mid.anchor_y - 5);
-        expect(mid.anchor_y - mid.card_bottom).toBeLessThanOrEqual(mid.ring_max);
+        expect(mid.anchor_y - mid.card_bottom).toBeLessThanOrEqual(mid.box_max);
 
-        // Annotation near the top edge -> card flips below the buttons
+        // Annotation near the top edge -> card flips below the box
         await draw_bbox(page, [100, 5], [200, 30]);
         await page.waitForTimeout(100);
         await page.mouse.move(150, 15);
@@ -210,7 +220,7 @@ test.describe("ULabel Basic Functionality", () => {
 
         const top_edge = await get_card_geometry(page, conf_id, anchor_id);
         expect(top_edge.card_top).toBeGreaterThanOrEqual(top_edge.anchor_y + 5);
-        expect(top_edge.card_top - top_edge.anchor_y).toBeLessThanOrEqual(top_edge.ring_max);
+        expect(top_edge.card_top - top_edge.anchor_y).toBeLessThanOrEqual(top_edge.box_max);
     });
 
     test("confidence card sits in the same spot when the subtask is read-only", async ({ page }) => {
@@ -236,19 +246,12 @@ test.describe("ULabel Basic Functionality", () => {
         await page.waitForTimeout(200);
         const read_only = await get_card_geometry(page, conf_id, anchor_id);
 
-        // Buttons are hidden with `visibility` so their flow space survives and the
-        // card lands in the exact same place (sub-pixel slack only).
-        const button_visibility = await page.evaluate(({ anchor }) => {
-            return getComputedStyle(
-                document.querySelector(anchor).querySelector("a.global_sub_suggestion"),
-            ).visibility;
-        }, { anchor: anchor_id });
-        expect(button_visibility).toBe("hidden");
+        // Read-only changes nothing about the card's anchor (sub-pixel slack only)
         expect(Math.abs(read_only.card_top - editable.card_top)).toBeLessThanOrEqual(1);
         expect(Math.abs(read_only.card_bottom - editable.card_bottom)).toBeLessThanOrEqual(1);
     });
 
-    test("confidence card hugs the ring on the single-class demo (0.666 dialog scale)", async ({ page }) => {
+    test("confidence card hugs the box on the single-class demo (0.666 dialog scale)", async ({ page }) => {
         await wait_for_ulabel_init(page, "/single-class.html");
 
         const subtask_key = await page.evaluate(() => window.ulabel.get_current_subtask_key());
@@ -262,9 +265,41 @@ test.describe("ULabel Basic Functionality", () => {
 
         const geom = await get_card_geometry(page, conf_id, anchor_id);
         expect(geom.card_bottom).toBeLessThanOrEqual(geom.anchor_y - 5);
-        expect(geom.anchor_y - geom.card_bottom).toBeLessThanOrEqual(geom.ring_max);
+        expect(geom.anchor_y - geom.card_bottom).toBeLessThanOrEqual(geom.box_max);
     });
 
+    for (const demo_path of ["/multi-class.html", "/single-class.html"]) {
+        test(`confidence card stays inside the side edges and recenters on ${demo_path}`, async ({ page }) => {
+            await wait_for_ulabel_init(page, demo_path);
+
+            const subtask_key = await get_current_subtask_key(page);
+            const conf_id = `#global_annotation_confidence__${subtask_key}`;
+            const bounds = await page.evaluate(() => {
+                const annbox = document.getElementById(window.ulabel.config.annbox_id);
+                const rect = annbox.getBoundingClientRect();
+                return {
+                    left: rect.left + annbox.clientLeft,
+                    right: rect.left + annbox.clientLeft + annbox.clientWidth,
+                    top: rect.top + annbox.clientTop,
+                };
+            });
+
+            for (const anchor_x of [bounds.left + 12, bounds.right - 12, (bounds.left + bounds.right) / 2]) {
+                const anchor_y = bounds.top + 220;
+                await draw_bbox(page, [anchor_x - 8, anchor_y - 20], [anchor_x + 8, anchor_y + 20]);
+                await page.mouse.move(anchor_x, anchor_y);
+                await expect(page.locator(conf_id)).toBeVisible();
+
+                const card = await page.locator(conf_id).boundingBox();
+                expect(card.x).toBeGreaterThanOrEqual(bounds.left);
+                expect(card.x + card.width).toBeLessThanOrEqual(bounds.right);
+                if (anchor_x === (bounds.left + bounds.right) / 2) {
+                    expect(Math.abs(card.x + card.width / 2 - anchor_x)).toBeLessThanOrEqual(1);
+                }
+            }
+        });
+    }
+
     test("confidence card flip check accounts for annbox scroll position", async ({ page }) => {
         await wait_for_ulabel_init(page);
 
diff --git a/tests/e2e/bitmask.spec.js b/tests/e2e/bitmask.spec.js
index 894bcd78..27f14d00 100644
--- a/tests/e2e/bitmask.spec.js
+++ b/tests/e2e/bitmask.spec.js
@@ -530,3 +530,104 @@ test.describe("Bitmask move bounce-back", () => {
         expect(res.after_redo.cbox).toEqual({ tlx: 15, tly: 10, brx: 25, bry: 20 });
     });
 });
+
+test.describe("Bitmask isolation lifecycle", () => {
+    // Paint (or erase) one brush dab at the centre of the annotation canvas
+    async function dab(page) {
+        const center = await page.evaluate(() => {
+            const u = window.ulabel;
+            const rect = document.getElementById(u.get_current_subtask().canvas_fid).getBoundingClientRect();
+            return [rect.x + rect.width / 2, rect.y + rect.height / 2];
+        });
+        await page.mouse.move(center[0], center[1]);
+        await page.mouse.down();
+        await page.mouse.move(center[0] + 2, center[1] + 2, { steps: 2 });
+        await page.mouse.up();
+        await page.waitForTimeout(100);
+    }
+
+    async function state(page) {
+        return await page.evaluate(() => {
+            const u = window.ulabel;
+            const st = u.get_current_subtask();
+            const fresh_id = st.annotations.ordering.at(-1);
+            return {
+                count: st.annotations.ordering.length,
+                fresh_id: fresh_id,
+                fresh_deprecated: st.annotations.access[fresh_id].deprecated,
+                isolated: u.get_isolated_annotation_id(),
+                base_defocused: u.is_annotation_defocused(st.annotations.access.base, "a"),
+                last_action: st.actions.stream.at(-1)?.act_type ?? null,
+                cleared_calls: window.__isolate_calls.filter((c) => c[1] === null).length,
+            };
+        });
+    }
+
+    async function isolate_fresh(page) {
+        await page.evaluate(() => {
+            const u = window.ulabel;
+            u.isolate_annotation(u.get_current_subtask().annotations.ordering.at(-1));
+        });
+    }
+
+    test.beforeEach(async ({ page }) => {
+        await wait_for_ulabel_init(page, "/bitmask-e2e.html");
+        await page.evaluate(async () => {
+            const u = window.ulabel;
+            const { make, rebuild } = window.__mask_helpers(u);
+            await u.set_annotations([make("base", 1, 2, 2, 8, 8)], "a");
+            rebuild("a", "base");
+            window.__isolate_calls = [];
+            u.config.on_isolate_change = (key, id) => window.__isolate_calls.push([key, id]);
+            u.set_subtask("a");
+            u.toggle_brush_mode({ pageX: 0, pageY: 0 });
+        });
+        await dab(page);
+        expect((await state(page)).count).toBe(2);
+    });
+
+    test("undoing the first stroke of the isolated mask clears the isolation", async ({ page }) => {
+        await isolate_fresh(page);
+        expect((await state(page)).base_defocused).toBe(true);
+
+        await page.keyboard.press("Control+z");
+        await page.waitForTimeout(100);
+
+        const after = await state(page);
+        expect(after.fresh_deprecated).toBe(true);
+        expect(after.isolated).toBeNull();
+        expect(after.base_defocused).toBe(false);
+        expect(after.cleared_calls).toBe(1);
+    });
+
+    test("erasing the whole isolated mask, and redoing that erasure, clears the isolation", async ({ page }) => {
+        await isolate_fresh(page);
+        // A wider erase brush over the same spot wipes the single paint dab
+        await page.evaluate(() => {
+            window.ulabel.config.brush_size *= 3;
+            window.ulabel.toggle_erase_mode({ pageX: 0, pageY: 0 });
+        });
+        await dab(page);
+
+        let after = await state(page);
+        expect(after.last_action).toBe("bitmask_stroke");
+        expect(after.fresh_deprecated).toBe(true);
+        expect(after.isolated).toBeNull();
+        expect(after.base_defocused).toBe(false);
+        expect(after.cleared_calls).toBe(1);
+
+        // Undo the erasure, isolate the restored mask, then redo the erasure
+        await page.keyboard.press("Control+z");
+        await page.waitForTimeout(100);
+        expect((await state(page)).fresh_deprecated).toBe(false);
+        await isolate_fresh(page);
+        await page.keyboard.press("Control+Shift+z");
+        await page.waitForTimeout(100);
+
+        after = await state(page);
+        expect(after.fresh_deprecated).toBe(true);
+        expect(after.isolated).toBeNull();
+        expect(after.base_defocused).toBe(false);
+        expect(after.cleared_calls).toBe(2);
+    });
+});
diff --git a/tests/e2e/body-move.spec.js b/tests/e2e/body-move.spec.js
new file mode 100644
index 00000000..f10c726e
--- /dev/null
+++ b/tests/e2e/body-move.spec.js
@@ -0,0 +1,180 @@
+// End-to-end tests for body-drag move: hover an annotation, left-drag its body
+import { test, expect } from "./fixtures";
+import { draw_bbox, draw_point, draw_polygon } from "../testing-utils/drawing_utils";
+import { wait_for_ulabel_init } from "../testing-utils/init_utils";
+import { get_annotation_count, get_annotation_by_index } from "../testing-utils/annotation_utils";
+
+// Drag from `from` to `to` with the left button, hovering first so the move
+// candidate is populated like a real interaction.
+async function drag(page, from, to, options = {}) {
+    await page.mouse.move(from[0], from[1]);
+    await page.waitForTimeout(100);
+    if (options.modifier) await page.keyboard.down(options.modifier);
+    await page.mouse.down();
+    await page.mouse.move(from[0] + (to[0] - from[0]) / 2, from[1] + (to[1] - from[1]) / 2);
+    await page.mouse.move(to[0], to[1]);
+    await page.mouse.up();
+    if (options.modifier) await page.keyboard.up(options.modifier);
+    await page.waitForTimeout(100);
+}
+
+// Translate every point of a spatial payload (any nesting) by a screen delta
+// expressed in image space.
+async function translated(page, payload, screen_delta) {
+    const zoom = await page.evaluate(() => window.ulabel.state.zoom_val);
+    const shift = (pt) => [pt[0] + screen_delta[0] / zoom, pt[1] + screen_delta[1] / zoom];
+    const walk = (node) => (typeof node[0] === "number" ? shift(node) : node.map(walk));
+    return walk(payload);
+}
+
+function expect_payload_close(actual, expected) {
+    const flat = (node) => (typeof node[0] === "number" ? [node] : node.flatMap(flat));
+    const a = flat(actual);
+    const e = flat(expected);
+    expect(a.length).toBe(e.length);
+    for (let i = 0; i < a.length; i++) {
+        expect(a[i][0]).toBeCloseTo(e[i][0], 0);
+        expect(a[i][1]).toBeCloseTo(e[i][1], 0);
+    }
+}
+
+test.describe("body-drag move", () => {
+    test("dragging a bbox body moves it and undo restores it", async ({ page }) => {
+        await wait_for_ulabel_init(page);
+        const bbox = await draw_bbox(page, [200, 200], [300, 300]);
+
+        await drag(page, [250, 250], [290, 270]);
+
+        expect(await get_annotation_count(page)).toBe(1);
+        const moved = await get_annotation_by_index(page, 0);
+        expect_payload_close(moved.spatial_payload, await translated(page, bbox, [40, 20]));
+        // Hover ring is gone: nothing draggable was rendered for it
+        await expect(page.locator(".movable")).toHaveCount(0);
+
+        await page.keyboard.press("Control+z");
+        await page.waitForTimeout(100);
+        const restored = await get_annotation_by_index(page, 0);
+        expect_payload_close(restored.spatial_payload, bbox);
+    });
+
+    test("dragging a point body moves it", async ({ page }) => {
+        await wait_for_ulabel_init(page);
+        const point = await draw_point(page, [300, 300]);
+
+        await drag(page, [300, 300], [330, 340]);
+
+        expect(await get_annotation_count(page)).toBe(1);
+        const moved = await get_annotation_by_index(page, 0);
+        expect_payload_close(moved.spatial_payload, await translated(page, point, [30, 40]));
+    });
+
+    test("dragging a polygon body moves it", async ({ page }) => {
+        await wait_for_ulabel_init(page);
+        const polygon = await draw_polygon(page, [[200, 200], [320, 200], [320, 320], [200, 320]]);
+
+        await drag(page, [260, 260], [300, 280]);
+
+        expect(await get_annotation_count(page)).toBe(1);
+        const moved = await get_annotation_by_index(page, 0);
+        expect_payload_close(moved.spatial_payload, await translated(page, polygon, [40, 20]));
+    });
+
+    test("dragging a vertex handle edits that vertex only", async ({ page }) => {
+        await wait_for_ulabel_init(page);
+        const bbox = await draw_bbox(page, [200, 200], [300, 300]);
+
+        // Hover the corner so the edit handle appears, then drag the handle itself
+        await page.mouse.move(300, 300);
+        await page.waitForTimeout(150);
+        const subtask_key = await page.evaluate(() => window.ulabel.get_current_subtask_key());
+        const handle = page.locator(`#edit_suggestion__${subtask_key}`);
+        await expect(handle).toBeVisible();
+        const box = await handle.boundingBox();
+        await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
+        await page.mouse.down();
+        await page.mouse.move(330, 340);
+        await page.mouse.up();
+        await page.waitForTimeout(100);
+
+        const edited = await get_annotation_by_index(page, 0);
+        const [[x0, y0], [x1, y1]] = edited.spatial_payload;
+        expect(Math.min(x0, x1)).toBeCloseTo(bbox[0][0], 0);
+        expect(Math.min(y0, y1)).toBeCloseTo(bbox[0][1], 0);
+        expect(Math.max(x0, x1)).toBeGreaterThan(bbox[1][0]);
+        expect(Math.max(y0, y1)).toBeGreaterThan(bbox[1][1]);
+    });
+
+    test("holding the force-draw modifier draws a new annotation over a body", async ({ page }) => {
+        await wait_for_ulabel_init(page);
+        const bbox = await draw_bbox(page, [200, 200], [300, 300]);
+
+        await drag(page, [220, 220], [280, 280], { modifier: "Alt" });
+
+        expect(await get_annotation_count(page)).toBe(2);
+        const first = await get_annotation_by_index(page, 0);
+        expect_payload_close(first.spatial_payload, bbox);
+    });
+
+    test("a plain click on a body leaves no undo entry", async ({ page }) => {
+        await wait_for_ulabel_init(page);
+        await draw_bbox(page, [200, 200], [300, 300]);
+        const before = await page.evaluate(() => window.ulabel.get_current_subtask().actions.stream.length);
+
+        await page.mouse.move(250, 250);
+        await page.waitForTimeout(100);
+        await page.mouse.down();
+        await page.mouse.up();
+        await page.waitForTimeout(100);
+
+        const after = await page.evaluate(() => window.ulabel.get_current_subtask().actions.stream.length);
+        expect(after).toBe(before);
+        expect(await get_annotation_count(page)).toBe(1);
+    });
+
+    test("read-only subtasks ignore body drags", async ({ page }) => {
+        await wait_for_ulabel_init(page);
+        const bbox = await draw_bbox(page, [200, 200], [300, 300]);
+        await page.evaluate(() => {
+            window.ulabel.get_current_subtask().read_only = true;
+        });
+
+        await drag(page, [250, 250], [290, 270]);
+
+        expect(await get_annotation_count(page)).toBe(1);
+        const unchanged = await get_annotation_by_index(page, 0);
+        expect_payload_close(unchanged.spatial_payload, bbox);
+    });
+
+    // A polyline whose single long segment runs from (200,200) to (400,200) on screen
+    async function create_polyline(page) {
+        return await page.evaluate(() => {
+            const u = window.ulabel;
+            const g = (x, y) => u.get_image_aware_mouse_x_y({ pageX: x, pageY: y });
+            const payload = [g(200, 200), g(400, 200)];
+            u.create_annotation("polyline", payload, "line");
+            return payload;
+        });
+    }
+
+    test("dragging a polyline stroke away from the segment midpoint moves it", async ({ page }) => {
+        await wait_for_ulabel_init(page);
+        const line = await create_polyline(page);
+
+        await drag(page, [230, 200], [260, 240]);
+
+        const moved = await get_annotation_by_index(page, 0);
+        expect_payload_close(moved.spatial_payload, await translated(page, line, [30, 40]));
+    });
+
+    test("dragging the segment midpoint handle inserts a vertex", async ({ page }) => {
+        await wait_for_ulabel_init(page);
+        const line = await create_polyline(page);
+
+        await drag(page, [300, 200], [300, 260]);
+
+        const edited = await get_annotation_by_index(page, 0);
+        expect(edited.spatial_payload).toHaveLength(3);
+        expect_payload_close([edited.spatial_payload[0], edited.spatial_payload[2]], line);
+        expect(edited.spatial_payload[1][1]).toBeGreaterThan(line[0][1]);
+    });
+});
diff --git a/tests/e2e/context-menu.spec.js b/tests/e2e/context-menu.spec.js
new file mode 100644
index 00000000..2a663dfe
--- /dev/null
+++ b/tests/e2e/context-menu.spec.js
@@ -0,0 +1,198 @@
+// End-to-end tests for the right-click context menu on the canvas and the
+// annotation list.
+import { test, expect } from "./fixtures";
+import { draw_bbox } from "../testing-utils/drawing_utils";
+import { wait_for_ulabel_init } from "../testing-utils/init_utils";
+import { get_annotation_count, get_annotation_by_index, get_annotation_class_id } from "../testing-utils/annotation_utils";
+
+const MENU = ".ulabel-context-menu";
+const ITEM = ".ulabel-context-menu-item";
+
+async function right_click(page, position) {
+    await page.mouse.move(position[0], position[1]);
+    await page.waitForTimeout(100);
+    await page.mouse.click(position[0], position[1], { button: "right" });
+    await page.waitForTimeout(100);
+}
+
+async function click_item(page, label) {
+    await page.locator(ITEM, { hasText: label }).click();
+    await page.waitForTimeout(100);
+}
+
+async function expand_annotation_list(page) {
+    // The list is collapsed by default; a click on its header expands it
+    const list = page.locator(".annotation-list-content");
+    if (!(await list.isVisible())) {
+        await page.locator(".annotation-list-header").click();
+    }
+    await expect(list).toBeVisible();
+}
+
+test.describe("context menu", () => {
+    test("right-click on a body opens the menu and Change class reclassifies via the pie", async ({ page }) => {
+        await wait_for_ulabel_init(page);
+        await draw_bbox(page, [200, 200], [300, 300]);
+        const before = get_annotation_class_id(await get_annotation_by_index(page, 0));
+
+        await right_click(page, [250, 250]);
+        const menu = page.locator(MENU);
+        await expect(menu).toBeVisible();
+        await expect(menu.locator(ITEM)).toHaveText(["Change class", "Delete", "Isolate", "Details"]);
+
+        await click_item(page, "Change class");
+        await expect(menu).toBeHidden();
+        const subtask_key = await page.evaluate(() => window.ulabel.get_current_subtask_key());
+        await expect(page.locator(`#id_dialog__${subtask_key}`)).toBeVisible();
+
+        // Pick the second wedge through the pie's own click handler
+        const target_class_id = await page.evaluate(() => {
+            const u = window.ulabel;
+            u.handle_id_dialog_click(null, null, 1);
+            return u.get_current_subtask().class_ids[1];
+        });
+        await page.waitForTimeout(100);
+        expect(target_class_id).not.toBe(before);
+        expect(get_annotation_class_id(await get_annotation_by_index(page, 0))).toBe(target_class_id);
+        await expect(page.locator(`#id_dialog__${subtask_key}`)).toBeHidden();
+
+        await page.keyboard.press("Control+z");
+        await page.waitForTimeout(100);
+        expect(get_annotation_class_id(await get_annotation_by_index(page, 0))).toBe(before);
+    });
+
+    test("right-click on a list entry and Delete removes it; undo restores", async ({ page }) => {
+        await wait_for_ulabel_init(page);
+        await draw_bbox(page, [200, 200], [300, 300]);
+        const annotation_id = (await get_annotation_by_index(page, 0)).id;
+        await expand_annotation_list(page);
+
+        const entry = page.locator(`.annotation-list-item[data-annotation-id="${annotation_id}"]`);
+        await expect(entry).toBeVisible();
+        await entry.click({ button: "right" });
+        await page.waitForTimeout(100);
+
+        const menu = page.locator(MENU);
+        await expect(menu).toBeVisible();
+        // The right-clicked entry stays highlighted while the menu is open
+        await expect(entry).toHaveClass(/highlighted/);
+
+        await click_item(page, "Delete");
+        await expect(menu).toBeHidden();
+        expect((await get_annotation_by_index(page, 0)).deprecated).toBe(true);
+        await expect(entry).toHaveCount(0);
+
+        await page.keyboard.press("Control+z");
+        await page.waitForTimeout(100);
+        expect((await get_annotation_by_index(page, 0)).deprecated).toBe(false);
+        await expect(page.locator(`.annotation-list-item[data-annotation-id="${annotation_id}"]`)).toHaveCount(1);
+    });
+
+    test("Details lists the annotation's fields", async ({ page }) => {
+        await wait_for_ulabel_init(page);
+        await draw_bbox(page, [200, 200], [300, 300]);
+        const annotation = await get_annotation_by_index(page, 0);
+
+        await right_click(page, [250, 250]);
+        await click_item(page, "Details");
+
+        const menu = page.locator(MENU);
+        await expect(menu).toBeVisible();
+        await expect(menu.locator(ITEM)).toHaveCount(0);
+        const values = menu.locator(".ulabel-context-menu-detail-value");
+        await expect(values.nth(0)).toHaveText(annotation.id);
+        await expect(values.nth(2)).toHaveText("bbox");
+    });
+
+    test("Details opened at the viewport corner stays inside it and scrolls when tall", async ({ page }) => {
+        await wait_for_ulabel_init(page);
+        await draw_bbox(page, [200, 200], [300, 300]);
+        const annotation = await get_annotation_by_index(page, 0);
+        const viewport = page.viewportSize();
+        await page.evaluate(([annid, n]) => {
+            const meta = {};
+            for (let i = 0; i < n; i++) meta[`field_${i}`] = "x".repeat(60);
+            window.ulabel.get_current_subtask().annotations.access[annid].annotation_meta = meta;
+            window.ulabel.show_context_menu(annid, window.innerWidth - 10, window.innerHeight - 10);
+        }, [annotation.id, 80]);
+
+        const menu = page.locator(MENU);
+        await expect(menu).toBeVisible();
+        await click_item(page, "Details");
+        await expect(menu.locator(ITEM)).toHaveCount(0);
+
+        const box = await menu.boundingBox();
+        expect(box.x).toBeGreaterThanOrEqual(0);
+        expect(box.y).toBeGreaterThanOrEqual(0);
+        expect(box.x + box.width).toBeLessThanOrEqual(viewport.width);
+        expect(box.y + box.height).toBeLessThanOrEqual(viewport.height);
+        const scrolls = await menu.evaluate((el) => el.scrollHeight > el.clientHeight);
+        expect(scrolls).toBe(true);
+    });
+
+    test("Escape and a click elsewhere close the menu without side effects", async ({ page }) => {
+        await wait_for_ulabel_init(page);
+        await draw_bbox(page, [200, 200], [300, 300]);
+        const menu = page.locator(MENU);
+
+        await right_click(page, [250, 250]);
+        await expect(menu).toBeVisible();
+        await page.keyboard.press("Escape");
+        await expect(menu).toBeHidden();
+
+        await right_click(page, [250, 250]);
+        await expect(menu).toBeVisible();
+        // The dismissing click on empty canvas must not start a new annotation
+        await page.mouse.click(500, 500);
+        await page.waitForTimeout(100);
+        await expect(menu).toBeHidden();
+        expect(await get_annotation_count(page)).toBe(1);
+    });
+
+    test("right-click on empty canvas opens nothing", async ({ page }) => {
+        await wait_for_ulabel_init(page);
+        await right_click(page, [500, 500]);
+        await expect(page.locator(MENU)).toHaveCount(0);
+    });
+
+    test("right-click mid-polyline finishes it and opens no menu", async ({ page }) => {
+        await wait_for_ulabel_init(page);
+        await page.click("a#md-btn--polyline");
+        await page.mouse.click(200, 200);
+        await page.mouse.click(300, 200);
+        await page.mouse.move(300, 300);
+        await page.mouse.click(300, 300, { button: "right" });
+        await page.waitForTimeout(150);
+
+        await expect(page.locator(MENU)).toHaveCount(0);
+        expect(await get_annotation_count(page)).toBe(1);
+        const in_progress = await page.evaluate(() => window.ulabel.get_current_subtask().state.is_in_progress);
+        expect(in_progress).toBe(false);
+    });
+
+    test("read-only subtask offers Isolate and Details only", async ({ page }) => {
+        await wait_for_ulabel_init(page, "/read-only.html");
+        const opened = await page.evaluate(() => window.ulabel.show_context_menu("ro-bbox-1", 300, 300));
+        expect(opened).toBe(true);
+        await expect(page.locator(MENU).locator(ITEM)).toHaveText(["Isolate", "Details"]);
+    });
+
+    test("Isolate toggles isolation and relabels to Show all", async ({ page }) => {
+        await wait_for_ulabel_init(page);
+        await draw_bbox(page, [200, 200], [300, 300]);
+        await draw_bbox(page, [400, 200], [500, 300]);
+        const annotation_id = (await get_annotation_by_index(page, 0)).id;
+        const isolated_id = () => page.evaluate(() => window.ulabel.get_isolated_annotation_id());
+
+        await right_click(page, [250, 250]);
+        await click_item(page, "Isolate");
+        await expect(page.locator(MENU)).toBeHidden();
+        expect(await isolated_id()).toBe(annotation_id);
+
+        await right_click(page, [250, 250]);
+        await expect(page.locator(MENU).locator(ITEM, { hasText: "Show all" })).toHaveCount(1);
+        await click_item(page, "Show all");
+        await expect(page.locator(MENU)).toBeHidden();
+        expect(await isolated_id()).toBeNull();
+    });
+});
diff --git a/tests/e2e/copy-annotation.spec.js b/tests/e2e/copy-annotation.spec.js
new file mode 100644
index 00000000..fed49889
--- /dev/null
+++ b/tests/e2e/copy-annotation.spec.js
@@ -0,0 +1,343 @@
+// End-to-end tests for copying / cutting annotations between subtasks via the
+// context menu and the clipboard shortcuts, against demo/submit-payload.html
+// (two writable subtasks sharing three classes).
+import { test, expect } from "./fixtures";
+import { wait_for_ulabel_init } from "../testing-utils/init_utils";
+
+const MENU = ".ulabel-context-menu";
+const ITEM = ".ulabel-context-menu-item";
+
+async function open_menu(page, annotation_id) {
+    await page.evaluate((annid) => {
+        window.ulabel.show_context_menu(annid, 400, 300);
+    }, annotation_id);
+    await expect(page.locator(MENU)).toBeVisible();
+}
+
+async function click_item(page, label) {
+    await page.locator(ITEM, { hasText: label }).click();
+    await page.waitForTimeout(100);
+}
+
+async function get_annotations(page, subtask_key) {
+    return await page.evaluate((key) => {
+        const subtask = window.ulabel.subtasks[key];
+        return subtask.annotations.ordering.map((id) => {
+            const annotation = subtask.annotations.access[id];
+            return {
+                id: annotation.id,
+                deprecated: annotation.deprecated,
+                spatial_type: annotation.spatial_type,
+                spatial_payload: annotation.spatial_payload,
+                class_id: annotation.classification_payloads.reduce((best, payload) => {
+                    if (best === null || payload.confidence > best.confidence) return payload;
+                    return best;
+                }, null).class_id,
+            };
+        });
+    }, subtask_key);
+}
+
+async function current_subtask_key(page) {
+    return await page.evaluate(() => window.ulabel.get_current_subtask_key());
+}
+
+async function reclassify(page, subtask_key, annotation_id, wedge) {
+    await page.evaluate(([key, annid, index]) => {
+        window.ulabel.set_subtask(key);
+        window.ulabel.handle_id_dialog_click(null, annid, index);
+    }, [subtask_key, annotation_id, wedge]);
+    await page.waitForTimeout(100);
+}
+
+function create_clipboard_driver(page, transport) {
+    let clipboard_text = "";
+    return async (kind, target = "body", handled = true) => {
+        if (transport === "native shortcuts") {
+            const keys = { copy: "c", cut: "x", paste: "v" };
+            await page.keyboard.press(`ControlOrMeta+${keys[kind]}`);
+            return;
+        }
+        const result = await page.locator(target).evaluate((element, { kind, text }) => {
+            const clipboard_data = new DataTransfer();
+            const event = new ClipboardEvent(kind, {
+                bubbles: true,
+                cancelable: true,
+                clipboardData: clipboard_data,
+            });
+            if (kind === "paste") event.clipboardData.setData("text/plain", text);
+            element.dispatchEvent(event);
+            return {
+                handled: event.defaultPrevented,
+                text: event.clipboardData.getData("text/plain"),
+            };
+        }, { kind, text: clipboard_text });
+        expect(result.handled).toBe(handled);
+        if (kind !== "paste" && handled) {
+            expect(JSON.parse(result.text).ulabel_annotation).toBe(1);
+            clipboard_text = result.text;
+        }
+    };
+}
+
+test.describe("copy annotations between subtasks", () => {
+    test("Copy to via the menu clones the annotation and keeps its class", async ({ page }) => {
+        await wait_for_ulabel_init(page, "/submit-payload.html");
+
+        await open_menu(page, "gt-bbox-1");
+        const menu = page.locator(MENU);
+        await expect(menu.locator(ITEM)).toHaveText([
+            "Change class",
+            "Copy to Predictions",
+            "Move to Predictions",
+            "Delete",
+            "Isolate",
+            "Details",
+        ]);
+
+        await click_item(page, "Copy to Predictions");
+        await expect(menu).toBeHidden();
+
+        // The target has the same class id, so no class pie and no subtask switch
+        expect(await current_subtask_key(page)).toBe("ground_truth");
+        await expect(page.locator("#id_dialog__predictions")).toBeHidden();
+
+        const predictions = await get_annotations(page, "predictions");
+        expect(predictions).toHaveLength(2);
+        const copy = predictions[1];
+        expect(copy.id).not.toBe("gt-bbox-1");
+        expect(copy.spatial_type).toBe("bbox");
+        expect(copy.spatial_payload).toEqual([[100, 100], [300, 250]]);
+        expect(copy.class_id).toBe(10);
+
+        // The source is untouched
+        const ground_truth = await get_annotations(page, "ground_truth");
+        expect(ground_truth).toHaveLength(2);
+        expect(ground_truth[0].deprecated).toBe(false);
+    });
+
+    test("a repeat Copy to asks first; with paste_switch_to_target the view lands on the target", async ({ page }) => {
+        await wait_for_ulabel_init(page, "/submit-payload.html");
+        await open_menu(page, "gt-bbox-1");
+        await click_item(page, "Copy to Predictions");
+        expect(await get_annotations(page, "predictions")).toHaveLength(2);
+
+        // Cancel the confirm: nothing is copied
+        page.once("dialog", (dialog) => {
+            expect(dialog.message()).toBe("Predictions already has this annotation. Copy it there anyway?");
+            dialog.dismiss();
+        });
+        await open_menu(page, "gt-bbox-1");
+        await click_item(page, "Copy to Predictions");
+        expect(await get_annotations(page, "predictions")).toHaveLength(2);
+        expect(await current_subtask_key(page)).toBe("ground_truth");
+
+        // Accept it with the switch enabled: copied and now on the target
+        await page.evaluate(() => window.ulabel.set_paste_switch_to_target(true));
+        page.once("dialog", (dialog) => dialog.accept());
+        await open_menu(page, "gt-bbox-1");
+        await click_item(page, "Copy to Predictions");
+        expect(await get_annotations(page, "predictions")).toHaveLength(3);
+        expect(await current_subtask_key(page)).toBe("predictions");
+        await expect(page.locator("#id_dialog__predictions")).toBeHidden();
+    });
+
+    test("Delete from removes the copy on the target's stream; undo there restores it", async ({ page }) => {
+        await wait_for_ulabel_init(page, "/submit-payload.html");
+        await open_menu(page, "gt-bbox-1");
+        await click_item(page, "Copy to Predictions");
+        const copy_id = (await get_annotations(page, "predictions"))[1].id;
+
+        await open_menu(page, "gt-bbox-1");
+        await expect(page.locator(MENU).locator(ITEM, { hasText: "Delete from Predictions" })).toBeVisible();
+        await click_item(page, "Delete from Predictions");
+
+        expect((await get_annotations(page, "predictions"))[1].deprecated).toBe(true);
+        expect((await get_annotations(page, "ground_truth"))[0].deprecated).toBe(false);
+        expect(await current_subtask_key(page)).toBe("ground_truth");
+
+        // Gone from the target: no more Delete from
+        await open_menu(page, "gt-bbox-1");
+        await expect(page.locator(MENU).locator(ITEM, { hasText: "Delete from" })).toHaveCount(0);
+
+        await page.evaluate(() => {
+            window.ulabel.hide_context_menu();
+            window.ulabel.set_subtask("predictions");
+            window.ulabel.undo();
+        });
+        const predictions = await get_annotations(page, "predictions");
+        expect(predictions[1].id).toBe(copy_id);
+        expect(predictions[1].deprecated).toBe(false);
+    });
+
+    test("Move to is one undoable action on the source subtask", async ({ page }) => {
+        await wait_for_ulabel_init(page, "/submit-payload.html");
+        const page_errors = [];
+        page.on("pageerror", (error) => page_errors.push(error.message));
+
+        await open_menu(page, "gt-bbox-2");
+        await click_item(page, "Move to Predictions");
+
+        expect((await get_annotations(page, "ground_truth"))[1].deprecated).toBe(true);
+        let predictions = await get_annotations(page, "predictions");
+        expect(predictions).toHaveLength(2);
+        expect(predictions[1].spatial_payload).toEqual([[400, 150], [600, 320]]);
+        expect(predictions[1].class_id).toBe(11);
+
+        // Reclassify the copy in the target
+        await reclassify(page, "predictions", predictions[1].id, 2);
+        predictions = await get_annotations(page, "predictions");
+        expect(predictions[1].class_id).toBe(12);
+
+        // Undo in the target (current subtask) only reverts the reclassify
+        await page.keyboard.press("Control+z");
+        await page.waitForTimeout(100);
+        predictions = await get_annotations(page, "predictions");
+        expect(predictions).toHaveLength(2);
+        expect(predictions[1].class_id).toBe(11);
+        await page.keyboard.press("Control+z");
+        await page.waitForTimeout(100);
+        expect(await get_annotations(page, "predictions")).toHaveLength(2);
+
+        // Undo in the source restores the annotation and removes the copy
+        await page.evaluate(() => window.ulabel.set_subtask("ground_truth"));
+        await page.keyboard.press("Control+z");
+        await page.waitForTimeout(100);
+        expect((await get_annotations(page, "ground_truth"))[1].deprecated).toBe(false);
+        expect(await get_annotations(page, "predictions")).toHaveLength(1);
+
+        // The target forgot the copy's reclassify: nothing to redo there
+        await page.evaluate(() => window.ulabel.set_subtask("predictions"));
+        await page.keyboard.press("Control+Shift+z");
+        await page.waitForTimeout(100);
+        expect(await get_annotations(page, "predictions")).toHaveLength(1);
+        expect(page_errors).toEqual([]);
+
+        // Redo replays the whole move
+        await page.evaluate(() => window.ulabel.set_subtask("ground_truth"));
+        await page.keyboard.press("Control+Shift+z");
+        await page.waitForTimeout(100);
+        expect((await get_annotations(page, "ground_truth"))[1].deprecated).toBe(true);
+        predictions = await get_annotations(page, "predictions");
+        expect(predictions).toHaveLength(2);
+        expect(predictions[1].deprecated).toBe(false);
+    });
+
+    for (const transport of ["native shortcuts", "synthetic ClipboardEvents"]) {
+        test.describe(transport, () => {
+            test.beforeEach(async ({ browserName }) => {
+                test.skip(
+                    transport === "native shortcuts" && process.platform === "linux" && browserName === "webkit",
+                    "Linux WebKit automation emits key events but not native clipboard events; covered separately by synthetic ClipboardEvents.",
+                );
+            });
+
+            test("copying a hovered annotation and pasting into another subtask keeps its position", async ({ page }) => {
+                await wait_for_ulabel_init(page, "/submit-payload.html");
+                const send_clipboard = create_clipboard_driver(page, transport);
+
+                await page.evaluate(() => {
+                    window.ulabel.get_current_subtask().state.edit_candidate = { annid: "gt-bbox-1" };
+                });
+                await send_clipboard("copy");
+                await expect.poll(() => page.evaluate(() => window.ulabel.state.clipboard?.annotation.id)).toBe("gt-bbox-1");
+                if (transport === "synthetic ClipboardEvents") {
+                    await page.evaluate(() => {
+                        window.ulabel.state.clipboard = null;
+                    });
+                }
+
+                await page.evaluate(() => window.ulabel.set_subtask("predictions"));
+                await send_clipboard("paste");
+                await expect.poll(() => get_annotations(page, "predictions")).toHaveLength(2);
+
+                const predictions = await get_annotations(page, "predictions");
+                expect(predictions[1].spatial_payload).toEqual([[100, 100], [300, 250]]);
+                expect(predictions[1].class_id).toBe(10);
+                await expect(page.locator("#id_dialog__predictions")).toBeHidden();
+
+                await send_clipboard("paste");
+                await expect.poll(() => get_annotations(page, "predictions")).toHaveLength(3);
+                expect((await get_annotations(page, "predictions"))[2].spatial_payload).toEqual([[120, 120], [320, 270]]);
+            });
+
+            test("pasting into the source subtask offsets the copy and keeps its class", async ({ page }) => {
+                await wait_for_ulabel_init(page, "/submit-payload.html");
+                const send_clipboard = create_clipboard_driver(page, transport);
+
+                await page.evaluate(() => {
+                    window.ulabel.isolate_annotation("gt-bbox-1");
+                    window.ulabel.get_current_subtask().state.edit_candidate = { annid: "gt-bbox-1" };
+                });
+                await send_clipboard("copy");
+                await send_clipboard("paste");
+                await expect.poll(() => get_annotations(page, "ground_truth")).toHaveLength(3);
+
+                const ground_truth = await get_annotations(page, "ground_truth");
+                expect(ground_truth[2].spatial_payload).toEqual([[120, 120], [320, 270]]);
+                expect(ground_truth[2].class_id).toBe(10);
+                await expect(page.locator("#id_dialog__ground_truth")).toBeHidden();
+                expect(await page.evaluate(() => window.ulabel.get_isolated_annotation_id())).toBeNull();
+
+                await send_clipboard("paste");
+                await expect.poll(() => get_annotations(page, "ground_truth")).toHaveLength(4);
+                expect((await get_annotations(page, "ground_truth"))[3].spatial_payload).toEqual([[140, 140], [340, 290]]);
+            });
+
+            test("cut removes the source and paste restores it elsewhere", async ({ page }) => {
+                await wait_for_ulabel_init(page, "/submit-payload.html");
+                const send_clipboard = create_clipboard_driver(page, transport);
+
+                await page.evaluate(() => {
+                    window.ulabel.get_current_subtask().state.edit_candidate = { annid: "gt-bbox-2" };
+                });
+                await send_clipboard("cut");
+                await expect.poll(async () => (await get_annotations(page, "ground_truth"))[1].deprecated).toBe(true);
+
+                await page.evaluate(() => window.ulabel.set_subtask("predictions"));
+                await send_clipboard("paste");
+                await expect.poll(() => get_annotations(page, "predictions")).toHaveLength(2);
+                const predictions = await get_annotations(page, "predictions");
+                expect(predictions[1].spatial_payload).toEqual([[400, 150], [600, 320]]);
+            });
+
+            test("copy, cut and paste are ignored while typing in a text field", async ({ page }) => {
+                await wait_for_ulabel_init(page, "/submit-payload.html");
+                const send_clipboard = create_clipboard_driver(page, transport);
+
+                await page.evaluate(() => {
+                    window.ulabel.get_current_subtask().state.edit_candidate = { annid: "gt-bbox-1" };
+                    const input = document.createElement("input");
+                    input.id = "scratch-input";
+                    input.value = "annotation note";
+                    document.body.appendChild(input);
+                });
+                await send_clipboard("copy");
+                const clipboard_before = await page.evaluate(() => window.ulabel.state.clipboard);
+                expect(clipboard_before?.annotation.id).toBe("gt-bbox-1");
+                await page.locator("#scratch-input").focus();
+                await page.locator("#scratch-input").selectText();
+                for (const kind of ["copy", "cut", "paste"]) {
+                    await send_clipboard(kind, "#scratch-input", false);
+                    expect(await page.evaluate(() => window.ulabel.state.clipboard)).toEqual(clipboard_before);
+                    const ground_truth = await get_annotations(page, "ground_truth");
+                    expect(ground_truth).toHaveLength(2);
+                    expect(ground_truth[0].deprecated).toBe(false);
+                }
+            });
+        });
+    }
+
+    test("pasting an envelope from a different image size is refused", async ({ page }) => {
+        await wait_for_ulabel_init(page, "/submit-payload.html");
+
+        const result = await page.evaluate(() => {
+            const u = window.ulabel;
+            const envelope = u.copy_annotation_to_clipboard("gt-bbox-1");
+            envelope.image_width += 1;
+            return u.paste_annotation_from_clipboard(envelope);
+        });
+        expect(result).toBeNull();
+        expect(await get_annotations(page, "ground_truth")).toHaveLength(2);
+    });
+});
diff --git a/tests/e2e/deprecated-focus.spec.js b/tests/e2e/deprecated-focus.spec.js
new file mode 100644
index 00000000..44f84ff1
--- /dev/null
+++ b/tests/e2e/deprecated-focus.spec.js
@@ -0,0 +1,90 @@
+// End-to-end tests for deprecated focus: the annotation list's "Show Deprecated" checkbox and Restore
+import { test, expect } from "./fixtures";
+import { wait_for_ulabel_init } from "../testing-utils/init_utils";
+import { get_annotation_list_count } from "../testing-utils/annotation_list_utils";
+
+const LOADED_AT = "2026-01-01T00:00:00.000Z";
+
+test.describe("deprecated focus", () => {
+    test.beforeEach(async ({ page }) => {
+        await wait_for_ulabel_init(page);
+        await page.evaluate(async (loaded_at) => {
+            const u = window.ulabel;
+            const to_image = (x, y) => u.get_image_aware_mouse_x_y({ pageX: x, pageY: y });
+            await u.set_annotations([{
+                id: "loaded",
+                spatial_type: "bbox",
+                spatial_payload: [to_image(400, 150), to_image(500, 250)],
+                classification_payloads: [{ class_id: u.get_current_subtask().class_ids[0], confidence: 1 }],
+                last_edited_at: loaded_at,
+            }], u.get_current_subtask_key(), false, false);
+        }, LOADED_AT);
+    });
+
+    test("a deleted annotation is hoverable but not editable, and Restore brings it back", async ({ page }) => {
+        const loaded = () => page.evaluate(() => {
+            const a = window.ulabel.get_current_subtask().annotations.access.loaded;
+            return { deprecated: a.deprecated, last_edited_at: a.last_edited_at };
+        });
+        await page.mouse.move(450, 200);
+        await page.keyboard.press("d");
+        expect((await loaded()).deprecated).toBe(true);
+        expect(await get_annotation_list_count(page)).toBe(0);
+
+        await page.locator("#annotation-list-show-deprecated").check();
+        expect(await page.evaluate(() => window.ulabel.get_current_subtask().focus_deprecated)).toBe(true);
+        expect(await get_annotation_list_count(page)).toBe(1);
+        await expect(page.locator(".annotation-list-item-deprecated")).toHaveCount(1);
+
+        // Hover shows the card but offers no grab; the delete keybind does nothing
+        await page.mouse.move(700, 500);
+        await page.mouse.move(450, 200);
+        await expect.poll(() => page.evaluate(() => window.ulabel.get_current_subtask().state.hovered_annid)).toBe("loaded");
+        expect(await page.evaluate(() => window.ulabel.get_current_subtask().state.move_candidate)).toBeNull();
+        const stream_length = await page.evaluate(() => window.ulabel.get_current_subtask().actions.stream.length);
+        await page.keyboard.press("d");
+        expect(await page.evaluate(() => window.ulabel.get_current_subtask().actions.stream.length)).toBe(stream_length);
+
+        await page.mouse.click(450, 200, { button: "right" });
+        const items = page.locator(".ulabel-context-menu-item");
+        await expect(items).toHaveText(["Restore", "Isolate", "Details"]);
+        await items.filter({ hasText: "Restore" }).click();
+
+        expect(await loaded()).toEqual({ deprecated: false, last_edited_at: LOADED_AT });
+        // Restored, so out of deprecated focus
+        expect(await get_annotation_list_count(page)).toBe(0);
+
+        await page.locator("#annotation-list-show-deprecated").uncheck();
+        expect(await get_annotation_list_count(page)).toBe(1);
+    });
+
+    test("drawing is blocked and signalled; the banner's Exit leaves the mode", async ({ page }) => {
+        const canvas_fid = await page.evaluate(() => window.ulabel.get_current_subtask().canvas_fid);
+        const banner = page.locator(".deprecated-focus-banner");
+        await expect(banner).toBeHidden();
+
+        await page.locator("#annotation-list-show-deprecated").check();
+        await expect(banner).toBeVisible();
+        await expect(page.locator(`#${canvas_fid}`)).toHaveClass(/edit_locked/);
+
+        const count = () => page.evaluate(() => window.ulabel.get_current_subtask().annotations.ordering.length);
+        const before = await count();
+        await page.mouse.move(200, 400);
+        await page.mouse.down();
+        await page.mouse.move(300, 500);
+        await page.mouse.up();
+        expect(await count()).toBe(before);
+
+        await banner.locator("a.deprecated-focus-exit").click();
+        await expect(banner).toBeHidden();
+        await expect(page.locator(`#${canvas_fid}`)).not.toHaveClass(/edit_locked/);
+        expect(await page.evaluate(() => window.ulabel.get_current_subtask().focus_deprecated)).toBe(false);
+        await expect(page.locator("#annotation-list-show-deprecated")).not.toBeChecked();
+
+        await page.keyboard.press("Shift+D");
+        await expect(banner).toBeVisible();
+        await expect(page.locator("#annotation-list-show-deprecated")).toBeChecked();
+        await page.keyboard.press("Shift+D");
+        await expect(banner).toBeHidden();
+    });
+});
diff --git a/tests/e2e/edit-focus.spec.js b/tests/e2e/edit-focus.spec.js
new file mode 100644
index 00000000..60469c1b
--- /dev/null
+++ b/tests/e2e/edit-focus.spec.js
@@ -0,0 +1,58 @@
+// End-to-end tests for edit focus: the annotation list's "Edited Only" checkbox and its keybind
+import { test, expect } from "./fixtures";
+import { wait_for_ulabel_init } from "../testing-utils/init_utils";
+import { draw_bbox } from "../testing-utils/drawing_utils";
+import { get_annotation_list_count } from "../testing-utils/annotation_list_utils";
+
+test.describe("edit focus", () => {
+    test.beforeEach(async ({ page }) => {
+        await wait_for_ulabel_init(page);
+        await page.evaluate(async () => {
+            const u = window.ulabel;
+            const to_image = (x, y) => u.get_image_aware_mouse_x_y({ pageX: x, pageY: y });
+            await u.set_annotations([{
+                id: "loaded",
+                spatial_type: "bbox",
+                spatial_payload: [to_image(400, 150), to_image(500, 250)],
+                classification_payloads: [{ class_id: u.get_current_subtask().class_ids[0], confidence: 1 }],
+                last_edited_at: "2026-01-01T00:00:00.000Z",
+            }], u.get_current_subtask_key(), false, false);
+        });
+    });
+
+    test("checkbox and keybind filter the list to created and modified annotations", async ({ page }) => {
+        const edited_only = page.locator("#annotation-list-edited-only");
+        await draw_bbox(page, [150, 150], [250, 250]);
+        expect(await get_annotation_list_count(page)).toBe(2);
+        await expect(edited_only).not.toBeChecked();
+
+        await edited_only.check();
+        expect(await get_annotation_list_count(page)).toBe(1);
+        expect(await page.evaluate(() => window.ulabel.get_current_subtask().focus_edited)).toBe(true);
+
+        // Reclassifying the loaded box makes it an edit
+        await page.evaluate(() => {
+            const u = window.ulabel;
+            const ids = u.get_current_subtask().class_ids;
+            u.get_current_subtask().state.id_payload = ids.map((id, i) => ({ class_id: id, confidence: i === 1 ? 1 : 0 }));
+            u.assign_annotation_id("loaded");
+        });
+        expect(await get_annotation_list_count(page)).toBe(2);
+
+        await page.mouse.move(700, 500);
+        await page.keyboard.press("h");
+        await expect(edited_only).not.toBeChecked();
+        expect(await page.evaluate(() => window.ulabel.get_current_subtask().focus_edited)).toBe(false);
+    });
+
+    test("an unchanged annotation can't be hovered while focused", async ({ page }) => {
+        await page.mouse.move(700, 500);
+        await page.keyboard.press("h");
+        await expect(page.locator("#annotation-list-edited-only")).toBeChecked();
+        expect(await get_annotation_list_count(page)).toBe(0);
+
+        await page.mouse.move(450, 200);
+        await page.waitForTimeout(100);
+        expect(await page.evaluate(() => window.ulabel.get_current_subtask().state.hovered_annid)).toBeNull();
+    });
+});
diff --git a/tests/e2e/fly-to-undo.spec.js b/tests/e2e/fly-to-undo.spec.js
new file mode 100644
index 00000000..6c0b6d11
--- /dev/null
+++ b/tests/e2e/fly-to-undo.spec.js
@@ -0,0 +1,60 @@
+// End-to-end tests for fly_to_on_undo: undo/redo centers the view only when nothing it changed is in view
+import { test, expect } from "./fixtures";
+import { wait_for_ulabel_init } from "../testing-utils/init_utils";
+
+test.describe("fly to undo", () => {
+    test.beforeEach(async ({ page }) => {
+        await wait_for_ulabel_init(page);
+    });
+
+    const view = (page) => page.evaluate(() => {
+        const u = window.ulabel;
+        const annbox = document.getElementById(u.config.annbox_id);
+        const scale = u.get_empirical_scale();
+        return {
+            zoom: u.state.zoom_val,
+            cx: (annbox.scrollLeft + annbox.clientWidth / 2) / scale,
+            cy: (annbox.scrollTop + annbox.clientHeight / 2) / scale,
+        };
+    });
+
+    test("undo off screen centers on the change; undo in view leaves the view alone", async ({ page }) => {
+        // A box near the bottom-right corner, then zoom into the top-left corner
+        const box = await page.evaluate(() => {
+            const u = window.ulabel;
+            const w = u.config.image_width;
+            const h = u.config.image_height;
+            const box = [[w * 0.85, h * 0.85], [w * 0.95, h * 0.95]];
+            u.create_annotation("bbox", box, "far");
+            u.set_zoom_val(u.state.zoom_val * 8);
+            u.rezoom(w * 0.05, h * 0.05, true);
+            return box;
+        });
+        const zoomed = await view(page);
+
+        await page.evaluate(() => window.ulabel.undo());
+        const after_undo = await view(page);
+        expect(after_undo.zoom).toBeCloseTo(zoomed.zoom);
+        expect(after_undo.cx).toBeCloseTo((box[0][0] + box[1][0]) / 2, -1);
+        expect(after_undo.cy).toBeCloseTo((box[0][1] + box[1][1]) / 2, -1);
+
+        // The box is now in view: redo does not move the view
+        await page.evaluate(() => window.ulabel.redo());
+        expect(await view(page)).toEqual(after_undo);
+    });
+
+    test("does nothing with fly_to_on_undo off", async ({ page }) => {
+        await page.evaluate(() => {
+            const u = window.ulabel;
+            u.config.fly_to_on_undo = false;
+            const w = u.config.image_width;
+            const h = u.config.image_height;
+            u.create_annotation("bbox", [[w * 0.85, h * 0.85], [w * 0.95, h * 0.95]], "far");
+            u.set_zoom_val(u.state.zoom_val * 8);
+            u.rezoom(w * 0.05, h * 0.05, true);
+        });
+        const zoomed = await view(page);
+        await page.evaluate(() => window.ulabel.undo());
+        expect(await view(page)).toEqual(zoomed);
+    });
+});
diff --git a/tests/e2e/isolate.spec.js b/tests/e2e/isolate.spec.js
new file mode 100644
index 00000000..28b7a2f7
--- /dev/null
+++ b/tests/e2e/isolate.spec.js
@@ -0,0 +1,240 @@
+// End-to-end tests for isolating one annotation from the annotation list.
+import { test, expect } from "./fixtures";
+import { wait_for_ulabel_init } from "../testing-utils/init_utils";
+import { get_annotation_count } from "../testing-utils/annotation_utils";
+import { draw_polygon } from "../testing-utils/drawing_utils";
+
+// 6 x 4 grid of 30px boxes in screen space; each cell's centre is a hover target
+const COLS = 6;
+const ROWS = 4;
+const ORIGIN = [150, 150];
+const STEP = 50;
+const SIZE = 30;
+
+function cell_center(index) {
+    const col = index % COLS;
+    const row = Math.floor(index / COLS);
+    return [ORIGIN[0] + col * STEP + SIZE / 2, ORIGIN[1] + row * STEP + SIZE / 2];
+}
+
+async function load_grid(page) {
+    await page.evaluate(async ({ cols, rows, origin, step, size }) => {
+        const u = window.ulabel;
+        const to_image = (x, y) => u.get_image_aware_mouse_x_y({ pageX: x, pageY: y });
+        const class_ids = u.get_current_subtask().class_ids;
+        const annotations = [];
+        for (let i = 0; i < cols * rows; i++) {
+            const x = origin[0] + (i % cols) * step;
+            const y = origin[1] + Math.floor(i / cols) * step;
+            annotations.push({
+                id: `grid-${i}`,
+                spatial_type: "bbox",
+                spatial_payload: [to_image(x, y), to_image(x + size, y + size)],
+                classification_payloads: [{ class_id: class_ids[i % class_ids.length], confidence: 1 }],
+            });
+        }
+        await u.set_annotations(annotations, u.get_current_subtask_key(), false, false);
+    }, { cols: COLS, rows: ROWS, origin: ORIGIN, step: STEP, size: SIZE });
+    await page.waitForTimeout(100);
+}
+
+// Non-transparent pixels across the subtask's annotation canvases
+async function painted_pixel_count(page) {
+    return await page.evaluate(() => {
+        const contexts = window.ulabel.get_current_subtask().state.annotation_contexts;
+        let count = 0;
+        for (const entry of Object.values(contexts)) {
+            const canvas = entry.context.canvas;
+            const data = entry.context.getImageData(0, 0, canvas.width, canvas.height).data;
+            for (let i = 3; i < data.length; i += 4) {
+                if (data[i] !== 0) count++;
+            }
+        }
+        return count;
+    });
+}
+
+async function isolated_id(page) {
+    return await page.evaluate(() => window.ulabel.get_isolated_annotation_id());
+}
+
+async function hover_and_get_hovered(page, position) {
+    await page.mouse.move(position[0], position[1]);
+    await page.waitForTimeout(100);
+    return await page.evaluate(() => window.ulabel.get_current_subtask().state.hovered_annid);
+}
+
+async function expand_annotation_list(page) {
+    const list = page.locator(".annotation-list-content");
+    if (!(await list.isVisible())) {
+        await page.locator(".annotation-list-header").click();
+    }
+    await expect(list).toBeVisible();
+}
+
+test.describe("isolate annotation", () => {
+    test.beforeEach(async ({ page }) => {
+        await wait_for_ulabel_init(page);
+        await load_grid(page);
+        expect(await get_annotation_count(page)).toBe(COLS * ROWS);
+    });
+
+    test("list button isolates: only that annotation is drawn, hoverable, and listed", async ({ page }) => {
+        await expand_annotation_list(page);
+        const all_painted = await painted_pixel_count(page);
+        await expect(page.locator(".annotation-list-item")).toHaveCount(COLS * ROWS);
+
+        const entry = page.locator(".annotation-list-item[data-annotation-id=\"grid-7\"]");
+        await entry.locator(".annotation-list-item-isolate").click();
+        await page.waitForTimeout(100);
+
+        expect(await isolated_id(page)).toBe("grid-7");
+        // Only one of 24 equal boxes remains painted
+        const isolated_painted = await painted_pixel_count(page);
+        expect(isolated_painted).toBeGreaterThan(0);
+        expect(isolated_painted).toBeLessThan(all_painted / 10);
+        // Data is untouched
+        expect(await get_annotation_count(page)).toBe(COLS * ROWS);
+
+        // The list shows only the isolated entry, with its button active, plus Show all
+        await expect(page.locator(".annotation-list-item")).toHaveCount(1);
+        await expect(page.locator(".annotation-list-item .annotation-list-item-isolate")).toHaveClass(/active/);
+        await expect(page.locator("#annotation-list-show-all")).toBeVisible();
+
+        // Hover: hidden boxes are inert, the isolated one still responds
+        expect(await hover_and_get_hovered(page, cell_center(0))).toBeNull();
+        expect(await hover_and_get_hovered(page, cell_center(7))).toBe("grid-7");
+    });
+
+    test("the isolate button does not fly to the annotation", async ({ page }) => {
+        await expand_annotation_list(page);
+        const zoom_before = await page.evaluate(() => window.ulabel.state.zoom_val);
+
+        await page.locator(".annotation-list-item[data-annotation-id=\"grid-3\"] .annotation-list-item-isolate").click();
+        await page.waitForTimeout(100);
+
+        expect(await page.evaluate(() => window.ulabel.state.zoom_val)).toBe(zoom_before);
+    });
+
+    test("Show all, the active button, and Escape each clear the isolation", async ({ page }) => {
+        await expand_annotation_list(page);
+        const all_painted = await painted_pixel_count(page);
+        const isolate_button = (id) => page.locator(`.annotation-list-item[data-annotation-id="${id}"] .annotation-list-item-isolate`);
+
+        await isolate_button("grid-1").click();
+        await page.locator("#annotation-list-show-all").click();
+        await page.waitForTimeout(100);
+        expect(await isolated_id(page)).toBeNull();
+        await expect(page.locator("#annotation-list-show-all")).toBeHidden();
+        expect(await painted_pixel_count(page)).toBe(all_painted);
+
+        await isolate_button("grid-1").click();
+        await isolate_button("grid-1").click();
+        await page.waitForTimeout(100);
+        expect(await isolated_id(page)).toBeNull();
+
+        await isolate_button("grid-1").click();
+        await page.mouse.move(600, 500);
+        await page.keyboard.press("Escape");
+        await page.waitForTimeout(100);
+        expect(await isolated_id(page)).toBeNull();
+        await expect(page.locator(".annotation-list-item")).toHaveCount(COLS * ROWS);
+    });
+
+    test("deleting the isolated annotation via the context menu clears the isolation", async ({ page }) => {
+        await expand_annotation_list(page);
+        const all_painted = await painted_pixel_count(page);
+        await page.locator(".annotation-list-item[data-annotation-id=\"grid-9\"] .annotation-list-item-isolate").click();
+        await page.waitForTimeout(100);
+
+        const center = cell_center(9);
+        await page.mouse.move(center[0], center[1]);
+        await page.waitForTimeout(100);
+        await page.mouse.click(center[0], center[1], { button: "right" });
+        await page.locator(".ulabel-context-menu-item", { hasText: "Delete" }).click();
+        await page.waitForTimeout(100);
+
+        expect(await isolated_id(page)).toBeNull();
+        const deleted = await page.evaluate(() => window.ulabel.get_current_subtask().annotations.access["grid-9"].deprecated);
+        expect(deleted).toBe(true);
+        await expect(page.locator(".annotation-list-item")).toHaveCount(COLS * ROWS - 1);
+        // The other 23 boxes are back on the canvas
+        expect(await painted_pixel_count(page)).toBeGreaterThan(all_painted / 2);
+    });
+
+    test("switching subtask clears the outgoing isolation", async ({ page }) => {
+        await page.evaluate(() => window.ulabel.isolate_annotation("grid-2"));
+        const key = await page.evaluate(() => window.ulabel.get_current_subtask_key());
+
+        await page.evaluate(() => window.ulabel.set_subtask("frame_review"));
+        await page.waitForTimeout(100);
+
+        expect(await page.evaluate((k) => window.ulabel.get_isolated_annotation_id(k), key)).toBeNull();
+    });
+
+    test("set_annotations clears the isolation", async ({ page }) => {
+        await page.evaluate(() => window.ulabel.isolate_annotation("grid-2"));
+        await load_grid(page);
+
+        expect(await isolated_id(page)).toBeNull();
+    });
+
+    test("undoing the creation of the isolated annotation clears the isolation", async ({ page }) => {
+        const all_painted = await painted_pixel_count(page);
+        // Draw a new box in the empty area below the grid, then isolate it
+        await page.mouse.move(150, 450);
+        await page.mouse.down();
+        await page.mouse.move(200, 500, { steps: 5 });
+        await page.mouse.up();
+        await page.waitForTimeout(100);
+        expect(await get_annotation_count(page)).toBe(COLS * ROWS + 1);
+        const fresh_id = await page.evaluate(() => window.ulabel.get_current_subtask().annotations.ordering.at(-1));
+        await page.evaluate((id) => window.ulabel.isolate_annotation(id), fresh_id);
+        expect(await isolated_id(page)).toBe(fresh_id);
+
+        await page.keyboard.press("Control+z");
+        await page.waitForTimeout(100);
+
+        expect(await get_annotation_count(page)).toBe(COLS * ROWS);
+        expect(await isolated_id(page)).toBeNull();
+        expect(await painted_pixel_count(page)).toBe(all_painted);
+    });
+
+    test("undoing the completion of an isolated polygon clears the isolation", async ({ page }) => {
+        const all_painted = await painted_pixel_count(page);
+        // Close a polygon in the empty area below the grid, then isolate it
+        await draw_polygon(page, [[150, 450], [220, 450], [220, 520], [150, 520]]);
+        expect(await get_annotation_count(page)).toBe(COLS * ROWS + 1);
+        const poly_id = await page.evaluate(() => window.ulabel.get_current_subtask().annotations.ordering.at(-1));
+        await page.evaluate((id) => window.ulabel.isolate_annotation(id), poly_id);
+        expect(await isolated_id(page)).toBe(poly_id);
+
+        await page.keyboard.press("Control+z");
+        await page.waitForTimeout(100);
+
+        // finish_annotation undo deprecates rather than removes
+        expect(await page.evaluate((id) => window.ulabel.get_current_subtask().annotations.access[id].deprecated, poly_id)).toBe(true);
+        expect(await isolated_id(page)).toBeNull();
+        expect(await painted_pixel_count(page)).toBe(all_painted);
+    });
+
+    test("on_isolate_change fires on change only, and the API rejects bad ids", async ({ page }) => {
+        const calls = await page.evaluate(() => {
+            const u = window.ulabel;
+            const calls = [];
+            u.config.on_isolate_change = (subtask_key, annotation_id) => calls.push([subtask_key, annotation_id]);
+            const accepted = [
+                u.isolate_annotation("grid-4"),
+                u.isolate_annotation("grid-4"),
+                u.isolate_annotation("no-such-id"),
+                u.isolate_annotation(null),
+            ];
+            u.config.on_isolate_change = null;
+            return { calls, accepted };
+        });
+        const key = await page.evaluate(() => window.ulabel.get_current_subtask_key());
+
+        expect(calls.accepted).toEqual([true, true, false, true]);
+        expect(calls.calls).toEqual([[key, "grid-4"], [key, null]]);
+    });
+});
diff --git a/tests/e2e/keybind-functionality.spec.js b/tests/e2e/keybind-functionality.spec.js
index b481e073..626ac95d 100644
--- a/tests/e2e/keybind-functionality.spec.js
+++ b/tests/e2e/keybind-functionality.spec.js
@@ -553,9 +553,9 @@ test.describe("Keybind Functionality Tests", () => {
         });
         expect(is_in_progress).toBe(false);
 
-        // Verify annotation is now deprecated
-        const annotation = await get_annotation_by_index(page, 0);
-        expect(annotation.deprecated).toBe(true);
+        // Verify the cancelled drawing was removed, not left deprecated
+        const n_annotations = await page.evaluate(() => window.ulabel.get_current_subtask().annotations.ordering.length);
+        expect(n_annotations).toBe(0);
 
         // Test 2: Exit brush mode
         // Enter brush mode
@@ -804,9 +804,10 @@ test.describe("Keybind Functionality Tests", () => {
         await press_keybind(page, keybind);
         await page.waitForTimeout(200);
 
-        // Verify the polyline is now deprecated (deleted)
+        // Verify the polyline is now deprecated (deleted) with its geometry intact
         annotation = await get_annotation_by_index(page, 0);
         expect(annotation.deprecated).toBe(true);
+        expect(annotation.spatial_payload.length).toBe(2);
     });
 
     test("shift-hover on an existing polygon starts a new complex layer", async ({ page }) => {
diff --git a/tests/e2e/read-only.spec.js b/tests/e2e/read-only.spec.js
index c03d3021..c6daf85d 100644
--- a/tests/e2e/read-only.spec.js
+++ b/tests/e2e/read-only.spec.js
@@ -5,6 +5,7 @@ import { test, expect } from "./fixtures";
 import { wait_for_ulabel_init } from "../testing-utils/init_utils";
 import { get_annotation_count } from "../testing-utils/annotation_utils";
 import { switch_to_subtask } from "../testing-utils/subtask_utils";
+import { switch_to_mode } from "../testing-utils/mode_utils";
 
 test.describe("Read-only subtask behavior", () => {
     test("loads with every subtask marked read_only without erroring", async ({ page }) => {
@@ -23,7 +24,7 @@ test.describe("Read-only subtask behavior", () => {
         expect(flags.fr_ro).toBe(true);
     });
 
-    test("global edit suggestion hides move/reid/delete buttons and skips id dialog thumbnail", async ({ page }) => {
+    test("global edit suggestion renders no action buttons and no id dialog", async ({ page }) => {
         await wait_for_ulabel_init(page, "/read-only.html");
 
         // Trigger the edit suggestion directly for a known bbox annotation
@@ -42,15 +43,11 @@ test.describe("Read-only subtask behavior", () => {
         const container_display = await page.locator(global_id).evaluate((el) => el.style.display);
         expect(container_display).toBe("block");
 
-        // All action buttons inside are visibility:hidden (preserves flow space so the
-        // confidence card's margin-based position math stays valid)
-        const button_visibilities = await page.locator(`${global_id} .global_sub_suggestion`).evaluateAll(
-            (els) => els.map((el) => el.style.visibility),
-        );
-        expect(button_visibilities.length).toBeGreaterThan(0);
-        for (const v of button_visibilities) expect(v).toBe("hidden");
+        // The hover ring is gone: no move/reid/delete anchors anywhere
+        await expect(page.locator(`${global_id} a`)).toHaveCount(0);
+        await expect(page.locator(".movable")).toHaveCount(0);
 
-        // ID dialog thumbnail is not shown
+        // ID dialog is not shown on hover
         const idd_visible = await page.evaluate(() => window.ulabel.get_current_subtask().state.idd_visible);
         expect(idd_visible).toBe(false);
     });
@@ -224,6 +221,71 @@ test.describe("Read-only subtask behavior", () => {
         expect(after).toEqual(before);
     });
 
+    test("shift-hover over a polygon does not start a complex layer", async ({ page }) => {
+        await wait_for_ulabel_init(page, "/read-only.html");
+        await switch_to_mode(page, "polygon");
+
+        // Prime the hover candidate as suggest_edits would, then shift-move the mouse
+        await page.mouse.move(300, 300);
+        await page.evaluate(() => {
+            window.ulabel.get_current_subtask().state.edit_candidate = {
+                annid: "ro-polygon-1",
+                spatial_type: "polygon",
+            };
+        });
+        await page.keyboard.down("Shift");
+        await page.mouse.move(301, 301);
+        await page.waitForTimeout(100);
+        await page.keyboard.up("Shift");
+
+        const after = await page.evaluate(() => {
+            const st = window.ulabel.get_current_subtask();
+            const anno = st.annotations.access["ro-polygon-1"];
+            return {
+                layers: anno.spatial_payload.length,
+                last_edited_at: anno.last_edited_at,
+                starting_complex_polygon: st.state.starting_complex_polygon,
+                is_in_progress: st.state.is_in_progress,
+                active_id: st.state.active_id,
+                act_types: st.actions.stream.map((a) => a.act_type),
+            };
+        });
+        expect(after.layers).toBe(1);
+        expect(after.last_edited_at).toBeNull();
+        expect(after.starting_complex_polygon).toBe(false);
+        expect(after.is_in_progress).toBe(false);
+        expect(after.active_id).toBeNull();
+        expect(after.act_types).not.toContain("start_complex_polygon");
+    });
+
+    test("legacy submit tolerates a nonspatial annotation with a null payload", async ({ page }) => {
+        await wait_for_ulabel_init(page, "/read-only.html");
+
+        // Capture the payload instead of letting the demo hook trigger a download
+        await page.evaluate(() => {
+            const item = window.ulabel.toolbox.items.find((i) => i.get_toolbox_item_type() === "SubmitButtons");
+            item.submit_buttons[0].hook = (payload) => {
+                window.submitted_payload = payload;
+            };
+        });
+        const whole_image_payload = await page.evaluate(
+            () => window.ulabel.subtasks.frame_review.annotations.access["ro-whole-image-1"].spatial_payload,
+        );
+        expect(whole_image_payload).toBeNull();
+
+        await page.locator(".submit-button").first().click();
+        await page.waitForFunction(() => window.submitted_payload !== undefined);
+
+        const result = await page.evaluate(() => ({
+            car_ids: window.submitted_payload.annotations.car_detection.map((a) => a.id),
+            frame_review_ids: window.submitted_payload.annotations.frame_review.map((a) => a.id),
+            button_disabled: document.querySelector(".submit-button").disabled,
+        }));
+        expect(result.car_ids).toContain("ro-polygon-1");
+        expect(result.frame_review_ids).toEqual([]);
+        expect(result.button_disabled).toBe(false);
+    });
+
     test("nonspatial annotation row has no reclassify or delete buttons and a readonly note", async ({ page }) => {
         await wait_for_ulabel_init(page, "/read-only.html");
 
@@ -249,3 +311,117 @@ test.describe("Read-only subtask behavior", () => {
         expect(row_state.delete_exists).toBe(false);
     });
 });
+
+// Runtime toggling via set_subtask_read_only (CVML-287). The demo's banner button
+// toggles the current subtask.
+test.describe("Read-only toggle", () => {
+    // Page points over empty image area near the canvas's top-left corner
+    async function empty_points(page) {
+        const box = await page.evaluate(() => {
+            const r = document.getElementById(window.ulabel.get_current_subtask().canvas_fid).getBoundingClientRect();
+            return { x: r.left, y: r.top };
+        });
+        return [[box.x + 40, box.y + 40], [box.x + 120, box.y + 40], [box.x + 120, box.y + 110], [box.x + 40, box.y + 110]];
+    }
+
+    async function live_ids(page) {
+        return await page.evaluate(() => {
+            const st = window.ulabel.get_current_subtask();
+            return st.annotations.ordering.filter((id) => !st.annotations.access[id].deprecated);
+        });
+    }
+
+    async function drag(page, from, to) {
+        await page.mouse.move(from[0], from[1]);
+        await page.mouse.down();
+        await page.mouse.move((from[0] + to[0]) / 2, (from[1] + to[1]) / 2);
+        await page.mouse.move(to[0], to[1]);
+        await page.mouse.up();
+    }
+
+    test("brush toolbox button and a canvas drag paint nothing while read-only", async ({ page }) => {
+        await wait_for_ulabel_init(page, "/read-only.html");
+        await switch_to_mode(page, "polygon");
+        const before = await live_ids(page);
+
+        await page.click("#brush-mode");
+        const state = await page.evaluate(() => window.ulabel.get_current_subtask().state.is_in_brush_mode);
+        expect(state).toBe(false);
+        await expect(page.locator("#brush_circle")).toHaveCount(0);
+
+        const [a, , c] = await empty_points(page);
+        await drag(page, a, c);
+        expect(await live_ids(page)).toEqual(before);
+    });
+
+    test("read-only, editable, read-only blocks, allows, then blocks again", async ({ page }) => {
+        await wait_for_ulabel_init(page, "/read-only.html");
+        const before = await live_ids(page);
+        const [a, , c] = await empty_points(page);
+
+        await page.click("#toggle-read-only");
+        expect(await page.evaluate(() => window.ulabel.is_current_subtask_read_only())).toBe(false);
+        await switch_to_mode(page, "bbox");
+        await drag(page, a, c);
+        const after_create = await live_ids(page);
+        expect(after_create).toHaveLength(before.length + 1);
+
+        // Brush turns on while editable and off on the way back to read-only
+        await switch_to_mode(page, "polygon");
+        await page.click("#brush-mode");
+        expect(await page.evaluate(() => window.ulabel.get_current_subtask().state.is_in_brush_mode)).toBe(true);
+
+        await page.click("#toggle-read-only");
+        expect(await page.evaluate(() => window.ulabel.get_current_subtask().state.is_in_brush_mode)).toBe(false);
+
+        await switch_to_mode(page, "bbox");
+        await drag(page, a, c);
+        expect(await live_ids(page)).toEqual(after_create);
+
+        // User undo is blocked while read-only and works again once editable
+        await page.keyboard.press("Control+z");
+        expect(await live_ids(page)).toEqual(after_create);
+
+        await page.click("#toggle-read-only");
+        await page.keyboard.press("Control+z");
+        expect(await live_ids(page)).toEqual(before);
+    });
+
+    test("going read-only mid-polygon discards the polygon", async ({ page }) => {
+        await wait_for_ulabel_init(page, "/read-only.html");
+        const before = await live_ids(page);
+        const [a, b, c] = await empty_points(page);
+
+        await page.click("#toggle-read-only");
+        await switch_to_mode(page, "polygon");
+        for (const pt of [a, b, c]) {
+            await page.mouse.click(pt[0], pt[1]);
+        }
+        expect(await page.evaluate(() => window.ulabel.get_current_subtask().state.is_in_progress)).toBe(true);
+
+        await page.click("#toggle-read-only");
+        const state = await page.evaluate(() => {
+            const st = window.ulabel.get_current_subtask();
+            return { read_only: st.read_only, is_in_progress: st.state.is_in_progress, active_id: st.state.active_id };
+        });
+        expect(state).toEqual({ read_only: true, is_in_progress: false, active_id: null });
+        expect(await live_ids(page)).toEqual(before);
+    });
+
+    test("non-spatial rows follow the toggle", async ({ page }) => {
+        await wait_for_ulabel_init(page, "/read-only.html");
+        await switch_to_subtask(page, 1);
+
+        const row = () => page.evaluate(() => ({
+            note_readonly: document.getElementById("note__ro-whole-image-1").hasAttribute("readonly"),
+            reclf: document.getElementById("reclf__ro-whole-image-1") != null,
+            del: document.getElementById("delete__ro-whole-image-1") != null,
+        }));
+
+        await page.click("#toggle-read-only");
+        expect(await row()).toEqual({ note_readonly: false, reclf: true, del: true });
+
+        await page.click("#toggle-read-only");
+        expect(await row()).toEqual({ note_readonly: true, reclf: false, del: false });
+    });
+});
diff --git a/tests/e2e/submit-payload.spec.js b/tests/e2e/submit-payload.spec.js
new file mode 100644
index 00000000..9e769bee
--- /dev/null
+++ b/tests/e2e/submit-payload.spec.js
@@ -0,0 +1,143 @@
+// End-to-end tests for per-button submit payload options against demo/submit-payload.html.
+// That demo has two subtasks and three buttons: "Submit All" (legacy), "Submit GT"
+// (subtasks whitelist), and "Submit Edits" (edits_only). Each hook stores its payload
+// on window.submitted_payloads so we can assert on exactly what the host receives.
+import { test, expect } from "./fixtures";
+import { wait_for_ulabel_init } from "../testing-utils/init_utils";
+
+async function click_submit(page, button_id, payload_key) {
+    await page.locator(`#${button_id}`).click();
+    await page.waitForFunction((key) => window.submitted_payloads[key] !== undefined, payload_key);
+    const payload = await page.evaluate((key) => {
+        const result = window.submitted_payloads[key];
+        delete window.submitted_payloads[key];
+        return result;
+    }, payload_key);
+    return payload;
+}
+
+function ids(payload, subtask_key) {
+    return payload.annotations[subtask_key].map((annotation) => annotation.id);
+}
+
+test.describe("Submit payload options", () => {
+    test("Submit All sends every subtask and every annotation", async ({ page }) => {
+        await wait_for_ulabel_init(page, "/submit-payload.html");
+
+        const payload = await click_submit(page, "submit-all", "all");
+
+        expect(payload.task_meta).toEqual({ job: 7 });
+        expect(Object.keys(payload.annotations)).toEqual(["ground_truth", "predictions"]);
+        expect(ids(payload, "ground_truth")).toEqual(["gt-bbox-1", "gt-bbox-2"]);
+        expect(ids(payload, "predictions")).toEqual(["pred-bbox-1"]);
+    });
+
+    test("Submit GT sends only the whitelisted subtask", async ({ page }) => {
+        await wait_for_ulabel_init(page, "/submit-payload.html");
+
+        const payload = await click_submit(page, "submit-gt", "gt");
+
+        expect(Object.keys(payload.annotations)).toEqual(["ground_truth"]);
+        expect(ids(payload, "ground_truth")).toEqual(["gt-bbox-1", "gt-bbox-2"]);
+    });
+
+    test("Submit Edits is empty before any edit", async ({ page }) => {
+        await wait_for_ulabel_init(page, "/submit-payload.html");
+
+        const payload = await click_submit(page, "submit-edits", "edits");
+
+        expect(Object.keys(payload.annotations)).toEqual(["ground_truth", "predictions"]);
+        expect(ids(payload, "ground_truth")).toEqual([]);
+        expect(ids(payload, "predictions")).toEqual([]);
+    });
+
+    test("Submit Edits tracks create, delete, and reclassify through undo/redo", async ({ page }) => {
+        await wait_for_ulabel_init(page, "/submit-payload.html");
+
+        // Create a new bbox, delete a loaded one, reclassify another loaded one.
+        await page.evaluate(() => {
+            const u = window.ulabel;
+            u.create_annotation("bbox", [[10, 10], [50, 50]], "fresh");
+            u.delete_annotation("gt-bbox-2");
+            u.get_current_subtask().state.id_payload = [{ class_id: 12, confidence: 1.0 }];
+            u.assign_annotation_id("gt-bbox-1");
+        });
+
+        let payload = await click_submit(page, "submit-edits", "edits");
+        expect(ids(payload, "ground_truth").sort()).toEqual(["fresh", "gt-bbox-1", "gt-bbox-2"]);
+        expect(ids(payload, "predictions")).toEqual([]);
+        const by_id = Object.fromEntries(payload.annotations.ground_truth.map((annotation) => [annotation.id, annotation]));
+        expect(by_id["fresh"].edit_type).toBe("created");
+        expect(by_id["gt-bbox-2"].edit_type).toBe("deleted");
+        expect(by_id["gt-bbox-2"].deprecated).toBe(true);
+        expect(by_id["gt-bbox-1"].edit_type).toBe("modified");
+        expect(by_id["gt-bbox-1"].classification_payloads[0].class_id).toBe(12);
+
+        // Undo the reclassify and the delete: only the creation remains an edit.
+        await page.evaluate(() => {
+            window.ulabel.undo();
+            window.ulabel.undo();
+        });
+        payload = await click_submit(page, "submit-edits", "edits");
+        expect(ids(payload, "ground_truth")).toEqual(["fresh"]);
+
+        // Redo the delete: it is an edit again.
+        await page.evaluate(() => window.ulabel.redo());
+        payload = await click_submit(page, "submit-edits", "edits");
+        expect(ids(payload, "ground_truth").sort()).toEqual(["fresh", "gt-bbox-2"]);
+
+        // Submit All is unaffected by edits_only and still includes everything.
+        payload = await click_submit(page, "submit-all", "all");
+        expect(ids(payload, "ground_truth").sort()).toEqual(["fresh", "gt-bbox-1", "gt-bbox-2"]);
+        expect(ids(payload, "predictions")).toEqual(["pred-bbox-1"]);
+        for (const annotation of payload.annotations.ground_truth) {
+            expect(annotation.edit_type).toBeUndefined();
+        }
+    });
+
+    test("Submit Edits reports delete polygon victims, not the eraser itself", async ({ page }) => {
+        await wait_for_ulabel_init(page, "/submit-payload.html");
+
+        await page.evaluate(() => {
+            const u = window.ulabel;
+            // Fully encloses gt-bbox-1 ([100,100]-[300,250]) but not gt-bbox-2.
+            u.create_annotation("delete_polygon", [[50, 50], [350, 50], [350, 300], [50, 300], [50, 50]], "eraser");
+            u.delete_annotations_in_polygon("eraser");
+        });
+
+        let payload = await click_submit(page, "submit-edits", "edits");
+        expect(ids(payload, "ground_truth")).toEqual(["gt-bbox-1"]);
+        expect(payload.annotations.ground_truth[0].deprecated).toBe(true);
+
+        await page.evaluate(() => window.ulabel.undo());
+        payload = await click_submit(page, "submit-edits", "edits");
+        expect(ids(payload, "ground_truth")).toEqual([]);
+    });
+
+    test("set_annotations re-baselines edits_only for the replaced subtask", async ({ page }) => {
+        await wait_for_ulabel_init(page, "/submit-payload.html");
+
+        await page.evaluate(() => window.ulabel.delete_annotation("gt-bbox-2"));
+        let payload = await click_submit(page, "submit-edits", "edits");
+        expect(ids(payload, "ground_truth")).toEqual(["gt-bbox-2"]);
+
+        await page.evaluate(async () => {
+            await window.ulabel.set_annotations([
+                {
+                    id: "gt-bbox-9",
+                    spatial_type: "bbox",
+                    spatial_payload: [[10, 10], [60, 60]],
+                    classification_payloads: [{ class_id: 10, confidence: 1.0 }],
+                    last_edited_at: "2026-02-02T00:00:00.000Z",
+                    last_edited_by: "host",
+                },
+            ], "ground_truth");
+        });
+
+        payload = await click_submit(page, "submit-edits", "edits");
+        expect(ids(payload, "ground_truth")).toEqual([]);
+
+        payload = await click_submit(page, "submit-all", "all");
+        expect(ids(payload, "ground_truth")).toEqual(["gt-bbox-9"]);
+    });
+});
diff --git a/tests/edit_focus.test.js b/tests/edit_focus.test.js
new file mode 100644
index 00000000..2a2d20c8
--- /dev/null
+++ b/tests/edit_focus.test.js
@@ -0,0 +1,153 @@
+// Edit focus: with `focus_edited`, annotations unchanged since load are defocused
+const { ULabel } = require("./testing-utils/build_loader");
+
+const LOADED_AT = "2026-01-01T00:00:00.000Z";
+
+function make_annotation(id, overrides = {}) {
+    return {
+        id,
+        spatial_type: "bbox",
+        spatial_payload: [[10, 10], [30, 30]],
+        containing_box: { tlx: 10, tly: 10, brx: 30, bry: 30 },
+        classification_payloads: [{ class_id: 1, confidence: 1.0 }],
+        deprecated: false,
+        last_edited_at: LOADED_AT,
+        last_edited_by: "host",
+        ...overrides,
+    };
+}
+
+function make_ulabel(resume = [], config_overrides = {}, subtask_overrides = {}) {
+    const ulabel = new ULabel({
+        container_id: "container",
+        image_data: "test.jpg",
+        username: "test_user",
+        image_width: 100,
+        image_height: 100,
+        submit_buttons: [{ name: "Submit", hook: jest.fn() }],
+        subtasks: {
+            gt: {
+                display_name: "GT",
+                classes: [
+                    { name: "Crop", id: 1, color: "green" },
+                    { name: "Weed", id: 2, color: "red" },
+                ],
+                allowed_modes: ["bbox"],
+                resume_from: resume,
+                ...subtask_overrides,
+            },
+        },
+        ...config_overrides,
+    });
+    ulabel.state.current_subtask = "gt";
+    for (const name of [
+        "redraw_annotation",
+        "redraw_all_annotations",
+        "rebuild_containing_box",
+        "update_filter_distance",
+        "suggest_edits",
+        "destroy_polygon_ender",
+        "destroy_annotation_context",
+        "hide_id_dialog",
+        "update_frame",
+        "recolor_active_polygon_ender",
+        "recolor_brush_circle",
+    ]) {
+        ulabel[name] = jest.fn();
+    }
+    ulabel.toolbox = { redraw_update_items: jest.fn() };
+    ulabel.get_init_canvas_context_id = jest.fn(() => "c0");
+    return ulabel;
+}
+
+function defocused(ulabel, id) {
+    return ulabel.is_annotation_defocused(ulabel.subtasks.gt.annotations.access[id], "gt");
+}
+
+function reclassify(ulabel, id) {
+    ulabel.subtasks.gt.state.id_payload = [{ class_id: 1, confidence: 0.0 }, { class_id: 2, confidence: 1.0 }];
+    ulabel.assign_annotation_id(id);
+}
+
+describe("edit focus", () => {
+    test("is off by default and read from the subtask config", () => {
+        expect(make_ulabel().subtasks.gt.focus_edited).toBe(false);
+        expect(make_ulabel([], {}, { focus_edited: true }).subtasks.gt.focus_edited).toBe(true);
+    });
+
+    test("defocuses only annotations unchanged since load", () => {
+        const ulabel = make_ulabel([make_annotation("g1"), make_annotation("g2")], {}, { focus_edited: true });
+        ulabel.create_annotation("bbox", [[0, 0], [10, 10]], "new1");
+        reclassify(ulabel, "g1");
+
+        expect(defocused(ulabel, "new1")).toBe(false);
+        expect(defocused(ulabel, "g1")).toBe(false);
+        expect(defocused(ulabel, "g2")).toBe(true);
+    });
+
+    test("an undone edit drops back out of focus", () => {
+        const ulabel = make_ulabel([make_annotation("g1")], {}, { focus_edited: true });
+        reclassify(ulabel, "g1");
+        expect(defocused(ulabel, "g1")).toBe(false);
+
+        ulabel.undo();
+
+        expect(defocused(ulabel, "g1")).toBe(true);
+    });
+
+    test("composes with class focus", () => {
+        const ulabel = make_ulabel(
+            [make_annotation("g1"), make_annotation("g2")],
+            {},
+            { focus_edited: true, focus_active_class: true },
+        );
+        ulabel.create_annotation("bbox", [[0, 0], [10, 10]], "new1");
+        reclassify(ulabel, "g1");
+
+        // Selected class is still 1: g1 is edited but now class 2
+        expect(defocused(ulabel, "new1")).toBe(false);
+        expect(defocused(ulabel, "g1")).toBe(true);
+        expect(defocused(ulabel, "g2")).toBe(true);
+    });
+
+    test("set_focus_edited toggles, drops hover, redraws, and reports only changes", () => {
+        const on_focus_edited_change = jest.fn();
+        const ulabel = make_ulabel([make_annotation("g1")], { on_focus_edited_change });
+        ulabel.subtasks.gt.state.hovered_annid = "g1";
+        expect(defocused(ulabel, "g1")).toBe(false);
+
+        ulabel.set_focus_edited("gt", true);
+
+        expect(defocused(ulabel, "g1")).toBe(true);
+        expect(ulabel.subtasks.gt.state.hovered_annid).toBeNull();
+        expect(ulabel.redraw_all_annotations).toHaveBeenCalledWith("gt");
+        expect(ulabel.toolbox.redraw_update_items).toHaveBeenCalled();
+        expect(on_focus_edited_change).toHaveBeenCalledWith("gt", true);
+
+        ulabel.set_focus_edited("gt", true, false);
+        expect(on_focus_edited_change).toHaveBeenCalledTimes(1);
+    });
+
+    test("ignores an unknown subtask key", () => {
+        const ulabel = make_ulabel();
+
+        expect(() => ulabel.set_focus_edited("nope", true, false)).not.toThrow();
+        expect(ulabel.subtasks.gt.focus_edited).toBe(false);
+    });
+
+    test("an annotation edited into focus is redrawn after it is stamped", () => {
+        const ulabel = make_ulabel([make_annotation("g1")], {}, { focus_edited: true });
+        const defocused_at_redraw = [];
+        ulabel.redraw_annotation = jest.fn((id) => defocused_at_redraw.push(defocused(ulabel, id)));
+
+        reclassify(ulabel, "g1");
+
+        expect(defocused_at_redraw.at(-1)).toBe(false);
+    });
+
+    test("navigation skips unchanged annotations", () => {
+        const ulabel = make_ulabel([make_annotation("g1")], {}, { focus_edited: true });
+
+        expect(ulabel.fly_to_annotation_id("g1", "gt")).toBe(false);
+    });
+});
diff --git a/tests/edit_timestamps.test.js b/tests/edit_timestamps.test.js
new file mode 100644
index 00000000..daeb8ad8
--- /dev/null
+++ b/tests/edit_timestamps.test.js
@@ -0,0 +1,209 @@
+// Every human edit must stamp `last_edited_at`/`last_edited_by` on each annotation
+// it touches, and undo must restore the previous stamp. These cover the paths that
+// edit annotations other than the one the action is named after, plus text notes.
+const { ULabel } = require("./testing-utils/build_loader");
+
+let next_id = 0;
+
+function make_annotation(overrides = {}) {
+    return {
+        id: `anno_${next_id++}`,
+        spatial_type: "bbox",
+        spatial_payload: [[0, 0], [10, 10]],
+        containing_box: { tlx: 0, tly: 0, brx: 10, bry: 10 },
+        classification_payloads: [{ class_id: 1, confidence: 1.0 }],
+        deprecated: false,
+        last_edited_at: "loaded",
+        last_edited_by: "host",
+        ...overrides,
+    };
+}
+
+const mock_config = {
+    container_id: "container",
+    image_data: "test.jpg",
+    username: "test_user",
+    image_width: 8,
+    image_height: 8,
+    submit_buttons: [{ name: "Submit", hook: jest.fn() }],
+    subtasks: {
+        st: {
+            display_name: "A",
+            classes: [{ name: "Crop", id: 1, color: "green" }],
+            allowed_modes: ["bbox", "point", "polygon", "delete_polygon", "bitmask", "whole-image"],
+            resume_from: null,
+        },
+        other: {
+            display_name: "B",
+            classes: [{ name: "Crop", id: 1, color: "green" }],
+            allowed_modes: ["bitmask"],
+            resume_from: null,
+        },
+    },
+};
+
+function load(ulabel, annotations, subtask_key = "st") {
+    const access = {};
+    const ordering = [];
+    for (const annotation of annotations) {
+        access[annotation.id] = annotation;
+        ordering.push(annotation.id);
+    }
+    ulabel.subtasks[subtask_key].annotations = { access, ordering };
+}
+
+function make_ulabel() {
+    const ulabel = new ULabel(mock_config);
+    ulabel.state.current_subtask = "st";
+    // Rendering/bookkeeping tail is not under test
+    for (const name of [
+        "redraw_annotation",
+        "redraw_all_annotations",
+        "redraw_multiple_spatial_annotations",
+        "rebuild_containing_box",
+        "update_filter_distance",
+        "suggest_edits",
+        "destroy_polygon_ender",
+        "destroy_annotation_context",
+        "remove_recorded_events_for_annotation",
+        "hide_id_dialog",
+        "update_frame",
+    ]) {
+        ulabel[name] = jest.fn();
+    }
+    ulabel.toolbox = { redraw_update_items: jest.fn() };
+    return ulabel;
+}
+
+function expect_stamped(annotation) {
+    expect(annotation.last_edited_at).not.toBe("loaded");
+    expect(annotation.last_edited_at).toEqual(expect.any(String));
+    expect(annotation.last_edited_by).toBe("test_user");
+}
+
+function expect_restored(annotation) {
+    expect(annotation.last_edited_at).toBe("loaded");
+    expect(annotation.last_edited_by).toBe("host");
+}
+
+describe("bitmask overwrite victims", () => {
+    function make_mask(id, subtask_key) {
+        return make_annotation({ id, spatial_type: "bitmask", spatial_payload: null, containing_box: null, subtask_key });
+    }
+
+    test("are stamped on redo and restored on undo, in their own subtask", () => {
+        const ulabel = make_ulabel();
+        const mask = make_mask("mask", "st");
+        const sibling = make_mask("sibling", "st");
+        const victim = make_mask("victim", "other");
+        load(ulabel, [mask, sibling]);
+        load(ulabel, [victim], "other");
+        const edit = (annotation_id, subtask) => ({ annotation_id, subtask, before_rle: null, after_rle: null, after_empty: false });
+
+        ulabel.bitmask_stroke__redo("mask", {
+            before_rle: null,
+            after_rle: null,
+            was_new: false,
+            after_empty: false,
+            other_edits: [edit("sibling", "st"), edit("victim", "other")],
+        });
+
+        expect_stamped(mask);
+        expect_stamped(sibling);
+        expect_stamped(victim);
+        const action = ulabel.subtasks.st.actions.stream.at(-1);
+        expect(action.affected).toEqual([
+            { annotation_id: "sibling", subtask_key: "st" },
+            { annotation_id: "victim", subtask_key: "other" },
+        ]);
+        expect(action.affected_prev).toEqual([
+            { prev_timestamp: "loaded", prev_user: "host" },
+            { prev_timestamp: "loaded", prev_user: "host" },
+        ]);
+
+        ulabel.undo();
+
+        expect_restored(mask);
+        expect_restored(sibling);
+        expect_restored(victim);
+    });
+});
+
+describe("delete polygon victims", () => {
+    function make_scene(ulabel) {
+        const hit = make_annotation({ id: "hit", spatial_type: "point", spatial_payload: [[5, 5]] });
+        const missed = make_annotation({ id: "missed", spatial_type: "point", spatial_payload: [[50, 50]] });
+        const eraser = {
+            id: "del0",
+            spatial_type: "delete_polygon",
+            spatial_payload: [[-1, -1], [20, -1], [20, 20], [-1, 20], [-1, -1]],
+            classification_payloads: [{ class_id: -1, confidence: 1.0 }],
+            deprecated: false,
+        };
+        load(ulabel, [hit, missed, eraser]);
+        return { hit, missed };
+    }
+
+    test("are stamped, restored on undo, and stamped again on redo", () => {
+        const ulabel = make_ulabel();
+        const { hit, missed } = make_scene(ulabel);
+
+        ulabel.delete_annotations_in_polygon("del0");
+
+        expect(hit.deprecated).toBe(true);
+        expect_stamped(hit);
+        expect_restored(missed);
+        // The delete polygon itself is gone; the victims carry the edit
+        expect(ulabel.subtasks.st.annotations.access.del0).toBeUndefined();
+
+        ulabel.undo();
+
+        expect(hit.deprecated).toBe(false);
+        expect_restored(hit);
+
+        ulabel.redo();
+
+        expect(hit.deprecated).toBe(true);
+        expect_stamped(hit);
+        expect_restored(missed);
+    });
+});
+
+describe("edit_text_payload", () => {
+    function make_note_ulabel() {
+        const ulabel = make_ulabel();
+        const note = make_annotation({ id: "note", spatial_type: "whole-image", spatial_payload: null, text_payload: "before" });
+        load(ulabel, [note]);
+        return { ulabel, note };
+    }
+
+    test("records an undoable, stamped action", () => {
+        const { ulabel, note } = make_note_ulabel();
+
+        ulabel.edit_text_payload("note", "after");
+
+        expect(note.text_payload).toBe("after");
+        expect_stamped(note);
+        expect(ulabel.subtasks.st.actions.stream.at(-1).act_type).toBe("edit_text_payload");
+        expect(ulabel.redraw_annotation).toHaveBeenCalledWith("note");
+
+        ulabel.undo();
+
+        expect(note.text_payload).toBe("before");
+        expect_restored(note);
+
+        ulabel.redo();
+
+        expect(note.text_payload).toBe("after");
+        expect_stamped(note);
+    });
+
+    test("ignores a change to the same text", () => {
+        const { ulabel, note } = make_note_ulabel();
+
+        ulabel.edit_text_payload("note", "before");
+
+        expect(ulabel.subtasks.st.actions.stream).toHaveLength(0);
+        expect_restored(note);
+    });
+});
diff --git a/tests/isolate.test.js b/tests/isolate.test.js
new file mode 100644
index 00000000..4f5a6b2f
--- /dev/null
+++ b/tests/isolate.test.js
@@ -0,0 +1,428 @@
+// Unit tests for isolating one annotation: every other annotation in the
+// subtask is hidden from the canvas and from input until the isolation
+// clears. View-only state, so nothing is recorded and the data is untouched.
+const { ULabel } = require("./testing-utils/build_loader");
+
+let next_id = 0;
+
+function make_annotation(class_id = 1) {
+    return {
+        id: `anno_${next_id++}`,
+        spatial_type: "bbox",
+        spatial_payload: [[0, 0], [10, 10]],
+        containing_box: { tlx: 0, tly: 0, brx: 10, bry: 10 },
+        classification_payloads: [{ class_id, confidence: 1.0 }],
+        deprecated: false,
+    };
+}
+
+const mock_config = {
+    container_id: "container",
+    image_data: "test.jpg",
+    username: "test_user",
+    submit_buttons: [{ name: "Submit", hook: jest.fn() }],
+    subtasks: {
+        st: {
+            display_name: "A",
+            classes: [
+                { name: "Crop", id: 1, color: "green" },
+                { name: "Weed", id: 2, color: "red" },
+            ],
+            allowed_modes: ["bbox"],
+            resume_from: null,
+        },
+    },
+};
+
+function load(ulabel, annotations, subtask_key = "st") {
+    const access = {};
+    const ordering = [];
+    for (const annotation of annotations) {
+        access[annotation.id] = annotation;
+        ordering.push(annotation.id);
+    }
+    ulabel.subtasks[subtask_key].annotations = { access, ordering };
+}
+
+function make_ulabel(config = mock_config) {
+    const ulabel = new ULabel(config);
+    ulabel.state.current_subtask = "st";
+    ulabel.redraw_all_annotations = jest.fn();
+    ulabel.toolbox = { redraw_update_items: jest.fn() };
+    return ulabel;
+}
+
+describe("isolate_annotation", () => {
+    test("starts with nothing isolated", () => {
+        const ulabel = make_ulabel();
+
+        expect(ulabel.subtasks.st.state.isolated_annid).toBeNull();
+        expect(ulabel.get_isolated_annotation_id("st")).toBeNull();
+    });
+
+    test("writes the state and reports it", () => {
+        const ulabel = make_ulabel();
+        const a = make_annotation();
+        load(ulabel, [a, make_annotation()]);
+
+        expect(ulabel.isolate_annotation(a.id)).toBe(true);
+
+        expect(ulabel.subtasks.st.state.isolated_annid).toBe(a.id);
+        expect(ulabel.get_isolated_annotation_id()).toBe(a.id);
+    });
+
+    test("rejects unknown and deprecated ids without touching state", () => {
+        const ulabel = make_ulabel();
+        const gone = { ...make_annotation(), deprecated: true };
+        load(ulabel, [gone]);
+
+        expect(ulabel.isolate_annotation("nope")).toBe(false);
+        expect(ulabel.isolate_annotation(gone.id)).toBe(false);
+        expect(ulabel.isolate_annotation("x", "no_such_subtask")).toBe(false);
+
+        expect(ulabel.subtasks.st.state.isolated_annid).toBeNull();
+    });
+
+    test("drops hover, candidates, and fly-to position", () => {
+        const ulabel = make_ulabel();
+        const a = make_annotation();
+        const b = make_annotation();
+        load(ulabel, [a, b]);
+        const state = ulabel.subtasks.st.state;
+        state.hovered_annid = b.id;
+        state.edit_candidate = { annid: b.id };
+        state.move_candidate = { annid: b.id };
+        state.fly_to_idx = 1;
+
+        ulabel.isolate_annotation(a.id);
+
+        expect(state.hovered_annid).toBeNull();
+        expect(state.edit_candidate).toBeNull();
+        expect(state.move_candidate).toBeNull();
+        expect(state.fly_to_idx).toBeNull();
+    });
+
+    test("redraws the subtask and the toolbox unless told not to", () => {
+        const ulabel = make_ulabel();
+        const a = make_annotation();
+        load(ulabel, [a]);
+
+        ulabel.isolate_annotation(a.id);
+        expect(ulabel.redraw_all_annotations).toHaveBeenCalledWith("st");
+        expect(ulabel.toolbox.redraw_update_items).toHaveBeenCalledTimes(1);
+
+        ulabel.isolate_annotation(null, "st", false);
+        expect(ulabel.redraw_all_annotations).toHaveBeenCalledTimes(1);
+    });
+
+    test("is view-only: no action recorded, edited flag untouched", () => {
+        const ulabel = make_ulabel();
+        const a = make_annotation();
+        load(ulabel, [a]);
+        ulabel.state.edited = false;
+
+        ulabel.isolate_annotation(a.id);
+        ulabel.isolate_annotation(null);
+
+        expect(ulabel.subtasks.st.actions.stream).toEqual([]);
+        expect(ulabel.state.edited).toBe(false);
+    });
+
+    test("does not change get_annotations()", () => {
+        const ulabel = make_ulabel();
+        const a = make_annotation();
+        load(ulabel, [a, make_annotation(), make_annotation()]);
+
+        ulabel.isolate_annotation(a.id);
+
+        expect(ulabel.get_annotations("st").length).toBe(3);
+    });
+});
+
+describe("on_isolate_change", () => {
+    test("fires only on an actual change, with the new id or null", () => {
+        const on_isolate_change = jest.fn();
+        const ulabel = make_ulabel({ ...mock_config, on_isolate_change });
+        const a = make_annotation();
+        load(ulabel, [a]);
+
+        ulabel.isolate_annotation(a.id);
+        ulabel.isolate_annotation(a.id);
+        ulabel.isolate_annotation("nope");
+        ulabel.isolate_annotation(null);
+        ulabel.isolate_annotation(null);
+
+        expect(on_isolate_change.mock.calls).toEqual([["st", a.id], ["st", null]]);
+    });
+});
+
+describe("gates", () => {
+    test("is_annotation_defocused is true for everything but the isolated one", () => {
+        const ulabel = make_ulabel();
+        const a = make_annotation();
+        const b = make_annotation();
+        load(ulabel, [a, b]);
+
+        ulabel.isolate_annotation(a.id);
+
+        expect(ulabel.is_annotation_defocused(a, "st")).toBe(false);
+        expect(ulabel.is_annotation_defocused(b, "st")).toBe(true);
+    });
+
+    test("draw_annotation skips isolated-out annotations even inside the defocus pass", () => {
+        const ulabel = make_ulabel();
+        const a = make_annotation();
+        const b = make_annotation();
+        load(ulabel, [a, b]);
+        ulabel.draw_bounding_box = jest.fn();
+        ulabel.subtasks.st.state.annotation_contexts = {
+            c0: { context: {}, annotation_ids: [a.id, b.id] },
+        };
+        a.canvas_id = "c0";
+        b.canvas_id = "c0";
+        ulabel.isolate_annotation(a.id);
+
+        ulabel.draw_annotation(b, null, "st");
+        ulabel.state.drawing_defocused = true;
+        ulabel.draw_annotation(b, null, "st");
+        ulabel.state.drawing_defocused = false;
+        expect(ulabel.draw_bounding_box).not.toHaveBeenCalled();
+
+        ulabel.draw_annotation(a, null, "st");
+        expect(ulabel.draw_bounding_box).toHaveBeenCalledTimes(1);
+    });
+
+    test("draw passes never send isolated-out annotations to the dimming layer", () => {
+        const ulabel = make_ulabel({
+            ...mock_config,
+            subtasks: { ...mock_config.subtasks, st: { ...mock_config.subtasks.st, focus_active_class: true } },
+        });
+        const crop = make_annotation(1);
+        const weed = make_annotation(2);
+        load(ulabel, [weed, crop]);
+        const live = { globalAlpha: 1, drawImage: jest.fn(), canvas: { width: 10, height: 10 } };
+        ulabel.subtasks.st.state.annotation_contexts = {
+            c0: { context: live, annotation_ids: [weed.id, crop.id] },
+        };
+        ulabel.state.defocus_scratch = { clearRect: jest.fn(), canvas: { width: 10, height: 10 } };
+        ulabel.isolate_annotation(crop.id);
+        const drawn = [];
+
+        ulabel.draw_context_in_focus_passes("c0", "st", (id) => drawn.push(id));
+
+        expect(drawn).toEqual([crop.id]);
+        expect(live.drawImage).not.toHaveBeenCalled();
+    });
+
+    test("isolated annotation in a defocused class draws nothing", () => {
+        const ulabel = make_ulabel({
+            ...mock_config,
+            subtasks: { ...mock_config.subtasks, st: { ...mock_config.subtasks.st, focus_active_class: true } },
+        });
+        const weed = make_annotation(2);
+        load(ulabel, [weed]);
+        ulabel.draw_bounding_box = jest.fn();
+        ulabel.subtasks.st.state.annotation_contexts = { c0: { context: {}, annotation_ids: [weed.id] } };
+        weed.canvas_id = "c0";
+        ulabel.isolate_annotation(weed.id);
+
+        // Selected class is Crop (1); Weed stays defocused and out of the live pass
+        ulabel.draw_annotation(weed, null, "st");
+
+        expect(ulabel.draw_bounding_box).not.toHaveBeenCalled();
+    });
+
+    test("fly_to_annotation refuses an isolated-out annotation", () => {
+        const ulabel = make_ulabel();
+        const a = make_annotation();
+        const b = make_annotation();
+        load(ulabel, [a, b]);
+        ulabel.isolate_annotation(a.id);
+
+        expect(ulabel.fly_to_annotation(b, "st", 1)).toBe(false);
+    });
+});
+
+describe("clears", () => {
+    test("deleting the isolated annotation clears the isolation with a full redraw", () => {
+        const ulabel = make_ulabel();
+        const a = make_annotation();
+        load(ulabel, [a, make_annotation()]);
+        ulabel.redraw_annotation = jest.fn();
+        ulabel.suggest_edits = jest.fn();
+        ulabel.destroy_polygon_ender = jest.fn();
+        ulabel.isolate_annotation(a.id);
+        ulabel.redraw_all_annotations.mockClear();
+
+        ulabel.delete_annotation(a.id);
+
+        expect(ulabel.subtasks.st.state.isolated_annid).toBeNull();
+        expect(ulabel.redraw_all_annotations).toHaveBeenCalledWith("st");
+        expect(a.deprecated).toBe(true);
+    });
+
+    test("deleting another annotation leaves the isolation alone", () => {
+        const ulabel = make_ulabel();
+        const a = make_annotation();
+        const b = make_annotation();
+        load(ulabel, [a, b]);
+        ulabel.redraw_annotation = jest.fn();
+        ulabel.suggest_edits = jest.fn();
+        ulabel.destroy_polygon_ender = jest.fn();
+        ulabel.isolate_annotation(a.id);
+
+        ulabel.delete_annotation(b.id);
+
+        expect(ulabel.subtasks.st.state.isolated_annid).toBe(a.id);
+    });
+
+    // set_subtask and set_annotations need the full DOM/canvas init; the e2e
+    // spec covers those clear paths.
+
+    test("creating a new annotation clears the isolation so it is visible", () => {
+        const ulabel = make_ulabel();
+        const a = make_annotation();
+        load(ulabel, [a]);
+        ulabel.isolate_annotation(a.id);
+        ulabel.redraw_annotation = jest.fn();
+        ulabel.rebuild_containing_box = jest.fn();
+        ulabel.update_filter_distance = jest.fn();
+        ulabel.suggest_edits = jest.fn();
+        ulabel.destroy_polygon_ender = jest.fn();
+        ulabel.get_init_canvas_context_id = jest.fn(() => "c0");
+        ulabel.subtasks.st.state.annotation_contexts = { c0: { context: {}, annotation_ids: [] } };
+
+        ulabel.create_annotation("bbox", [[0, 0], [5, 5]]);
+
+        expect(ulabel.subtasks.st.state.isolated_annid).toBeNull();
+    });
+
+    test("undoing the creation of the isolated annotation clears the isolation", () => {
+        const on_isolate_change = jest.fn();
+        const ulabel = make_ulabel({ ...mock_config, on_isolate_change });
+        const base = make_annotation();
+        load(ulabel, [base]);
+        ulabel.redraw_annotation = jest.fn();
+        ulabel.rebuild_containing_box = jest.fn();
+        ulabel.update_filter_distance = jest.fn();
+        ulabel.suggest_edits = jest.fn();
+        ulabel.destroy_polygon_ender = jest.fn();
+        ulabel.destroy_annotation_context = jest.fn();
+        ulabel.hide_id_dialog = jest.fn();
+        ulabel.get_init_canvas_context_id = jest.fn(() => "c0");
+        ulabel.subtasks.st.state.annotation_contexts = { c0: { context: {}, annotation_ids: [] } };
+        ulabel.create_annotation("bbox", [[0, 0], [5, 5]], "fresh");
+        ulabel.isolate_annotation("fresh");
+        ulabel.redraw_all_annotations.mockClear();
+
+        ulabel.undo();
+
+        expect(ulabel.subtasks.st.annotations.access.fresh).toBeUndefined();
+        expect(ulabel.subtasks.st.state.isolated_annid).toBeNull();
+        expect(ulabel.is_annotation_defocused(base, "st")).toBe(false);
+        expect(ulabel.redraw_all_annotations).toHaveBeenCalledWith("st");
+        expect(on_isolate_change).toHaveBeenLastCalledWith("st", null);
+    });
+
+    test("undoing finish_annotation on the isolated polygon clears the isolation", () => {
+        const on_isolate_change = jest.fn();
+        const ulabel = make_ulabel({ ...mock_config, on_isolate_change });
+        const base = make_annotation();
+        const poly = { ...make_annotation(), id: "poly", spatial_type: "polygon", spatial_payload: [[[0, 0], [5, 0], [5, 5], [0, 0]]] };
+        load(ulabel, [base, poly]);
+        ulabel.isolate_annotation("poly");
+        ulabel.redraw_all_annotations.mockClear();
+
+        ulabel.finish_annotation__undo("poly");
+
+        expect(poly.deprecated).toBe(true);
+        expect(ulabel.subtasks.st.state.isolated_annid).toBeNull();
+        expect(ulabel.is_annotation_defocused(base, "st")).toBe(false);
+        expect(ulabel.redraw_all_annotations).toHaveBeenCalledWith("st");
+        expect(on_isolate_change).toHaveBeenLastCalledWith("st", null);
+    });
+});
+
+describe("isolation follows bitmask deprecation", () => {
+    function make_mask(id) {
+        return { ...make_annotation(), id, spatial_type: "bitmask", spatial_payload: null, containing_box: null };
+    }
+
+    function make_bitmask_ulabel() {
+        const on_isolate_change = jest.fn();
+        const ulabel = make_ulabel({ ...mock_config, on_isolate_change });
+        ulabel.config.image_width = 8;
+        ulabel.config.image_height = 8;
+        ulabel.redraw_annotation = jest.fn();
+        const base = make_annotation();
+        const mask = make_mask("mask");
+        load(ulabel, [base, mask]);
+        return { ulabel, base, mask, on_isolate_change };
+    }
+
+    function expect_cleared({ ulabel, base, on_isolate_change }, subtask_key = "st") {
+        expect(ulabel.subtasks[subtask_key].state.isolated_annid).toBeNull();
+        expect(ulabel.is_annotation_defocused(base, subtask_key)).toBe(false);
+        expect(ulabel.redraw_all_annotations).toHaveBeenCalledWith(subtask_key);
+        expect(on_isolate_change).toHaveBeenLastCalledWith(subtask_key, null);
+    }
+
+    test("undoing the first stroke of the isolated mask clears the isolation", () => {
+        const fixture = make_bitmask_ulabel();
+        const { ulabel, mask } = fixture;
+        ulabel.isolate_annotation("mask");
+        ulabel.redraw_all_annotations.mockClear();
+
+        ulabel.bitmask_stroke__undo("mask", { was_new: true, before_rle: null, other_edits: [] });
+
+        expect(mask.deprecated).toBe(true);
+        expect_cleared(fixture);
+    });
+
+    test("redoing a stroke that erased the isolated mask clears the isolation", () => {
+        const fixture = make_bitmask_ulabel();
+        const { ulabel, mask } = fixture;
+        ulabel.isolate_annotation("mask");
+        ulabel.redraw_all_annotations.mockClear();
+
+        ulabel.bitmask_stroke__redo("mask", { after_rle: null, after_empty: true, other_edits: [] });
+
+        expect(mask.deprecated).toBe(true);
+        expect_cleared(fixture);
+    });
+
+    test("finishing a stroke that erases the whole isolated mask clears the isolation", () => {
+        const fixture = make_bitmask_ulabel();
+        const { ulabel, mask } = fixture;
+        ulabel.isolate_annotation("mask");
+        ulabel.redraw_all_annotations.mockClear();
+        ulabel.subtasks.st.state.active_id = "mask";
+        ulabel.subtasks.st.state.bitmask_stroke = { is_erase: true, was_new: false, before_rle: null };
+
+        ulabel.finish_bitmask();
+
+        expect(mask.deprecated).toBe(true);
+        expect_cleared(fixture);
+    });
+
+    test("redoing an overwrite that empties an isolated mask in another subtask clears that subtask's isolation", () => {
+        const fixture = make_bitmask_ulabel();
+        const { ulabel } = fixture;
+        ulabel.subtasks.other = { ...ulabel.subtasks.st, state: { ...ulabel.subtasks.st.state }, read_only: false };
+        const other_base = make_annotation();
+        const victim = make_mask("victim");
+        load(ulabel, [other_base, victim], "other");
+        ulabel.isolate_annotation("victim", "other");
+        ulabel.redraw_all_annotations.mockClear();
+
+        ulabel.bitmask_stroke__redo("mask", {
+            after_rle: null,
+            after_empty: false,
+            other_edits: [{ annotation_id: "victim", subtask: "other", after_rle: null, after_empty: true }],
+        });
+
+        expect(victim.deprecated).toBe(true);
+        expect_cleared({ ...fixture, base: other_base }, "other");
+        expect(ulabel.subtasks.st.state.isolated_annid).toBeNull();
+    });
+});
diff --git a/tests/on_annotation_change.test.js b/tests/on_annotation_change.test.js
new file mode 100644
index 00000000..082cbaa2
--- /dev/null
+++ b/tests/on_annotation_change.test.js
@@ -0,0 +1,405 @@
+// Unit tests for the `on_annotation_change` host callback (CVML-286): one call
+// per recorded / undone / redone action that changes committed annotation state.
+const { ULabel } = require("./testing-utils/build_loader");
+
+const classes = [
+    { name: "Crop", id: 1, color: "green" },
+    { name: "Weed", id: 2, color: "red" },
+];
+
+function make_bbox(id, class_id = 1) {
+    return {
+        id,
+        spatial_type: "bbox",
+        spatial_payload: [[10, 10], [30, 30]],
+        containing_box: { tlx: 10, tly: 10, brx: 30, bry: 30 },
+        classification_payloads: [{ class_id, confidence: 1.0 }],
+        deprecated: false,
+        last_edited_at: "2026-01-01T00:00:00.000Z",
+        last_edited_by: "host",
+    };
+}
+
+function make_ulabel(resume = {}, config_overrides = {}) {
+    const ulabel = new ULabel({
+        container_id: "container",
+        image_data: "test.jpg",
+        username: "test_user",
+        image_width: 100,
+        image_height: 100,
+        allow_annotations_outside_image: true,
+        submit_buttons: [{ name: "Submit", hook: jest.fn() }],
+        subtasks: {
+            gt: { display_name: "GT", classes, allowed_modes: ["bbox", "bitmask"], resume_from: resume.gt ?? null },
+            pred: { display_name: "Pred", classes, allowed_modes: ["bbox", "bitmask"], resume_from: resume.pred ?? null },
+        },
+        ...config_overrides,
+    });
+    ulabel.state.current_subtask = "gt";
+    for (const name of [
+        "redraw_annotation",
+        "redraw_all_annotations",
+        "redraw_all_annotations_in_annotation_context",
+        "rebuild_containing_box",
+        "update_filter_distance",
+        "update_filter_distance_during_polyline_move",
+        "suggest_edits",
+        "show_edit_suggestion",
+        "destroy_polygon_ender",
+        "destroy_annotation_context",
+        "hide_id_dialog",
+        "show_id_dialog",
+        "update_frame",
+    ]) {
+        ulabel[name] = jest.fn();
+    }
+    ulabel.toolbox = { redraw_update_items: jest.fn() };
+    ulabel.get_init_canvas_context_id = jest.fn(() => "c0");
+    return ulabel;
+}
+
+// Collapse a call into the fields most tests care about
+function brief(call) {
+    const { subtask_key, annotation_id, act_type, kind } = call[0];
+    return { subtask_key, annotation_id, act_type, kind };
+}
+
+function make_ulabel_with_callback(resume = {}, config_overrides = {}) {
+    const on_annotation_change = jest.fn();
+    const ulabel = make_ulabel(resume, { on_annotation_change, ...config_overrides });
+    return { ulabel, on_annotation_change };
+}
+
+describe("create / delete round trip", () => {
+    test("create fires do, undo fires undo, redo fires redo", () => {
+        const { ulabel, on_annotation_change } = make_ulabel_with_callback();
+
+        ulabel.create_annotation("bbox", [[0, 0], [10, 10]], "a1");
+        ulabel.undo();
+        ulabel.redo();
+
+        expect(on_annotation_change.mock.calls.map(brief)).toEqual([
+            { subtask_key: "gt", annotation_id: "a1", act_type: "create_annotation", kind: "do" },
+            { subtask_key: "gt", annotation_id: "a1", act_type: "create_annotation", kind: "undo" },
+            { subtask_key: "gt", annotation_id: "a1", act_type: "create_annotation", kind: "redo" },
+        ]);
+        expect(on_annotation_change.mock.calls[0][0]).toEqual({
+            subtask_key: "gt",
+            annotation_id: "a1",
+            act_type: "create_annotation",
+            kind: "do",
+            affected: [],
+            previous_classification_payloads: null,
+            from_subtask_key: null,
+        });
+    });
+
+    test("delete fires for do / undo / redo", () => {
+        const { ulabel, on_annotation_change } = make_ulabel_with_callback({ gt: [make_bbox("g1")] });
+
+        ulabel.delete_annotation("g1");
+        ulabel.undo();
+        ulabel.redo();
+
+        expect(on_annotation_change.mock.calls.map((call) => call[0].kind)).toEqual(["do", "undo", "redo"]);
+        expect(on_annotation_change.mock.calls.every((call) => call[0].act_type === "delete_annotation")).toBe(true);
+    });
+
+    test("is silent without a callback", () => {
+        const ulabel = make_ulabel({ gt: [make_bbox("g1")] });
+
+        expect(() => {
+            ulabel.delete_annotation("g1");
+            ulabel.undo();
+        }).not.toThrow();
+    });
+});
+
+describe("class change", () => {
+    function pick_class(ulabel, annotation_id, class_id) {
+        ulabel.subtasks.gt.state.id_payload = classes.map((cls) => ({ class_id: cls.id, confidence: cls.id === class_id ? 1.0 : 0.0 }));
+        ulabel.assign_annotation_id(annotation_id);
+    }
+
+    test("reports the payloads the annotation had before each event", () => {
+        const { ulabel, on_annotation_change } = make_ulabel_with_callback({ gt: [make_bbox("g1", 1)] });
+        const crop = [{ class_id: 1, confidence: 1.0 }, { class_id: 2, confidence: 0.0 }];
+        const weed = [{ class_id: 1, confidence: 0.0 }, { class_id: 2, confidence: 1.0 }];
+
+        pick_class(ulabel, "g1", 2);
+        ulabel.undo();
+        ulabel.redo();
+
+        expect(on_annotation_change.mock.calls.map((call) => [call[0].kind, call[0].previous_classification_payloads])).toEqual([
+            ["do", crop],
+            ["undo", weed],
+            ["redo", crop],
+        ]);
+        expect(on_annotation_change.mock.calls.every((call) => call[0].act_type === "assign_annotation_id")).toBe(true);
+    });
+
+    test("re-picking the current class fires nothing", () => {
+        const { ulabel, on_annotation_change } = make_ulabel_with_callback({ gt: [make_bbox("g1", 1)] });
+
+        pick_class(ulabel, "g1", 1);
+
+        expect(on_annotation_change).not.toHaveBeenCalled();
+    });
+});
+
+describe("edit", () => {
+    function drag_corner(ulabel, annotation_id, to) {
+        ulabel.get_global_mouse_x = () => to[0];
+        ulabel.get_global_mouse_y = () => to[1];
+        ulabel.subtasks.gt.state.edit_candidate = { annid: annotation_id, access: "11", point: to };
+        ulabel.begin_edit({});
+        ulabel.continue_edit({});
+        ulabel.finish_edit();
+    }
+
+    test("begin_edit and continue_edit are silent on do; finish_edit fires; undo and redo report begin_edit", () => {
+        const { ulabel, on_annotation_change } = make_ulabel_with_callback({ gt: [make_bbox("g1")] });
+
+        drag_corner(ulabel, "g1", [50, 50]);
+        expect(on_annotation_change.mock.calls.map(brief)).toEqual([
+            { subtask_key: "gt", annotation_id: "g1", act_type: "finish_edit", kind: "do" },
+        ]);
+
+        ulabel.undo();
+        expect(ulabel.subtasks.gt.annotations.access.g1.spatial_payload).toEqual([[10, 10], [30, 30]]);
+        ulabel.redo();
+        expect(ulabel.subtasks.gt.annotations.access.g1.spatial_payload).toEqual([[10, 10], [50, 50]]);
+
+        expect(on_annotation_change.mock.calls.slice(1).map(brief)).toEqual([
+            { subtask_key: "gt", annotation_id: "g1", act_type: "begin_edit", kind: "undo" },
+            { subtask_key: "gt", annotation_id: "g1", act_type: "begin_edit", kind: "redo" },
+        ]);
+    });
+
+    test("on_annotation_change_in_progress reports continue_edit too", () => {
+        const { ulabel, on_annotation_change } = make_ulabel_with_callback(
+            { gt: [make_bbox("g1")] },
+            { on_annotation_change_in_progress: true },
+        );
+
+        drag_corner(ulabel, "g1", [50, 50]);
+
+        // begin_edit itself runs one continue_edit, then the explicit one
+        expect(on_annotation_change.mock.calls.map((call) => call[0].act_type)).toEqual([
+            "continue_edit",
+            "continue_edit",
+            "finish_edit",
+        ]);
+    });
+});
+
+describe("drawing", () => {
+    function setup(resume, config_overrides = {}) {
+        const { ulabel, on_annotation_change } = make_ulabel_with_callback(resume, config_overrides);
+        for (const name of ["create_polygon_ender", "move_polygon_ender", "recolor_active_polygon_ender", "redraw_multiple_spatial_annotations", "draw_annotation_from_id"]) {
+            ulabel[name] = jest.fn();
+        }
+        ulabel.subtasks.gt.state.annotation_contexts = { c0: { context: {}, annotation_ids: [] } };
+        ulabel.get_image_aware_mouse_x_y = (mouse_event) => [mouse_event.x, mouse_event.y];
+        ulabel.get_global_mouse_x = (mouse_event) => mouse_event.x;
+        ulabel.get_global_mouse_y = (mouse_event) => mouse_event.y;
+        return { ulabel, on_annotation_change };
+    }
+
+    function draw_bbox(ulabel, from, to) {
+        ulabel.subtasks.gt.state.annotation_mode = "bbox";
+        ulabel.begin_annotation({ x: from[0], y: from[1] });
+        ulabel.continue_annotation({ x: to[0], y: to[1] });
+        ulabel.finish_annotation();
+        return ulabel.subtasks.gt.state.active_id ?? ulabel.subtasks.gt.annotations.ordering.at(-1);
+    }
+
+    function draw_polygon(ulabel, points) {
+        ulabel.subtasks.gt.state.annotation_mode = "polygon";
+        ulabel.begin_annotation({ x: points[0][0], y: points[0][1] });
+        for (const [x, y] of points.slice(1)) {
+            ulabel.continue_annotation({ x, y }, true);
+        }
+        // Close on the first point
+        ulabel.continue_annotation({ x: points[0][0], y: points[0][1] }, true);
+        ulabel.finish_annotation();
+        return ulabel.subtasks.gt.annotations.ordering.at(-1);
+    }
+
+    test("a drawn bbox fires once on finish with its final geometry; undo and redo report begin_annotation", () => {
+        const { ulabel, on_annotation_change } = setup();
+        const seen = [];
+        on_annotation_change.mockImplementation((change) => {
+            seen.push(JSON.parse(JSON.stringify(ulabel.subtasks.gt.annotations.access[change.annotation_id]?.spatial_payload ?? null)));
+        });
+
+        const id = draw_bbox(ulabel, [10, 10], [40, 30]);
+
+        expect(on_annotation_change.mock.calls.map(brief)).toEqual([
+            { subtask_key: "gt", annotation_id: id, act_type: "finish_annotation", kind: "do" },
+        ]);
+        expect(seen).toEqual([[[10, 10], [40, 30]]]);
+
+        ulabel.undo();
+        expect(ulabel.subtasks.gt.annotations.access[id]).toBeUndefined();
+        ulabel.redo();
+        expect(ulabel.subtasks.gt.annotations.access[id].spatial_payload).toEqual([[10, 10], [40, 30]]);
+
+        expect(on_annotation_change.mock.calls.slice(1).map(brief)).toEqual([
+            { subtask_key: "gt", annotation_id: id, act_type: "begin_annotation", kind: "undo" },
+            { subtask_key: "gt", annotation_id: id, act_type: "begin_annotation", kind: "redo" },
+        ]);
+    });
+
+    test("a drawn polygon fires once, after simplify/merge, with the final geometry", () => {
+        const { ulabel, on_annotation_change } = setup();
+        const seen = [];
+        on_annotation_change.mockImplementation((change) => {
+            seen.push(JSON.parse(JSON.stringify(ulabel.subtasks.gt.annotations.access[change.annotation_id].spatial_payload)));
+        });
+
+        // The collinear midpoint on the top edge is what simplify removes
+        const id = draw_polygon(ulabel, [[0, 0], [10, 0], [20, 0], [20, 20], [0, 20]]);
+
+        expect(on_annotation_change.mock.calls.map(brief)).toEqual([
+            { subtask_key: "gt", annotation_id: id, act_type: "finish_annotation", kind: "do" },
+        ]);
+        // The collapse leaves one action standing in for the whole draw
+        expect(ulabel.subtasks.gt.actions.stream.map((action) => action.act_type)).toEqual(["finish_annotation"]);
+        expect(seen).toHaveLength(1);
+        expect(seen[0]).toEqual(ulabel.subtasks.gt.annotations.access[id].spatial_payload);
+        expect(seen[0][0]).not.toContainEqual([10, 0]);
+
+        ulabel.undo();
+        expect(ulabel.subtasks.gt.annotations.access[id].deprecated).toBe(true);
+        ulabel.redo();
+        expect(ulabel.subtasks.gt.annotations.access[id].deprecated).toBe(false);
+
+        expect(on_annotation_change.mock.calls.slice(1).map(brief)).toEqual([
+            { subtask_key: "gt", annotation_id: id, act_type: "finish_annotation", kind: "undo" },
+            { subtask_key: "gt", annotation_id: id, act_type: "finish_annotation", kind: "redo" },
+        ]);
+    });
+
+    test("on_annotation_change_in_progress reports each continue_annotation", () => {
+        const { ulabel, on_annotation_change } = setup({}, { on_annotation_change_in_progress: true });
+
+        draw_bbox(ulabel, [10, 10], [40, 30]);
+
+        expect(on_annotation_change.mock.calls.map((call) => call[0].act_type)).toEqual(["continue_annotation", "finish_annotation"]);
+    });
+});
+
+describe("move", () => {
+    function drag_body(ulabel, dx, dy) {
+        ulabel.subtasks.gt.state.move_candidate = { annid: "g1", spatial_type: "bbox", access: 0, distance: 0, point: [20, 20], containing: true };
+        ulabel.drag_state.move.mouse_start = [100, 100, 0];
+        ulabel.begin_move({ clientX: 100, clientY: 100 });
+        ulabel.finish_move({ clientX: 100 + dx, clientY: 100 + dy });
+    }
+
+    test("a drag fires finish_move; a zero-diff click fires nothing", () => {
+        const { ulabel, on_annotation_change } = make_ulabel_with_callback({ gt: [make_bbox("g1")] });
+
+        drag_body(ulabel, 0, 0);
+        expect(on_annotation_change).not.toHaveBeenCalled();
+
+        drag_body(ulabel, 20, 10);
+        ulabel.undo();
+        ulabel.redo();
+
+        expect(on_annotation_change.mock.calls.map(brief)).toEqual([
+            { subtask_key: "gt", annotation_id: "g1", act_type: "finish_move", kind: "do" },
+            { subtask_key: "gt", annotation_id: "g1", act_type: "begin_move", kind: "undo" },
+            { subtask_key: "gt", annotation_id: "g1", act_type: "begin_move", kind: "redo" },
+        ]);
+    });
+});
+
+describe("cross-subtask actions", () => {
+    test("paste is reported on the target stream", () => {
+        const { ulabel, on_annotation_change } = make_ulabel_with_callback({ gt: [make_bbox("g1")] });
+
+        const new_id = ulabel.copy_annotation_to_subtask("g1", "gt", "pred");
+
+        expect(on_annotation_change.mock.calls.map(brief)).toEqual([
+            { subtask_key: "pred", annotation_id: new_id, act_type: "paste_annotation", kind: "do" },
+        ]);
+        expect(on_annotation_change.mock.calls[0][0].affected).toEqual([]);
+    });
+
+    test("move is reported on the source stream with the target copy in affected", () => {
+        const { ulabel, on_annotation_change } = make_ulabel_with_callback({ gt: [make_bbox("g1")] });
+
+        const new_id = ulabel.copy_annotation_to_subtask("g1", "gt", "pred", null, true);
+        ulabel.undo();
+        ulabel.redo();
+
+        expect(on_annotation_change.mock.calls.map(brief)).toEqual([
+            { subtask_key: "gt", annotation_id: "g1", act_type: "move_annotation", kind: "do" },
+            { subtask_key: "gt", annotation_id: "g1", act_type: "move_annotation", kind: "undo" },
+            { subtask_key: "gt", annotation_id: "g1", act_type: "move_annotation", kind: "redo" },
+        ]);
+        for (const call of on_annotation_change.mock.calls) {
+            expect(call[0].affected).toEqual([{ annotation_id: new_id, subtask_key: "pred" }]);
+        }
+    });
+
+    test("bitmask overlap edits carry the other masks in affected", () => {
+        const mask = (id) => ({ ...make_bbox(id), spatial_type: "bitmask", spatial_payload: null, containing_box: null });
+        const { ulabel, on_annotation_change } = make_ulabel_with_callback({ gt: [mask("m1"), mask("m2")], pred: [mask("p1")] });
+        const edit = (annotation_id, subtask) => ({ annotation_id, subtask, before_rle: null, after_rle: null, after_empty: false });
+
+        ulabel.bitmask_stroke__redo("m1", {
+            before_rle: null,
+            after_rle: null,
+            was_new: false,
+            after_empty: false,
+            other_edits: [edit("m2", "gt"), edit("p1", "pred")],
+        });
+
+        expect(on_annotation_change).toHaveBeenCalledTimes(1);
+        expect(brief(on_annotation_change.mock.calls[0])).toEqual({ subtask_key: "gt", annotation_id: "m1", act_type: "bitmask_stroke", kind: "redo" });
+        expect(on_annotation_change.mock.calls[0][0].affected).toEqual([
+            { annotation_id: "m2", subtask_key: "gt" },
+            { annotation_id: "p1", subtask_key: "pred" },
+        ]);
+    });
+});
+
+describe("not reported", () => {
+    test("edit_text_payload", () => {
+        const { ulabel, on_annotation_change } = make_ulabel_with_callback({ gt: [make_bbox("g1")] });
+
+        ulabel.edit_text_payload("g1", "note");
+        ulabel.undo();
+
+        expect(on_annotation_change).not.toHaveBeenCalled();
+    });
+
+    test("set_annotations", async () => {
+        const { ulabel, on_annotation_change } = make_ulabel_with_callback({ gt: [make_bbox("g1")] });
+        ulabel._clear_subtask_annotation_canvases = jest.fn();
+        ulabel.refresh_toolbox = jest.fn();
+
+        await ulabel.set_annotations([make_bbox("g2")], "gt", false, false);
+
+        expect(ulabel.subtasks.gt.annotations.ordering).toEqual(["g2"]);
+        expect(on_annotation_change).not.toHaveBeenCalled();
+    });
+});
+
+test("a throwing callback is logged and does not break the action", () => {
+    const warn = jest.spyOn(console, "warn").mockImplementation(() => {});
+    const { ulabel } = make_ulabel_with_callback({ gt: [make_bbox("g1")] }, {
+        on_annotation_change: () => {
+            throw new Error("host bug");
+        },
+    });
+
+    expect(() => ulabel.delete_annotation("g1")).not.toThrow();
+
+    expect(ulabel.subtasks.gt.annotations.access.g1.deprecated).toBe(true);
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining("host bug"));
+    warn.mockRestore();
+});
diff --git a/tests/read_only_toggle.test.js b/tests/read_only_toggle.test.js
new file mode 100644
index 00000000..10fb58fe
--- /dev/null
+++ b/tests/read_only_toggle.test.js
@@ -0,0 +1,251 @@
+// Unit tests for set_subtask_read_only and the read-only gates (CVML-287).
+const { ULabel } = require("./testing-utils/build_loader");
+
+const classes = [
+    { name: "Crop", id: 1, color: "green" },
+    { name: "Weed", id: 2, color: "red" },
+];
+
+function make_bbox(id) {
+    return {
+        id,
+        spatial_type: "bbox",
+        spatial_payload: [[10, 10], [30, 30]],
+        containing_box: { tlx: 10, tly: 10, brx: 30, bry: 30 },
+        classification_payloads: [{ class_id: 1, confidence: 1.0 }],
+        deprecated: false,
+    };
+}
+
+function make_ulabel(config_overrides = {}, gt_resume = null) {
+    const ulabel = new ULabel({
+        container_id: "container",
+        image_data: "test.jpg",
+        username: "test_user",
+        image_width: 100,
+        image_height: 100,
+        allow_annotations_outside_image: true,
+        submit_buttons: [{ name: "Submit", hook: jest.fn() }],
+        subtasks: {
+            gt: { display_name: "GT", classes, allowed_modes: ["bbox", "polygon", "whole-image"], resume_from: gt_resume },
+            pred: { display_name: "Pred", classes, allowed_modes: ["bbox", "polygon"], resume_from: null },
+        },
+        ...config_overrides,
+    });
+    ulabel.state.current_subtask = "gt";
+    for (const name of [
+        "redraw_annotation",
+        "redraw_all_annotations",
+        "redraw_all_annotations_in_annotation_context",
+        "rebuild_containing_box",
+        "update_filter_distance",
+        "suggest_edits",
+        "show_edit_suggestion",
+        "destroy_polygon_ender",
+        "destroy_annotation_context",
+        "hide_id_dialog",
+        "hide_context_menu",
+        "hide_and_clear_action_candidates",
+        "update_frame",
+        "set_and_update_annotation_mode",
+        "create_brush_circle",
+        "destroy_brush_circle",
+    ]) {
+        ulabel[name] = jest.fn();
+    }
+    ulabel.toolbox = { redraw_update_items: jest.fn() };
+    ulabel.get_init_canvas_context_id = jest.fn(() => "c0");
+    return ulabel;
+}
+
+describe("set_subtask_read_only", () => {
+    test("unknown subtask key warns and changes nothing", () => {
+        const ulabel = make_ulabel();
+        const warn = jest.spyOn(console, "warn").mockImplementation(() => {});
+
+        ulabel.set_subtask_read_only("nope", true);
+
+        expect(warn).toHaveBeenCalled();
+        expect(ulabel.subtasks.gt.read_only).toBe(false);
+        warn.mockRestore();
+    });
+
+    test("same value is a no-op", () => {
+        const ulabel = make_ulabel();
+
+        ulabel.set_subtask_read_only("gt", false);
+
+        expect(ulabel.hide_id_dialog).not.toHaveBeenCalled();
+    });
+
+    test("is not recorded and fires no callback", () => {
+        const on_annotation_change = jest.fn();
+        const ulabel = make_ulabel({ on_annotation_change });
+        ulabel.create_annotation("bbox", [[0, 0], [10, 10]], "a1");
+        on_annotation_change.mockClear();
+        ulabel.set_saved(true);
+
+        ulabel.set_subtask_read_only("gt", true);
+        ulabel.set_subtask_read_only("gt", false);
+
+        expect(ulabel.subtasks.gt.actions.stream).toHaveLength(1);
+        expect(on_annotation_change).not.toHaveBeenCalled();
+        expect(ulabel.state.edited).toBe(false);
+    });
+
+    test("a non-current subtask flips without teardown", () => {
+        const ulabel = make_ulabel();
+
+        ulabel.set_subtask_read_only("pred", true);
+
+        expect(ulabel.subtasks.pred.read_only).toBe(true);
+        expect(ulabel.hide_id_dialog).not.toHaveBeenCalled();
+    });
+
+    test("current subtask tears down in order while still editable", () => {
+        const ulabel = make_ulabel();
+        const state = ulabel.subtasks.gt.state;
+        const calls = [];
+        const track = (name, fn = () => {}) => {
+            ulabel[name] = jest.fn((...args) => {
+                calls.push([name, ulabel.subtasks.gt.read_only]);
+                fn(...args);
+            });
+        };
+        ulabel.drag_state.active_key = "annotation";
+        ulabel.state.last_move = { fake: true };
+        state.is_in_progress = true;
+        state.is_in_brush_mode = true;
+        track("end_drag", () => {
+            ulabel.drag_state.active_key = null;
+        });
+        track("cancel_annotation", () => {
+            state.is_in_progress = false;
+        });
+        track("disable_bitmask_brush");
+        track("hide_id_dialog");
+        track("hide_context_menu");
+        track("hide_and_clear_action_candidates");
+
+        ulabel.set_subtask_read_only("gt", true);
+
+        expect(calls).toEqual([
+            ["end_drag", false],
+            ["cancel_annotation", false],
+            ["disable_bitmask_brush", false],
+            ["hide_id_dialog", false],
+            ["hide_context_menu", false],
+            ["hide_and_clear_action_candidates", false],
+        ]);
+        expect(ulabel.end_drag).toHaveBeenCalledWith(ulabel.state.last_move);
+        expect(ulabel.subtasks.gt.read_only).toBe(true);
+    });
+
+    test("becoming editable runs no teardown", () => {
+        const ulabel = make_ulabel();
+        ulabel.set_subtask_read_only("gt", true);
+        ulabel.hide_id_dialog.mockClear();
+
+        ulabel.set_subtask_read_only("gt", false);
+
+        expect(ulabel.subtasks.gt.read_only).toBe(false);
+        expect(ulabel.hide_id_dialog).not.toHaveBeenCalled();
+    });
+});
+
+describe("undo / redo gates", () => {
+    test("user undo and redo do nothing on a read-only current subtask", () => {
+        const ulabel = make_ulabel();
+        ulabel.create_annotation("bbox", [[0, 0], [10, 10]], "a1");
+        ulabel.create_annotation("bbox", [[0, 0], [10, 10]], "a2");
+        ulabel.undo();
+        const { stream, undone_stack } = ulabel.subtasks.gt.actions;
+
+        ulabel.set_subtask_read_only("gt", true);
+        ulabel.undo();
+        ulabel.redo();
+
+        expect(stream).toHaveLength(1);
+        expect(undone_stack).toHaveLength(1);
+        expect(ulabel.subtasks.gt.annotations.access.a1.deprecated).toBe(false);
+
+        ulabel.set_subtask_read_only("gt", false);
+        ulabel.redo();
+        expect(stream).toHaveLength(2);
+        ulabel.undo();
+        ulabel.undo();
+        expect(stream).toHaveLength(0);
+    });
+
+    test("user undo is blocked when the action touched a read-only subtask", () => {
+        const ulabel = make_ulabel({}, [make_bbox("g1")]);
+        const new_id = ulabel.copy_annotation_to_subtask("g1", "gt", "pred", null, true);
+        const stream = ulabel.subtasks.gt.actions.stream;
+        expect(stream[stream.length - 1].affected).toEqual([{ annotation_id: new_id, subtask_key: "pred" }]);
+
+        ulabel.set_subtask_read_only("pred", true);
+        ulabel.undo();
+        expect(stream).toHaveLength(1);
+
+        ulabel.set_subtask_read_only("pred", false);
+        ulabel.undo();
+        expect(stream).toHaveLength(0);
+
+        ulabel.set_subtask_read_only("pred", true);
+        ulabel.redo();
+        expect(stream).toHaveLength(0);
+    });
+});
+
+describe("brush gates", () => {
+    test("toggle_brush_mode and toggle_erase_mode do nothing when read-only", () => {
+        const ulabel = make_ulabel();
+        ulabel.subtasks.gt.state.annotation_mode = "polygon";
+        ulabel.set_subtask_read_only("gt", true);
+
+        ulabel.toggle_brush_mode();
+        ulabel.toggle_erase_mode();
+
+        expect(ulabel.subtasks.gt.state.is_in_brush_mode).toBe(false);
+        expect(ulabel.subtasks.gt.state.is_in_erase_mode).toBe(false);
+    });
+
+    test("a brush circle mousedown starts no brush drag when read-only", () => {
+        const ulabel = make_ulabel();
+        const mouse_event = { button: 0, target: { id: "brush_circle" } };
+
+        expect(ULabel.get_drag_key_start(mouse_event, ulabel)).toBe("brush");
+        ulabel.set_subtask_read_only("gt", true);
+        expect(ULabel.get_drag_key_start(mouse_event, ulabel)).toBeNull();
+    });
+});
+
+describe("non-spatial rows", () => {
+    test("re-render with or without their controls", () => {
+        const ulabel = make_ulabel();
+        document.body.innerHTML = "<div id=\"fad_st__gt\"><div class=\"fad_annotation_rows\"></div></div>";
+        const annotation = {
+            id: "w1",
+            spatial_type: "whole-image",
+            spatial_payload: null,
+            classification_payloads: [{ class_id: 1, confidence: 1.0 }],
+            text_payload: "note",
+            deprecated: false,
+        };
+        ulabel.subtasks.gt.annotations.access.w1 = annotation;
+        ulabel.subtasks.gt.annotations.ordering.push("w1");
+        ulabel.draw_whole_image_annotation(annotation, "gt");
+        expect($("#delete__w1")).toHaveLength(1);
+
+        ulabel.set_subtask_read_only("gt", true);
+        expect($("#delete__w1")).toHaveLength(0);
+        expect($("#reclf__w1")).toHaveLength(0);
+        expect($("#note__w1").prop("readOnly")).toBe(true);
+        expect($("#note__w1").val()).toBe("note");
+
+        ulabel.set_subtask_read_only("gt", false);
+        expect($("#delete__w1")).toHaveLength(1);
+        expect($("#reclf__w1")).toHaveLength(1);
+        expect($("#note__w1").prop("readOnly")).toBe(false);
+    });
+});
diff --git a/tests/submit_payload.test.js b/tests/submit_payload.test.js
new file mode 100644
index 00000000..53691949
--- /dev/null
+++ b/tests/submit_payload.test.js
@@ -0,0 +1,399 @@
+// Unit tests for the per-button submit payload options: `subtasks` whitelist
+// and `edits_only` (new / deleted / modified relative to what the host loaded).
+// NOTE: require `configuration` before `submit_buttons` so the `ToolboxItem`
+// base class is initialized first (see confidence_slider.test.js).
+require("../build/configuration");
+const { SubmitButtons } = require("../build/toolbox_items/submit_buttons");
+const { mark_deprecated } = require("../build/annotation_operators");
+const { ULabel } = require("./testing-utils/build_loader");
+
+function make_bbox(id, class_id = 1, extra = {}) {
+    return {
+        id,
+        spatial_type: "bbox",
+        spatial_payload: [[0, 0], [10, 10]],
+        classification_payloads: [{ class_id, confidence: 1.0 }],
+        deprecated: false,
+        last_edited_at: "2026-01-01T00:00:00.000Z",
+        last_edited_by: "host",
+        ...extra,
+    };
+}
+
+function make_polygon(id) {
+    return make_bbox(id, 1, {
+        spatial_type: "polygon",
+        spatial_payload: [[[0, 0], [10, 0], [10, 10], [0, 10], [0, 0]]],
+    });
+}
+
+function make_note(id) {
+    return make_bbox(id, 1, { spatial_type: "whole-image", spatial_payload: null, text_payload: "before" });
+}
+
+const classes = [
+    { name: "Crop", id: 1, color: "green" },
+    { name: "Weed", id: 2, color: "red" },
+];
+
+function make_config(gt, pred) {
+    return {
+        container_id: "container",
+        image_data: "test.jpg",
+        username: "test_user",
+        image_width: 100,
+        image_height: 100,
+        allow_annotations_outside_image: true,
+        task_meta: { job: 7 },
+        submit_buttons: [{ name: "Submit", hook: jest.fn() }],
+        subtasks: {
+            gt: { display_name: "GT", classes, allowed_modes: ["bbox", "point", "polygon", "delete_polygon", "bitmask", "whole-image"], resume_from: gt },
+            pred: { display_name: "Pred", classes, allowed_modes: ["bbox", "bitmask"], resume_from: pred },
+        },
+    };
+}
+
+function make_ulabel(gt = [], pred = []) {
+    const ulabel = new ULabel(make_config(gt, pred));
+    ulabel.state.current_subtask = "gt";
+    for (const name of [
+        "redraw_annotation",
+        "redraw_all_annotations",
+        "redraw_multiple_spatial_annotations",
+        "rebuild_containing_box",
+        "update_filter_distance",
+        "suggest_edits",
+        "destroy_polygon_ender",
+        "destroy_annotation_context",
+        "remove_recorded_events_for_annotation",
+        "hide_id_dialog",
+        "hide_context_menu",
+        "update_frame",
+        "recolor_active_polygon_ender",
+        "recolor_brush_circle",
+    ]) {
+        ulabel[name] = jest.fn();
+    }
+    ulabel.toolbox = { redraw_update_items: jest.fn() };
+    ulabel.get_init_canvas_context_id = jest.fn(() => "c0");
+    ulabel.subtasks.gt.state.annotation_contexts = { c0: { context: {}, annotation_ids: [] } };
+    return ulabel;
+}
+
+function ids(payload, subtask_key) {
+    return payload.annotations[subtask_key].map((annotation) => annotation.id);
+}
+
+function edit_types(payload, subtask_key) {
+    return Object.fromEntries(payload.annotations[subtask_key].map((annotation) => [annotation.id, annotation.edit_type]));
+}
+
+function reclassify(ulabel, annotation_id, class_id) {
+    ulabel.subtasks.gt.state.id_payload = [{ class_id, confidence: 1.0 }];
+    ulabel.assign_annotation_id(annotation_id);
+}
+
+describe("build_submit_payload without options", () => {
+    test("matches the legacy payload: every subtask, every annotation, task_meta", () => {
+        const ulabel = make_ulabel([make_bbox("g1"), make_bbox("g2", 1, { deprecated: true })], [make_bbox("p1")]);
+
+        const payload = SubmitButtons.build_submit_payload(ulabel);
+
+        expect(payload.task_meta).toEqual({ job: 7 });
+        expect(Object.keys(payload.annotations)).toEqual(["gt", "pred"]);
+        expect(ids(payload, "gt")).toEqual(["g1", "g2"]);
+        expect(ids(payload, "pred")).toEqual(["p1"]);
+        expect(payload.annotations.gt[1].deprecated).toBe(true);
+        for (const annotation of [...payload.annotations.gt, ...payload.annotations.pred]) {
+            expect(annotation.edit_type).toBeUndefined();
+        }
+    });
+
+    test("strips an edit_type a host round-tripped through resume_from", () => {
+        const ulabel = make_ulabel([make_bbox("g1", 1, { edit_type: "modified" })]);
+
+        const payload = SubmitButtons.build_submit_payload(ulabel);
+
+        expect(payload.annotations.gt[0].edit_type).toBeUndefined();
+    });
+
+    test("skips nonspatial annotations with a null spatial payload", () => {
+        const ulabel = make_ulabel([make_note("note"), make_bbox("g1")]);
+
+        expect(ids(SubmitButtons.build_submit_payload(ulabel), "gt")).toEqual(["g1"]);
+    });
+});
+
+describe("subtasks whitelist", () => {
+    test("keeps only the listed subtask keys, in config order", () => {
+        const ulabel = make_ulabel([make_bbox("g1")], [make_bbox("p1")]);
+
+        const payload = SubmitButtons.build_submit_payload(ulabel, { subtasks: ["pred"] });
+
+        expect(Object.keys(payload.annotations)).toEqual(["pred"]);
+        expect(ids(payload, "pred")).toEqual(["p1"]);
+    });
+
+    test("ignores unknown keys", () => {
+        const ulabel = make_ulabel([make_bbox("g1")], [make_bbox("p1")]);
+
+        const payload = SubmitButtons.build_submit_payload(ulabel, { subtasks: ["gt", "nope"] });
+
+        expect(Object.keys(payload.annotations)).toEqual(["gt"]);
+    });
+});
+
+describe("edits_only", () => {
+    const edits_only = { edits_only: true };
+
+    test("is empty when nothing was touched, including loaded-deprecated annotations", () => {
+        const ulabel = make_ulabel([make_bbox("g1"), make_bbox("g2", 1, { deprecated: true })]);
+
+        expect(ids(SubmitButtons.build_submit_payload(ulabel, edits_only), "gt")).toEqual([]);
+    });
+
+    test("loaded annotations without a host timestamp still count as loaded", () => {
+        const ulabel = make_ulabel([make_bbox("g1", 1, { last_edited_at: undefined, last_edited_by: undefined })]);
+
+        expect(ulabel.subtasks.gt.annotations.access.g1.last_edited_at).toBeNull();
+        expect(ids(SubmitButtons.build_submit_payload(ulabel, edits_only), "gt")).toEqual([]);
+
+        ulabel.delete_annotation("g1");
+
+        expect(edit_types(SubmitButtons.build_submit_payload(ulabel, edits_only), "gt")).toEqual({ g1: "deleted" });
+    });
+
+    test("new: an in-session creation is included until it is deleted or undone", () => {
+        const ulabel = make_ulabel([make_bbox("g1")]);
+
+        ulabel.create_annotation("bbox", [[1, 1], [5, 5]], "fresh");
+        expect(edit_types(SubmitButtons.build_submit_payload(ulabel, edits_only), "gt")).toEqual({ fresh: "created" });
+
+        ulabel.delete_annotation("fresh");
+        expect(ids(SubmitButtons.build_submit_payload(ulabel, edits_only), "gt")).toEqual([]);
+
+        ulabel.undo();
+        expect(ids(SubmitButtons.build_submit_payload(ulabel, edits_only), "gt")).toEqual(["fresh"]);
+
+        ulabel.undo();
+        expect(ids(SubmitButtons.build_submit_payload(ulabel, edits_only), "gt")).toEqual([]);
+    });
+
+    test("deleted: a loaded annotation is reported once deleted and dropped again on undo", () => {
+        const ulabel = make_ulabel([make_bbox("g1"), make_bbox("g2")]);
+
+        ulabel.delete_annotation("g2");
+        const payload = SubmitButtons.build_submit_payload(ulabel, edits_only);
+        expect(edit_types(payload, "gt")).toEqual({ g2: "deleted" });
+        expect(payload.annotations.gt[0].deprecated).toBe(true);
+
+        ulabel.undo();
+        expect(ids(SubmitButtons.build_submit_payload(ulabel, edits_only), "gt")).toEqual([]);
+
+        ulabel.redo();
+        expect(ids(SubmitButtons.build_submit_payload(ulabel, edits_only), "gt")).toEqual(["g2"]);
+    });
+
+    test("modified: reclassifying a loaded annotation reports it, undo drops it", () => {
+        const ulabel = make_ulabel([make_bbox("g1"), make_bbox("g2")]);
+
+        reclassify(ulabel, "g1", 2);
+        const payload = SubmitButtons.build_submit_payload(ulabel, edits_only);
+        expect(edit_types(payload, "gt")).toEqual({ g1: "modified" });
+        expect(payload.annotations.gt[0].classification_payloads[0].class_id).toBe(2);
+
+        ulabel.undo();
+        expect(ids(SubmitButtons.build_submit_payload(ulabel, edits_only), "gt")).toEqual([]);
+    });
+
+    test("modified: a delete polygon reports its victims, not the eraser", () => {
+        const ulabel = make_ulabel([
+            make_bbox("hit", 1, { spatial_type: "point", spatial_payload: [[5, 5]] }),
+            make_bbox("missed", 1, { spatial_type: "point", spatial_payload: [[50, 50]] }),
+        ]);
+        ulabel.create_annotation("delete_polygon", [[-1, -1], [20, -1], [20, 20], [-1, 20], [-1, -1]], "del0");
+
+        ulabel.delete_annotations_in_polygon("del0");
+        expect(edit_types(SubmitButtons.build_submit_payload(ulabel, edits_only), "gt")).toEqual({ hit: "deleted" });
+
+        ulabel.undo();
+        expect(ids(SubmitButtons.build_submit_payload(ulabel, edits_only), "gt")).toEqual([]);
+    });
+
+    test("modified: a bitmask overwrite reports the carved mask in another whitelisted subtask", () => {
+        const mask = (id) => make_bbox(id, 1, { spatial_type: "bitmask", spatial_payload: { counts: [100 * 100], size: [100, 100] } });
+        const ulabel = make_ulabel([mask("active")], [mask("victim")]);
+
+        ulabel.bitmask_stroke__redo("active", {
+            before_rle: null,
+            after_rle: ulabel.subtasks.gt.annotations.access.active.spatial_payload,
+            was_new: false,
+            after_empty: false,
+            other_edits: [{
+                annotation_id: "victim",
+                subtask: "pred",
+                before_rle: null,
+                after_rle: ulabel.subtasks.pred.annotations.access.victim.spatial_payload,
+                after_empty: false,
+            }],
+        });
+
+        const payload = SubmitButtons.build_submit_payload(ulabel, edits_only);
+        expect(edit_types(payload, "gt")).toEqual({ active: "modified" });
+        expect(edit_types(payload, "pred")).toEqual({ victim: "modified" });
+
+        ulabel.undo();
+        const after_undo = SubmitButtons.build_submit_payload(ulabel, edits_only);
+        expect(ids(after_undo, "gt")).toEqual([]);
+        expect(ids(after_undo, "pred")).toEqual([]);
+    });
+
+    test("a filter hiding a loaded annotation is not an edit", () => {
+        const ulabel = make_ulabel([make_bbox("g1")]);
+        const g1 = ulabel.subtasks.gt.annotations.access.g1;
+        g1.deprecated_by = { human: false, confidence_filter: true };
+        g1.deprecated = true;
+
+        expect(ids(SubmitButtons.build_submit_payload(ulabel, edits_only), "gt")).toEqual([]);
+    });
+
+    test("a filter hiding a modified annotation keeps it modified and not deprecated", () => {
+        const ulabel = make_ulabel([make_bbox("g1")]);
+        reclassify(ulabel, "g1", 2);
+        mark_deprecated(ulabel.subtasks.gt.annotations.access.g1, true, "confidence_slider");
+        expect(ulabel.subtasks.gt.annotations.access.g1.deprecated).toBe(true);
+
+        const payload = SubmitButtons.build_submit_payload(ulabel, edits_only);
+
+        expect(edit_types(payload, "gt")).toEqual({ g1: "modified" });
+        expect(payload.annotations.gt[0].deprecated).toBe(false);
+        expect(payload.annotations.gt[0].deprecated_by.confidence_slider).toBe(true);
+    });
+
+    test("a filter hiding a created annotation keeps it created", () => {
+        const ulabel = make_ulabel([]);
+        ulabel.create_annotation("bbox", [[1, 1], [5, 5]], "fresh");
+        mark_deprecated(ulabel.subtasks.gt.annotations.access.fresh, true, "confidence_slider");
+
+        const payload = SubmitButtons.build_submit_payload(ulabel, edits_only);
+
+        expect(edit_types(payload, "gt")).toEqual({ fresh: "created" });
+        expect(payload.annotations.gt[0].deprecated).toBe(false);
+    });
+
+    test("a human deletion under a filter is still a deletion", () => {
+        const ulabel = make_ulabel([make_bbox("g1")]);
+        ulabel.delete_annotation("g1");
+        mark_deprecated(ulabel.subtasks.gt.annotations.access.g1, true, "confidence_slider");
+
+        const payload = SubmitButtons.build_submit_payload(ulabel, edits_only);
+
+        expect(edit_types(payload, "gt")).toEqual({ g1: "deleted" });
+        expect(payload.annotations.gt[0].deprecated).toBe(true);
+    });
+
+    test("a loaded polygon erased to nothing still yields a deletion record", () => {
+        const ulabel = make_ulabel([make_polygon("poly")]);
+        // What continue_brush leaves behind after the last fill is erased
+        ulabel.delete_annotation("poly");
+        ulabel.subtasks.gt.annotations.access.poly.spatial_payload = [];
+
+        expect(ids(SubmitButtons.build_submit_payload(ulabel), "gt")).toEqual([]);
+        const payload = SubmitButtons.build_submit_payload(ulabel, edits_only);
+        expect(edit_types(payload, "gt")).toEqual({ poly: "deleted" });
+        expect(payload.annotations.gt[0].deprecated).toBe(true);
+        expect(payload.annotations.gt[0].spatial_type).toBe("polygon");
+    });
+
+    test("a created polygon erased to nothing is omitted", () => {
+        const ulabel = make_ulabel([]);
+        ulabel.create_annotation("polygon", [[[0, 0], [10, 0], [10, 10], [0, 10], [0, 0]]], "fresh");
+        ulabel.delete_annotation("fresh");
+        ulabel.subtasks.gt.annotations.access.fresh.spatial_payload = [];
+
+        expect(ids(SubmitButtons.build_submit_payload(ulabel, edits_only), "gt")).toEqual([]);
+    });
+
+    test("an edited or created nonspatial note does not reach the payload", () => {
+        const ulabel = make_ulabel([make_note("note")]);
+        ulabel.edit_text_payload("note", "after");
+        ulabel.create_annotation("whole-image", null, "fresh_note");
+
+        expect(ids(SubmitButtons.build_submit_payload(ulabel, edits_only), "gt")).toEqual([]);
+    });
+
+    test.each([
+        ["a string baseline", "2026-01-01T00:00:00.000Z"],
+        ["a null baseline", null],
+    ])("modified: a finished complex layer drops out on undo and returns on redo with %s", (_label, loaded_at) => {
+        const ulabel = make_ulabel([make_bbox("poly", 1, {
+            spatial_type: "polygon",
+            spatial_payload: [[[0, 0], [10, 0], [10, 10], [0, 10], [0, 0]]],
+            last_edited_at: loaded_at,
+        })]);
+        expect(ulabel.subtasks.gt.annotations.access.poly.last_edited_at).toBe(loaded_at);
+        ulabel.subtasks.gt.state.active_id = "poly";
+        ulabel.start_complex_polygon();
+        ulabel.subtasks.gt.annotations.access.poly.spatial_payload[1] = [[20, 20], [30, 20], [30, 30], [20, 30], [20, 30]];
+        ulabel.finish_annotation();
+
+        const stream = ulabel.subtasks.gt.actions.stream;
+        expect(stream[stream.length - 1].act_type).toBe("finish_modify_annotation");
+        expect(stream[stream.length - 1].prev_timestamp).toBe(loaded_at);
+        expect(edit_types(SubmitButtons.build_submit_payload(ulabel, edits_only), "gt")).toEqual({ poly: "modified" });
+
+        ulabel.undo();
+        expect(ulabel.subtasks.gt.annotations.access.poly.last_edited_at).toBe(loaded_at);
+        expect(ulabel.subtasks.gt.annotations.access.poly.spatial_payload.length).toBe(1);
+        expect(ids(SubmitButtons.build_submit_payload(ulabel, edits_only), "gt")).toEqual([]);
+
+        ulabel.redo();
+        expect(edit_types(SubmitButtons.build_submit_payload(ulabel, edits_only), "gt")).toEqual({ poly: "modified" });
+
+        ulabel.undo();
+        expect(ids(SubmitButtons.build_submit_payload(ulabel, edits_only), "gt")).toEqual([]);
+    });
+
+    test("set_annotations re-baselines the replaced subtask", async () => {
+        const ulabel = make_ulabel([make_bbox("g1")]);
+        ulabel.delete_annotation("g1");
+        expect(ids(SubmitButtons.build_submit_payload(ulabel, edits_only), "gt")).toEqual(["g1"]);
+        ulabel._clear_subtask_annotation_canvases = jest.fn();
+        ulabel.refresh_toolbox = jest.fn();
+        ulabel.reset_interaction_state = jest.fn();
+
+        await ulabel.set_annotations([make_bbox("g1"), make_bbox("g3")], "gt", false, false);
+
+        expect(ids(SubmitButtons.build_submit_payload(ulabel, edits_only), "gt")).toEqual([]);
+        expect(ulabel.subtasks.gt.annotations.loaded_edited_at).toEqual({
+            g1: "2026-01-01T00:00:00.000Z",
+            g3: "2026-01-01T00:00:00.000Z",
+        });
+    });
+
+    test("combines with the subtasks whitelist", () => {
+        const ulabel = make_ulabel([make_bbox("g1")], [make_bbox("p1")]);
+        ulabel.delete_annotation("g1");
+
+        const payload = SubmitButtons.build_submit_payload(ulabel, { subtasks: ["pred"], edits_only: true });
+
+        expect(Object.keys(payload.annotations)).toEqual(["pred"]);
+        expect(ids(payload, "pred")).toEqual([]);
+    });
+});
+
+describe("has_edits", () => {
+    test("follows the edits_only payload, so an undone edit clears it", () => {
+        const ulabel = make_ulabel([make_bbox("g1")], [make_bbox("p1")]);
+        expect(ulabel.has_edits()).toBe(false);
+
+        ulabel.delete_annotation("g1");
+        expect(ulabel.has_edits()).toBe(true);
+        expect(ulabel.has_edits(["gt"])).toBe(true);
+        expect(ulabel.has_edits(["pred"])).toBe(false);
+
+        ulabel.undo();
+        expect(ulabel.has_edits()).toBe(false);
+        expect(ulabel.state.edited).toBe(true);
+    });
+});