diff --git a/packages/freecut-editor/README.md b/packages/freecut-editor/README.md
index 68f0dc3a1..4480ec512 100644
--- a/packages/freecut-editor/README.md
+++ b/packages/freecut-editor/README.md
@@ -69,7 +69,9 @@ shortcut editor, including J/K/L transport. UI changes call `setSettings`, and
 host or agent changes can flow back through `subscribe`, so embedded shortcut
 configuration never becomes a UI-only setting.
 
-As of 0.3.11, the host-mode Delete action and Delete/Backspace shortcuts submit
+As of 0.3.12, host-mode timeline clips use durable forward attachment chains by
+default. A detached clip is an explicit ripple break and can be reattached from
+its context menu. The host-mode Delete action and Delete/Backspace shortcuts submit
 one authoritative ripple-delete request for the selected linked cohort. The
 controlled timeline remains unchanged until the host receipt arrives; rejected
 requests surface actionable host feedback. Lift / leave gap remains the named
@@ -135,5 +137,5 @@ Consumers install the exact published version and keep it pinned in their
 lockfile:
 
 ```bash
-npm install @quantfive/freecut-editor-surface@0.3.11
+npm install @quantfive/freecut-editor-surface@0.3.12
 ```
diff --git a/packages/freecut-editor/package.json b/packages/freecut-editor/package.json
index bf57e0a81..19e9df070 100644
--- a/packages/freecut-editor/package.json
+++ b/packages/freecut-editor/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@quantfive/freecut-editor-surface",
-  "version": "0.3.11",
+  "version": "0.3.12",
   "description": "The host-backed FreeCut browser editor surface.",
   "license": "MIT",
   "repository": {
diff --git a/packages/freecut-editor/src/index.d.ts b/packages/freecut-editor/src/index.d.ts
index ac970bdad..ca1afedcd 100644
--- a/packages/freecut-editor/src/index.d.ts
+++ b/packages/freecut-editor/src/index.d.ts
@@ -88,6 +88,7 @@ export type EditorCapability =
   | 'media.relink'
   | 'timeline.add'
   | 'timeline.move'
+  | 'timeline.attachment'
   | 'timeline.trim'
   | 'timeline.split'
   | 'timeline.remove'
@@ -160,6 +161,7 @@ export interface FreeCutFrameClip {
   trackId: string
   mediaId: string
   linkedGroupId?: string | null
+  rippleLinked?: boolean
   from: number
   durationInFrames: number
   sourceStart?: number
@@ -177,6 +179,7 @@ export interface FreeCutFrameText {
   from: number
   durationInFrames: number
   linkedGroupId?: string | null
+  rippleLinked?: boolean
   text: string
   style?: Record<string, string | number>
   opacity?: number
@@ -190,6 +193,7 @@ export interface FreeCutFrameCaptionCue {
   from: number
   durationInFrames: number
   linkedGroupId?: string | null
+  rippleLinked?: boolean
   text: string
   speaker?: string | null
   style?: CaptionStyle
@@ -483,6 +487,7 @@ export interface EditorHostContextValue {
 
 export interface HostTimelineEditPort {
   requestRippleDelete(itemIds: readonly string[]): Promise<void> | void
+  requestSetItemAttachment?(itemIds: readonly string[], rippleLinked: boolean): Promise<void> | void
 }
 
 export interface EditorHostProviderProps {
@@ -501,6 +506,7 @@ export declare const SUPPORTED_HOST_COMMANDS: readonly [
   'add_clip',
   'add_text',
   'move_item',
+  'set_item_attachment',
   'trim_item',
   'split_item',
   'remove_item',
diff --git a/scripts/fallow-unused-class-members.allowlist.json b/scripts/fallow-unused-class-members.allowlist.json
index 9da914322..a7cf4d483 100644
--- a/scripts/fallow-unused-class-members.allowlist.json
+++ b/scripts/fallow-unused-class-members.allowlist.json
@@ -40,20 +40,10 @@
           "memberName": "getLastFailureKind",
           "kind": "class_method"
         },
-        {
-          "parentName": "VideoFrameExtractor",
-          "memberName": "init",
-          "kind": "class_method"
-        },
         {
           "parentName": "VideoFrameExtractor",
           "memberName": "isBatchPrewarmAvailable",
           "kind": "class_method"
-        },
-        {
-          "parentName": "VideoFrameExtractor",
-          "memberName": "prewarmBatch",
-          "kind": "class_method"
         }
       ]
     },
@@ -339,11 +329,6 @@
           "memberName": "isFrameInRange",
           "kind": "class_method"
         },
-        {
-          "parentName": "Clock",
-          "memberName": "isPlaying",
-          "kind": "class_method"
-        },
         {
           "parentName": "Clock",
           "memberName": "loop",
@@ -365,22 +350,11 @@
           "memberName": "outFrame",
           "kind": "class_method"
         },
-        {
-          "parentName": "Clock",
-          "memberName": "playbackRate",
-          "kind": "class_method",
-          "count": 2
-        },
         {
           "parentName": "Clock",
           "memberName": "seekToTime",
           "kind": "class_method"
         },
-        {
-          "parentName": "Clock",
-          "memberName": "setAudioContext",
-          "kind": "class_method"
-        },
         {
           "parentName": "Clock",
           "memberName": "setInPoint",
diff --git a/scripts/fallow-unused-exports.allowlist.json b/scripts/fallow-unused-exports.allowlist.json
index 6edcc961b..5bab86b97 100644
--- a/scripts/fallow-unused-exports.allowlist.json
+++ b/scripts/fallow-unused-exports.allowlist.json
@@ -245,16 +245,6 @@
       "exportName": "createAudioBuffer",
       "reason": "Called through the canvas-audio namespace from export rendering."
     },
-    {
-      "path": "src/features/export/utils/canvas-audio.ts",
-      "exportName": "hasAudioContent",
-      "reason": "Called through the canvas-audio namespace from export rendering."
-    },
-    {
-      "path": "src/features/export/utils/canvas-render-orchestrator.ts",
-      "exportName": "renderSingleFrame",
-      "reason": "Dynamically imported by thumbnail and timeline persistence flows."
-    },
     {
       "path": "src/features/keyframes/utils/easing-presets.ts",
       "exportName": "areBezierPointsEqual",
@@ -305,21 +295,11 @@
       "exportName": "PARAKEET_MODEL",
       "reason": "unreviewed: carried over by the 2026-07-09 re-baseline; trace individually before deleting."
     },
-    {
-      "path": "src/features/media-library/transcription/transcription-engine.ts",
-      "exportName": "PARAKEET_SUPPORTED_LANGUAGES",
-      "reason": "unreviewed: carried over by the 2026-07-09 re-baseline; trace individually before deleting."
-    },
     {
       "path": "src/features/preview/components/color-scopes-monitor.tsx",
       "exportName": "ColorScopesMonitor",
       "reason": "Lazy-loaded from the preview area."
     },
-    {
-      "path": "src/features/preview/components/inline-source-preview.tsx",
-      "exportName": "InlineSourcePreview",
-      "reason": "Lazy-loaded from the preview area."
-    },
     {
       "path": "src/features/preview/deps/media-library-contract.ts",
       "exportName": "cleanupBlobUrls",
diff --git a/src/features/editor/codepress/README.md b/src/features/editor/codepress/README.md
index 492ffabcb..0e3b32124 100644
--- a/src/features/editor/codepress/README.md
+++ b/src/features/editor/codepress/README.md
@@ -64,6 +64,12 @@ frame timestamp.
 
 ## Ripple and captions
 
+Timeline items carry optional `ripple_linked` attachment metadata; missing means
+attached for compatibility, while `false` is a durable break. `move_item` may
+carry `ripple: true` to ask the authority to resolve the forward touching chain
+from one anchor. `set_item_attachment` changes the break explicitly and keeps
+the A/V `linked_group_id` cohort concept separate.
+
 `ripple_delete` operates on `[start_us, end_us)` in the selected tracks (or all
 tracks for `track_ids: null`). Downstream items shift left by the exact frame
 delta, with each shifted endpoint re-encoded from its resulting frame index.
diff --git a/src/features/editor/codepress/adapter.test.ts b/src/features/editor/codepress/adapter.test.ts
index 4747732cb..d38ae6d14 100644
--- a/src/features/editor/codepress/adapter.test.ts
+++ b/src/features/editor/codepress/adapter.test.ts
@@ -152,6 +152,24 @@ describe('PR1 conformance fixtures', () => {
     })
   })
 
+  it('rejects a non-boolean ripple move intent', () => {
+    const fixture = readFixture<ValidFixture>('valid/core-edit-batch.json')
+    const request = structuredClone(fixture.request) as unknown as Record<string, unknown>
+    request.commands = [
+      {
+        command_id: 'invalid-ripple-move',
+        type: 'move_item',
+        item_id: 'clip-a',
+        to_track_id: 'track-video',
+        timeline_start_us: 1_000_000,
+        index: 0,
+        ripple: 'true',
+      },
+    ]
+
+    expect(validateCommandBatch(request).ok).toBe(false)
+  })
+
   it.each(['errors/revision-conflict.json', 'errors/idempotency-conflict.json'])(
     'keeps the canonical structured error shape for %s',
     (path) => {
@@ -180,6 +198,71 @@ describe('deterministic microsecond/frame conversion', () => {
     expect(() => assertFrameAligned(33_334, 30)).toThrow(FrameTimingError)
   })
 
+  it('keeps ripple-moved touching clips frame-aligned across rounded endpoints', () => {
+    const frame = (value: number) => framesToMicroseconds(value, 30)
+    const items = [
+      clip({
+        item_id: 'clip-one',
+        timeline_start_us: frame(10),
+        timeline_end_us: frame(50),
+      }),
+      clip({
+        item_id: 'clip-two',
+        timeline_start_us: frame(50),
+        timeline_end_us: frame(90),
+      }),
+      clip({
+        item_id: 'clip-three',
+        timeline_start_us: frame(90),
+        timeline_end_us: frame(130),
+      }),
+    ]
+    const adapter = new CodePressCommandAdapter({
+      document: documentFor(
+        timeline({
+          duration_us: frame(180),
+          tracks: [
+            {
+              track_id: 'track-video',
+              kind: 'video',
+              name: 'Video',
+              locked: false,
+              muted: false,
+              items,
+            },
+          ],
+        }),
+      ),
+    })
+
+    const result = applyRequest(adapter, {
+      contract_version: 1,
+      timeline_id: 'timeline-test',
+      operation_id: 'frame-aligned-ripple-move',
+      idempotency_key: 'frame-aligned-ripple-move:1',
+      base_revision: 0,
+      preconditions: [],
+      commands: [
+        {
+          command_id: 'move-attached-chain',
+          type: 'move_item',
+          item_id: 'clip-one',
+          to_track_id: 'track-video',
+          timeline_start_us: frame(26),
+          index: 0,
+          ripple: true,
+        },
+      ],
+    })
+
+    expect(result.timeline.tracks[0]?.items).toMatchObject([
+      { item_id: 'clip-one', timeline_start_us: frame(26), timeline_end_us: frame(66) },
+      { item_id: 'clip-two', timeline_start_us: frame(66), timeline_end_us: frame(106) },
+      { item_id: 'clip-three', timeline_start_us: frame(106), timeline_end_us: frame(146) },
+    ])
+    expect(validateTimelineState(result.timeline).ok).toBe(true)
+  })
+
   it('translates every public timestamp in a batch before application', () => {
     const fixture = readFixture<ValidFixture>('valid/core-edit-batch.json')
     const translated = translateCommandBatchToFrames(fixture.request, 30)
diff --git a/src/features/editor/codepress/attached-chain.ts b/src/features/editor/codepress/attached-chain.ts
new file mode 100644
index 000000000..b4151ab82
--- /dev/null
+++ b/src/features/editor/codepress/attached-chain.ts
@@ -0,0 +1,67 @@
+import type { TimelineItem, TimelineState } from './contract'
+
+function itemId(item: TimelineItem): string {
+  return item.item_type === 'caption_cue' ? item.cue_id : item.item_id
+}
+
+function start(item: TimelineItem): number {
+  return item.item_type === 'caption_cue' ? item.start_us : item.timeline_start_us
+}
+
+function end(item: TimelineItem): number {
+  return item.item_type === 'caption_cue' ? item.end_us : item.timeline_end_us
+}
+
+function attached(item: TimelineItem): boolean {
+  return item.ripple_linked !== false
+}
+
+function enqueueLinkedCohort(
+  items: readonly TimelineItem[],
+  current: TimelineItem,
+  seen: ReadonlySet<string>,
+  queue: TimelineItem[],
+): void {
+  if (current.item_type === 'caption_cue' || !current.linked_group_id) return
+  for (const cohort of items) {
+    if (cohort.linked_group_id === current.linked_group_id && !seen.has(itemId(cohort)))
+      queue.push(cohort)
+  }
+}
+
+function findTouchingAttachedItem(
+  items: readonly TimelineItem[],
+  current: TimelineItem,
+): TimelineItem | undefined {
+  const currentId = itemId(current)
+  return items.find(
+    (candidate) =>
+      candidate.track_id === current.track_id &&
+      itemId(candidate) !== currentId &&
+      start(candidate) === end(current) &&
+      attached(candidate),
+  )
+}
+
+/** Neutral-wire counterpart of the frame-native attachment resolver. */
+export function resolveAttachedChainIds(timeline: TimelineState, anchorId: string): string[] {
+  const items = timeline.tracks.flatMap((track) => track.items)
+  const byId = new Map(items.map((item) => [itemId(item), item]))
+  const anchor = byId.get(anchorId)
+  if (!anchor) return []
+  const result: string[] = []
+  const seen = new Set<string>()
+  const queue: TimelineItem[] = [anchor]
+  while (queue.length) {
+    const current = queue.shift()!
+    const currentId = itemId(current)
+    if (seen.has(currentId)) continue
+    seen.add(currentId)
+    result.push(currentId)
+    enqueueLinkedCohort(items, current, seen, queue)
+    if (!attached(current)) continue
+    const next = findTouchingAttachedItem(items, current)
+    if (next && !seen.has(itemId(next))) queue.push(next)
+  }
+  return result
+}
diff --git a/src/features/editor/codepress/contract.ts b/src/features/editor/codepress/contract.ts
index de7c97fb3..f3f1a1271 100644
--- a/src/features/editor/codepress/contract.ts
+++ b/src/features/editor/codepress/contract.ts
@@ -128,6 +128,8 @@ export interface ClipItem {
   source_end_us: Microseconds
   /** Stable identity for an atomically linked media/caption cohort. */
   linked_group_id?: string | null
+  /** Sequence attachment; omitted is attached, false is a detached break. */
+  ripple_linked?: boolean
   transform?: Transform
   opacity?: number
   volume?: number
@@ -149,6 +151,7 @@ export interface TextItem {
   text: string
   /** Reserved for host-authored synchronized text cohorts. */
   linked_group_id?: string | null
+  ripple_linked?: boolean
   style?: TextStyle
   transform?: Transform
   opacity?: number
@@ -164,6 +167,7 @@ export interface CaptionCue {
   text: string
   /** Stable identity when a caption is part of a linked edit cohort. */
   linked_group_id?: string | null
+  ripple_linked?: boolean
   speaker?: string | null
   style?: CaptionStyle
 }
@@ -236,6 +240,13 @@ export interface MoveItemCommand {
   to_track_id: TrackId
   timeline_start_us: Microseconds
   index: number
+  ripple?: boolean
+}
+export interface SetItemAttachmentCommand {
+  command_id: CommandId
+  type: 'set_item_attachment'
+  item_ids: readonly TimelineItemId[]
+  ripple_linked: boolean
 }
 export interface TrimItemCommand {
   command_id: CommandId
@@ -381,6 +392,7 @@ export type EditCommand =
   | DuplicateItemCommand
   | RemoveItemCommand
   | MoveItemCommand
+  | SetItemAttachmentCommand
   | TrimItemCommand
   | SplitItemCommand
   | RippleDeleteCommand
@@ -433,6 +445,8 @@ export function itemIdFromCommand(command: EditCommand): TimelineItemId | null {
     case 'split_item':
     case 'set_item_properties':
       return command.item_id
+    case 'set_item_attachment':
+      return command.item_ids[0] ?? null
     case 'upsert_caption_cues':
       return command.cues[0]?.cue_id ?? null
     case 'remove_caption_cues':
@@ -460,6 +474,7 @@ export function isTimelineItemCommand(
   | SetCaptionStyleCommand
   | RequestJobCommand
   | RippleDeleteCommand
+  | SetItemAttachmentCommand
 > {
   return itemIdFromCommand(command) !== null
 }
@@ -831,6 +846,20 @@ function checkArray(value: unknown, path: string, errors: VideoCommandError[]):
   return true
 }
 
+function checkUniqueIdentifiers(
+  values: readonly unknown[],
+  path: string,
+  errors: VideoCommandError[],
+): void {
+  const ids = new Set<string>()
+  for (const [index, id] of values.entries()) {
+    const itemPath = `${path}[${index}]`
+    if (!checkIdentifier(id, itemPath, errors)) continue
+    if (ids.has(id)) errors.push(invalidRequest(itemPath, 'must be unique'))
+    ids.add(id)
+  }
+}
+
 function checkTrackKind(value: unknown): value is TrackKind {
   return typeof value === 'string' && (TRACK_KINDS as readonly string[]).includes(value)
 }
@@ -1162,6 +1191,16 @@ function validateCommand(value: unknown, path: string, errors: VideoCommandError
       checkIdentifier(value.to_track_id, `${path}.to_track_id`, errors)
       checkMicroseconds(value.timeline_start_us, `${path}.timeline_start_us`, errors)
       checkIndex(value.index, `${path}.index`, errors)
+      if (value.ripple !== undefined && typeof value.ripple !== 'boolean')
+        errors.push(invalidRequest(`${path}.ripple`, 'must be a boolean'))
+      break
+    case 'set_item_attachment':
+      if (!checkArray(value.item_ids, `${path}.item_ids`, errors)) return
+      if (value.item_ids.length === 0)
+        errors.push(invalidRequest(`${path}.item_ids`, 'must not be empty'))
+      checkUniqueIdentifiers(value.item_ids, `${path}.item_ids`, errors)
+      if (typeof value.ripple_linked !== 'boolean')
+        errors.push(invalidRequest(`${path}.ripple_linked`, 'must be a boolean'))
       break
     case 'trim_item':
       checkIdentifier(value.item_id, `${path}.item_id`, errors)
@@ -1183,16 +1222,8 @@ function validateCommand(value: unknown, path: string, errors: VideoCommandError
       checkInterval(value.start_us, value.end_us, path, errors)
       if (value.track_ids !== null && !checkArray(value.track_ids, `${path}.track_ids`, errors))
         return
-      if (Array.isArray(value.track_ids)) {
-        const ids = new Set<string>()
-        for (const [index, id] of value.track_ids.entries()) {
-          if (checkIdentifier(id, `${path}.track_ids[${index}]`, errors)) {
-            if (ids.has(id))
-              errors.push(invalidRequest(`${path}.track_ids[${index}]`, 'must be unique'))
-            ids.add(id)
-          }
-        }
-      }
+      if (Array.isArray(value.track_ids))
+        checkUniqueIdentifiers(value.track_ids, `${path}.track_ids`, errors)
       break
     case 'add_track':
       checkIndex(value.index, `${path}.index`, errors)
@@ -1291,16 +1322,8 @@ function validateCommand(value: unknown, path: string, errors: VideoCommandError
       break
     case 'remove_caption_cues':
       checkIdentifier(value.track_id, `${path}.track_id`, errors)
-      if (checkArray(value.cue_ids, `${path}.cue_ids`, errors)) {
-        const ids = new Set<string>()
-        for (const [index, id] of value.cue_ids.entries()) {
-          if (checkIdentifier(id, `${path}.cue_ids[${index}]`, errors)) {
-            if (ids.has(id))
-              errors.push(invalidRequest(`${path}.cue_ids[${index}]`, 'must be unique'))
-            ids.add(id)
-          }
-        }
-      }
+      if (checkArray(value.cue_ids, `${path}.cue_ids`, errors))
+        checkUniqueIdentifiers(value.cue_ids, `${path}.cue_ids`, errors)
       break
     case 'set_item_properties':
       checkIdentifier(value.item_id, `${path}.item_id`, errors)
diff --git a/src/features/editor/codepress/document.ts b/src/features/editor/codepress/document.ts
index e538e9d19..815873e45 100644
--- a/src/features/editor/codepress/document.ts
+++ b/src/features/editor/codepress/document.ts
@@ -22,6 +22,7 @@ export interface FreeCutFrameClip {
   trackId: string
   mediaId: string
   linkedGroupId?: string | null
+  rippleLinked?: boolean
   from: number
   durationInFrames: number
   sourceStart?: number
@@ -39,6 +40,7 @@ export interface FreeCutFrameText {
   from: number
   durationInFrames: number
   linkedGroupId?: string | null
+  rippleLinked?: boolean
   text: string
   style?: Record<string, string | number>
   opacity?: number
@@ -52,6 +54,7 @@ export interface FreeCutFrameCaptionCue {
   from: number
   durationInFrames: number
   linkedGroupId?: string | null
+  rippleLinked?: boolean
   text: string
   speaker?: string | null
   style?: CaptionStyle
@@ -124,6 +127,7 @@ function toContractItem(item: FreeCutFrameItem, fps: FrameRateLike): TimelineIte
       end_us: range.end_us,
       text: item.text,
       ...(item.linkedGroupId !== undefined ? { linked_group_id: item.linkedGroupId } : {}),
+      ...(item.rippleLinked !== undefined ? { ripple_linked: item.rippleLinked } : {}),
       ...(item.speaker !== undefined ? { speaker: item.speaker } : {}),
       ...(item.style !== undefined ? { style: { ...item.style } } : {}),
     }
@@ -137,6 +141,7 @@ function toContractItem(item: FreeCutFrameItem, fps: FrameRateLike): TimelineIte
       timeline_end_us: range.end_us,
       text: item.text,
       ...(item.linkedGroupId !== undefined ? { linked_group_id: item.linkedGroupId } : {}),
+      ...(item.rippleLinked !== undefined ? { ripple_linked: item.rippleLinked } : {}),
       ...(item.style
         ? {
             style: {
@@ -184,6 +189,7 @@ function toContractItem(item: FreeCutFrameItem, fps: FrameRateLike): TimelineIte
     source_start_us: framesToMicroseconds(sourceStart, fps),
     source_end_us: framesToMicroseconds(sourceEnd, fps),
     ...(item.linkedGroupId !== undefined ? { linked_group_id: item.linkedGroupId } : {}),
+    ...(item.rippleLinked !== undefined ? { ripple_linked: item.rippleLinked } : {}),
     ...(item.volume !== undefined ? { volume: item.volume } : {}),
     ...(item.speed !== undefined ? { speed: item.speed } : {}),
     ...(item.opacity !== undefined ? { opacity: item.opacity } : {}),
@@ -292,6 +298,7 @@ function fromContractItem(item: TimelineItem, fps: FrameRateLike): FreeCutFrameI
       durationInFrames: range.end - range.start,
       text: item.text,
       ...(item.linked_group_id !== undefined ? { linkedGroupId: item.linked_group_id } : {}),
+      ...(item.ripple_linked !== undefined ? { rippleLinked: item.ripple_linked } : {}),
       ...(item.speaker !== undefined ? { speaker: item.speaker } : {}),
       ...(item.style !== undefined ? { style: { ...item.style } } : {}),
     }
@@ -311,6 +318,7 @@ function fromContractItem(item: TimelineItem, fps: FrameRateLike): FreeCutFrameI
       durationInFrames: range.end - range.start,
       text: item.text,
       ...(item.linked_group_id !== undefined ? { linkedGroupId: item.linked_group_id } : {}),
+      ...(item.ripple_linked !== undefined ? { rippleLinked: item.ripple_linked } : {}),
       ...(item.style ? { style: { ...item.style } } : {}),
       ...(item.opacity !== undefined ? { opacity: item.opacity } : {}),
       ...(item.transform ? { transform: fromTransform(item.transform) } : {}),
@@ -338,6 +346,7 @@ function fromContractItem(item: TimelineItem, fps: FrameRateLike): FreeCutFrameI
     sourceStart: sourceRange.start,
     sourceEnd: sourceRange.end,
     ...(item.linked_group_id !== undefined ? { linkedGroupId: item.linked_group_id } : {}),
+    ...(item.ripple_linked !== undefined ? { rippleLinked: item.ripple_linked } : {}),
     ...(item.volume !== undefined ? { volume: item.volume } : {}),
     ...(item.speed !== undefined ? { speed: item.speed } : {}),
     ...(item.opacity !== undefined ? { opacity: item.opacity } : {}),
diff --git a/src/features/editor/codepress/edit-engine.ts b/src/features/editor/codepress/edit-engine.ts
index dc49a5dcd..0c6a3b9d1 100644
--- a/src/features/editor/codepress/edit-engine.ts
+++ b/src/features/editor/codepress/edit-engine.ts
@@ -25,6 +25,7 @@ import type {
 } from './contract'
 import { MAX_ID_LENGTH, validateTimelineState } from './contract'
 import type { ControlledEditEngine, EditEngineContext, EditEngineResult } from './interfaces'
+import { resolveAttachedChainIds } from './attached-chain'
 
 export class EditEngineError extends Error {
   readonly code:
@@ -215,6 +216,11 @@ function setItemFramePosition(
   )
 }
 
+function moveItemToFrame(item: TimelineItem, startFrame: number, fps: FrameRateLike): TimelineItem {
+  const range = frameRangeFor(item, fps)
+  return setItemFramePosition(item, startFrame, startFrame + range.end - range.start, fps)
+}
+
 function shiftItemByFrames(
   item: TimelineItem,
   deltaFrames: number,
@@ -378,6 +384,7 @@ function applyAddText(timeline: MutableTimeline, command: AddTextCommand): Comma
 function applyDuplicate(
   timeline: MutableTimeline,
   command: Extract<EditCommand, { type: 'duplicate_item' }>,
+  fps: FrameRateLike,
 ): CommandEffect {
   const source = findItem(timeline, command.item_id, command.command_id).item
   const target = findTrack(timeline, command.to_track_id, command.command_id)
@@ -385,11 +392,7 @@ function applyDuplicate(
   const duplicate = cloneItem(source)
   const sourceStart = itemStart(source)
   const targetStart = command.timeline_start_us ?? sourceStart
-  const shifted = setItemPosition(
-    duplicate,
-    targetStart,
-    targetStart + (itemEnd(source) - sourceStart),
-  )
+  const shifted = moveItemToFrame(duplicate, assertFrameAligned(targetStart, fps), fps)
   const withId =
     shifted.item_type === 'caption_cue'
       ? { ...shifted, cue_id: command.new_item_id, track_id: target.track_id }
@@ -413,15 +416,40 @@ function applyRemoveItem(
   return { ...emptyEffect(), deleted_item_ids: [command.item_id] }
 }
 
-function applyMoveItem(timeline: MutableTimeline, command: MoveItemCommand): CommandEffect {
+function applyMoveItem(
+  timeline: MutableTimeline,
+  command: MoveItemCommand,
+  fps: FrameRateLike,
+): CommandEffect {
   const located = findItem(timeline, command.item_id, command.command_id)
   const target = findTrack(timeline, command.to_track_id, command.command_id)
   ensureTrackCompatibility(target, located.item, command.command_id)
-  const oldStart = itemStart(located.item)
-  const moved = setItemPosition(
+  if (command.ripple) {
+    const chainIds = resolveAttachedChainIds(timeline, command.item_id)
+    const anchorStartFrame = frameRangeFor(located.item, fps).start
+    const targetStartFrame = assertFrameAligned(command.timeline_start_us, fps)
+    const deltaFrames = targetStartFrame - anchorStartFrame
+    const moved = applyMoveItem(timeline, { ...command, ripple: undefined }, fps)
+    for (const id of chainIds) {
+      if (id === command.item_id) continue
+      const member = findItem(timeline, id, command.command_id)
+      const range = frameRangeFor(member.item, fps)
+      setItemAt(
+        timeline,
+        member,
+        setItemFramePosition(member.item, range.start + deltaFrames, range.end + deltaFrames, fps),
+      )
+    }
+    return {
+      ...moved,
+      moved_item_ids: chainIds,
+      updated_item_ids: chainIds,
+    }
+  }
+  const moved = moveItemToFrame(
     setItemTrack(located.item, target.track_id),
-    command.timeline_start_us,
-    command.timeline_start_us + itemEnd(located.item) - oldStart,
+    assertFrameAligned(command.timeline_start_us, fps),
+    fps,
   )
   const sourceTrack = timeline.tracks[located.trackIndex]!
   const sourceItems = sourceTrack.items.filter((_, index) => index !== located.itemIndex)
@@ -436,6 +464,31 @@ function applyMoveItem(timeline: MutableTimeline, command: MoveItemCommand): Com
   }
 }
 
+function applySetItemAttachment(
+  timeline: MutableTimeline,
+  command: Extract<EditCommand, { type: 'set_item_attachment' }>,
+): CommandEffect {
+  const requested = new Set(command.item_ids)
+  const updated: string[] = []
+  for (const track of timeline.tracks) {
+    const items = track.items.map((item) => {
+      const id = itemId(item)
+      if (!requested.has(id)) return item
+      if (item.ripple_linked === command.ripple_linked) return item
+      updated.push(id)
+      return { ...item, ripple_linked: command.ripple_linked }
+    })
+    replaceTrackItems(timeline, timeline.tracks.indexOf(track), items)
+  }
+  if (updated.length !== requested.size)
+    throw new EditEngineError(
+      'unknown_item',
+      'One or more attachment items do not exist',
+      command.command_id,
+    )
+  return { ...emptyEffect(), updated_item_ids: updated }
+}
+
 function applyTrim(
   timeline: MutableTimeline,
   command: Extract<EditCommand, { type: 'trim_item' }>,
@@ -832,12 +885,14 @@ function applyCommand(
     case 'duplicate_item':
       if (command.timeline_start_us !== undefined)
         assertFrameAligned(command.timeline_start_us, fps)
-      return applyDuplicate(timeline, command)
+      return applyDuplicate(timeline, command, fps)
     case 'remove_item':
       return applyRemoveItem(timeline, command)
     case 'move_item':
       assertFrameAligned(command.timeline_start_us, fps)
-      return applyMoveItem(timeline, command)
+      return applyMoveItem(timeline, command, fps)
+    case 'set_item_attachment':
+      return applySetItemAttachment(timeline, command)
     case 'trim_item':
       assertFrameAligned(command.timeline_us, fps)
       assertFrameAligned(command.source_us, fps)
diff --git a/src/features/editor/codepress/translation.ts b/src/features/editor/codepress/translation.ts
index 005182921..02ab3ecd3 100644
--- a/src/features/editor/codepress/translation.ts
+++ b/src/features/editor/codepress/translation.ts
@@ -79,6 +79,7 @@ export type FrameEditCommand =
       timeline_start_frame?: Frame
     })
   | Extract<EditCommand, { type: 'remove_item' }>
+  | Extract<EditCommand, { type: 'set_item_attachment' }>
   | (Omit<Extract<EditCommand, { type: 'move_item' }>, 'timeline_start_us'> & {
       timeline_start_frame: Frame
     })
@@ -177,6 +178,7 @@ function itemToFrames(item: TimelineItem, fps: FrameRateLike): FrameItem {
       cue_id: item.cue_id,
       track_id: item.track_id,
       text: item.text,
+      ...(item.ripple_linked !== undefined ? { ripple_linked: item.ripple_linked } : {}),
       ...(item.speaker !== undefined ? { speaker: item.speaker } : {}),
       ...(item.style !== undefined ? { style: item.style } : {}),
       start_frame: assertFrameAligned(item.start_us, fps),
@@ -189,6 +191,7 @@ function itemToFrames(item: TimelineItem, fps: FrameRateLike): FrameItem {
       item_id: item.item_id,
       track_id: item.track_id,
       text: item.text,
+      ...(item.ripple_linked !== undefined ? { ripple_linked: item.ripple_linked } : {}),
       ...(item.style !== undefined ? { style: item.style } : {}),
       ...(item.transform !== undefined ? { transform: item.transform } : {}),
       ...(item.opacity !== undefined ? { opacity: item.opacity } : {}),
@@ -203,6 +206,7 @@ function itemToFrames(item: TimelineItem, fps: FrameRateLike): FrameItem {
     track_id: item.track_id,
     media_id: item.media_id,
     media_kind: item.media_kind,
+    ...(item.ripple_linked !== undefined ? { ripple_linked: item.ripple_linked } : {}),
     ...(item.transform !== undefined ? { transform: item.transform } : {}),
     ...(item.opacity !== undefined ? { opacity: item.opacity } : {}),
     ...(item.volume !== undefined ? { volume: item.volume } : {}),
@@ -270,6 +274,8 @@ export function translateCommandToFrames(
       }
     case 'remove_item':
       return command
+    case 'set_item_attachment':
+      return command
     case 'move_item':
       return {
         ...command,
diff --git a/src/features/editor/components/properties-sidebar/clip-panel/text-section.tsx b/src/features/editor/components/properties-sidebar/clip-panel/text-section.tsx
index a82449a76..ab8360eb6 100644
--- a/src/features/editor/components/properties-sidebar/clip-panel/text-section.tsx
+++ b/src/features/editor/components/properties-sidebar/clip-panel/text-section.tsx
@@ -287,11 +287,6 @@ export function TextStyleSection(props: TextSectionProps) {
   return <TextSectionComposer {...props} slots={['effects']} />
 }
 
-/** Motion-text animation on its own — the Animation tab. */
-export function TextAnimationSection(props: TextSectionProps) {
-  return <TextSectionComposer {...props} slots={['animation']} />
-}
-
 /**
  * Style + animation together — used only for mixed (text + non-text)
  * selections, which keep the general Effects-tab layout.
diff --git a/src/features/editor/deps/timeline-motion-contract.ts b/src/features/editor/deps/timeline-motion-contract.ts
index c3ae993e1..2abd96382 100644
--- a/src/features/editor/deps/timeline-motion-contract.ts
+++ b/src/features/editor/deps/timeline-motion-contract.ts
@@ -13,7 +13,6 @@ export {
   KEYFRAME_DIAMOND_RENDERED_WIDTH_PX,
   ROW_HEIGHT,
   getAnimatablePropertiesForItem,
-  getEffectPropertyBaseValue,
   getProceduralBands,
   getPropertyAccordionGroups,
   getPropertyDisplayGroups,
diff --git a/src/features/editor/host/context.ts b/src/features/editor/host/context.ts
index 45e3d7ff8..389cc080e 100644
--- a/src/features/editor/host/context.ts
+++ b/src/features/editor/host/context.ts
@@ -10,6 +10,10 @@ import {
 export interface HostTimelineEditPort {
   /** Ask the host authority to ripple-delete the selected timeline anchors. */
   requestRippleDelete(itemIds: readonly string[]): Promise<void> | void
+  requestSetItemAttachment?: (
+    itemIds: readonly string[],
+    rippleLinked: boolean,
+  ) => Promise<void> | void
 }
 
 export interface EditorHostContextValue {
diff --git a/src/features/editor/host/contract.ts b/src/features/editor/host/contract.ts
index 294dcc9aa..747e4ad85 100644
--- a/src/features/editor/host/contract.ts
+++ b/src/features/editor/host/contract.ts
@@ -25,6 +25,7 @@ export type EditorCapability =
   | 'media.relink'
   | 'timeline.add'
   | 'timeline.move'
+  | 'timeline.attachment'
   | 'timeline.trim'
   | 'timeline.split'
   | 'timeline.remove'
@@ -50,6 +51,7 @@ export const DEFAULT_HOST_CAPABILITIES: EditorCapabilityMap = {
   'media.relink': false,
   'timeline.add': true,
   'timeline.move': true,
+  'timeline.attachment': true,
   'timeline.trim': true,
   'timeline.split': true,
   'timeline.remove': true,
@@ -383,6 +385,7 @@ export const SUPPORTED_HOST_COMMANDS = [
   'add_clip',
   'add_text',
   'move_item',
+  'set_item_attachment',
   'trim_item',
   'split_item',
   'remove_item',
@@ -404,6 +407,8 @@ export function capabilityForCommand(command: EditCommand['type']): EditorCapabi
       return 'timeline.add'
     case 'move_item':
       return 'timeline.move'
+    case 'set_item_attachment':
+      return 'timeline.attachment'
     case 'trim_item':
       return 'timeline.trim'
     case 'split_item':
diff --git a/src/features/editor/host/controller.test.ts b/src/features/editor/host/controller.test.ts
index 0e20ede10..06f9ba7d8 100644
--- a/src/features/editor/host/controller.test.ts
+++ b/src/features/editor/host/controller.test.ts
@@ -190,6 +190,23 @@ describe('embedded FreeCut host controller', () => {
     })
   })
 
+  it('floors sourceDuration at the clip source range when asset duration is unprobed', () => {
+    const initial = snapshot()
+    // Cloud/AI assets sit at durationSeconds 0 until the probe job lands. The
+    // native item must not get a 1-frame sourceDuration: the trim clamp would
+    // turn any end-extend drag into a collapse toward 1 frame.
+    const unprobed = {
+      ...initial,
+      assets: [{ ...initial.assets[0]!, durationSeconds: 0 }],
+    }
+    const native = hostSnapshotToNativeTimeline(unprobed)
+    expect(native.items[0]).toMatchObject({
+      sourceStart: 0,
+      sourceEnd: 60,
+      sourceDuration: 60,
+    })
+  })
+
   it('keeps caption styles and caption-role items on the host-backed native bridge', () => {
     const initial = snapshot({
       tracks: [
@@ -330,6 +347,44 @@ describe('embedded FreeCut host controller', () => {
     expect(derived.batch?.commands[0]).toMatchObject({ type: 'move_item', item_id: 'text-1' })
   })
 
+  it('preserves detached regular text through native host reconciliation', () => {
+    const initial = snapshot({
+      tracks: [
+        {
+          id: 'text-track',
+          kind: 'overlay',
+          name: 'Text',
+          locked: false,
+          muted: false,
+          items: [
+            {
+              type: 'text',
+              id: 'detached-text',
+              trackId: 'text-track',
+              from: 150,
+              durationInFrames: 30,
+              text: 'Detached tail',
+              rippleLinked: false,
+            },
+          ],
+        },
+      ],
+    })
+    const native = hostSnapshotToNativeTimeline(initial)
+    const reconciled = nativeTimelineToFrameDocument(
+      { tracks: native.tracks, items: native.items, fps: native.fps },
+      initial.timeline,
+    )
+
+    expect(reconciled).toMatchObject({ ok: true })
+    if (!reconciled.ok) return
+    expect(reconciled.document.tracks[0]?.items[0]).toMatchObject({ rippleLinked: false })
+    expect(deriveSupportedHostEdit(initial.timeline, reconciled.document)).toEqual({
+      batch: null,
+      reason: NO_SUPPORTED_EDIT_REASON,
+    })
+  })
+
   it.each([
     ['null', null],
     ['absent', undefined],
@@ -698,6 +753,7 @@ describe('embedded FreeCut host controller', () => {
       'add_clip',
       'add_text',
       'move_item',
+      'set_item_attachment',
       'trim_item',
       'split_item',
       'remove_item',
@@ -721,6 +777,24 @@ describe('embedded FreeCut host controller', () => {
     expect(adapter.capabilities).toEqual({})
   })
 
+  it('derives attachment toggles as one command with item preconditions', () => {
+    const initial = snapshot()
+    const track = initial.timeline.tracks[0]!
+    const next = {
+      ...initial.timeline,
+      tracks: [{ ...track, items: [{ ...track.items[0]!, rippleLinked: false }] }],
+    }
+    const derived = deriveSupportedHostEdit(initial.timeline, next)
+    expect(derived.batch?.commands).toEqual([
+      expect.objectContaining({
+        type: 'set_item_attachment',
+        item_ids: ['clip-1'],
+        ripple_linked: false,
+      }),
+    ])
+    expect(derived.batch?.preconditions).toHaveLength(1)
+  })
+
   describe('host round-trip stability', () => {
     async function flushReconcile(): Promise<void> {
       for (let i = 0; i < 10; i += 1) {
@@ -1278,13 +1352,9 @@ describe('embedded FreeCut host controller', () => {
 
       const derived = deriveSupportedHostEdit(initial.timeline, next)
 
-      expect(derived.batch).toBeNull()
-      expect(derived.reason).toMatch(/^Multiple or ambiguous timeline changes are unsupported\b/)
-      expect(derived.reason).toContain('added 0, removed 0, changed 2')
-      expect(derived.detail).toEqual({
-        code: 'ambiguous_change',
-        changeCounts: { added: 0, removed: 0, changed: 2 },
-      })
+      expect(derived.batch?.commands).toEqual([
+        expect.objectContaining({ type: 'move_item', item_id: 'clip-1', ripple: true }),
+      ])
     })
 
     it('derives a move_item command for a store drag of a clip carrying an identity transform', async () => {
diff --git a/src/features/editor/host/controller.ts b/src/features/editor/host/controller.ts
index a32ec7a9d..91f8c171c 100644
--- a/src/features/editor/host/controller.ts
+++ b/src/features/editor/host/controller.ts
@@ -67,6 +67,48 @@ function isFrameClip(item: FreeCutFrameItem): item is FrameClip {
   return item.type === 'video' || item.type === 'audio' || item.type === 'image'
 }
 
+function frameItemAttached(item: FreeCutFrameItem): boolean {
+  return item.rippleLinked !== false
+}
+
+function frameAttachedChain(document: FreeCutFrameDocument, anchorId: string): string[] {
+  const items = document.tracks.flatMap((track) => track.items)
+  const byId = new Map(items.map((item) => [item.id, item]))
+  const anchor = byId.get(anchorId)
+  if (!anchor) return []
+  const result: string[] = []
+  const seen = new Set<string>()
+  const queue: FreeCutFrameItem[] = [anchor]
+  while (queue.length) {
+    const current = queue.shift()!
+    if (seen.has(current.id)) continue
+    seen.add(current.id)
+    result.push(current.id)
+    for (const cohort of items.filter(
+      (candidate) => candidate.linkedGroupId && candidate.linkedGroupId === current.linkedGroupId,
+    )) {
+      if (!seen.has(cohort.id)) queue.push(cohort)
+    }
+    if (!frameItemAttached(current)) continue
+    const end = current.from + current.durationInFrames
+    const next = items.find(
+      (candidate) =>
+        candidate.trackId === current.trackId &&
+        candidate.id !== current.id &&
+        candidate.from === end &&
+        frameItemAttached(candidate),
+    )
+    if (next && !seen.has(next.id)) queue.push(next)
+  }
+  return result
+}
+
+function withoutAttachment(item: FreeCutFrameItem): unknown {
+  const copy = { ...item } as Record<string, unknown>
+  delete copy.rippleLinked
+  return copy
+}
+
 /**
  * The concrete source window of a clip that states none: a clip with no
  * source range plays from the start of its media for its timeline duration.
@@ -480,6 +522,53 @@ export function deriveRippleDelete(
   }
 }
 
+function deriveSetItemAttachment(
+  previous: FreeCutFrameDocument,
+  itemIds: readonly string[],
+  rippleLinked: boolean,
+  options: { operationId?: string; idempotencyKey?: string } = {},
+): DerivedHostEdit {
+  const ids = [...new Set(itemIds)]
+  const items = itemMap(previous)
+  if (ids.length === 0) return { batch: null, reason: 'No timeline item is selected' }
+  const selected = ids.map((id) => items.get(id))
+  if (selected.some((item) => item === undefined)) {
+    return { batch: null, reason: 'The selected timeline item is no longer authoritative' }
+  }
+  const trackById = new Map(previous.tracks.map((track) => [track.id, track]))
+  const isTrackLocked = (trackId: string, visited = new Set<string>()): boolean => {
+    if (visited.has(trackId)) return true
+    visited.add(trackId)
+    const track = trackById.get(trackId)
+    return (
+      !!track?.locked || (!!track?.parentTrackId && isTrackLocked(track.parentTrackId, visited))
+    )
+  }
+  if (selected.some((item) => isTrackLocked(item!.trackId))) {
+    return { batch: null, reason: 'Cannot change attachment on a locked track' }
+  }
+  const operationId = options.operationId ?? `op-${crypto.randomUUID()}`
+  const idempotencyKey = options.idempotencyKey ?? `idem-${crypto.randomUUID()}`
+  return {
+    batch: {
+      contract_version: 1,
+      timeline_id: previous.timelineId,
+      operation_id: operationId,
+      idempotency_key: idempotencyKey,
+      base_revision: previous.revision,
+      preconditions: selected.map((item) => preconditionForItem(item!, previous.fps)),
+      commands: [
+        {
+          command_id: `attachment-${operationId}`,
+          type: 'set_item_attachment',
+          item_ids: ids,
+          ripple_linked: rippleLinked,
+        },
+      ],
+    },
+  }
+}
+
 /**
  * Derive one bounded command batch from the real editor's frame-native store
  * change.  Ambiguous or unsupported changes fail closed instead of being
@@ -519,7 +608,30 @@ export function deriveSupportedHostEdit(
     preconditions.push({ type: 'track_absent', track_id: track.id })
   }
 
-  if (removed.length === 0 && added.length === 0 && changed.length === 0) {
+  const attachmentOnlyChange =
+    removed.length === 0 &&
+    added.length === 0 &&
+    changed.length > 0 &&
+    changed.every((id) => {
+      const before = previousItems.get(id)
+      const after = nextItems.get(id)
+      return (
+        before !== undefined &&
+        after !== undefined &&
+        before.rippleLinked !== after.rippleLinked &&
+        stableSerialize(withoutAttachment(before)) === stableSerialize(withoutAttachment(after))
+      )
+    })
+
+  if (attachmentOnlyChange) {
+    commands.push({
+      command_id: `attachment-${operationId}`,
+      type: 'set_item_attachment',
+      item_ids: changed,
+      ripple_linked: nextItems.get(changed[0]!)!.rippleLinked !== false,
+    })
+    for (const id of changed) preconditions.push(preconditionForItem(previousItems.get(id)!, fps))
+  } else if (removed.length === 0 && added.length === 0 && changed.length === 0) {
     // Any track creation is already represented by the add_track commands
     // above.  With no tracks added either, nothing changed at all: `commands`
     // stays empty and the caller gets the silent "No supported edit was
@@ -603,124 +715,163 @@ export function deriveSupportedHostEdit(
     })
     preconditions.push(preconditionForItem(before, fps))
   } else if (removed.length === 0 && added.length === 0 && changed.length > 1) {
-    // Host mode defaults contiguous trims to ripple edits. The native store
-    // applies that as one trimmed clip plus uniformly shifted downstream
-    // clips, so recognize the full gesture and serialize it as one command
-    // batch instead of restoring the authoritative snapshot as ambiguous.
-    const trimIds = changed.filter((id) => {
+    const movedOnly = changed.every((id) => {
       const before = previousItems.get(id)!
       const after = nextItems.get(id)!
-      if (before.type === 'caption_cue' || after.type === 'caption_cue') return false
       const facts = itemChangeFacts(before, after)
       return (
         facts.metadataUnchanged &&
         facts.transformUnchanged &&
-        facts.sameTrack &&
-        (!facts.sourceUnchanged || !facts.durationUnchanged)
+        facts.sourceUnchanged &&
+        facts.durationUnchanged &&
+        !facts.timelineUnchanged
       )
     })
-    const trimId = trimIds.length === 1 ? trimIds[0] : null
-    const beforeTrim = trimId ? previousItems.get(trimId) : null
-    const afterTrim = trimId ? nextItems.get(trimId) : null
-    const shift =
-      beforeTrim && afterTrim ? afterTrim.durationInFrames - beforeTrim.durationInFrames : 0
-    const oldTrimEnd = beforeTrim ? beforeTrim.from + beforeTrim.durationInFrames : 0
-    const movedIds = trimId ? changed.filter((id) => id !== trimId) : []
-    const isUniformContiguousRipple =
-      !!trimId &&
-      !!beforeTrim &&
-      !!afterTrim &&
-      isFrameClip(beforeTrim) &&
-      isFrameClip(afterTrim) &&
-      shift !== 0 &&
-      movedIds.length > 0 &&
-      movedIds.every((id) => {
+    const movedAnchor = movedOnly
+      ? changed
+          .map((id) => previousItems.get(id)!)
+          .sort((left, right) => left.from - right.from || left.id.localeCompare(right.id))[0]
+      : undefined
+    const chainIds = movedAnchor ? frameAttachedChain(previous, movedAnchor.id) : []
+    if (
+      movedOnly &&
+      movedAnchor &&
+      chainIds.length === changed.length &&
+      new Set(chainIds).size === changed.length
+    ) {
+      const afterAnchor = nextItems.get(movedAnchor.id)!
+      const location = itemLocation(next, movedAnchor.id)
+      if (!location) return { batch: null, reason: 'A rippled item no longer has a track' }
+      commands.push({
+        command_id: `move-${movedAnchor.id}`,
+        type: 'move_item',
+        item_id: movedAnchor.id,
+        to_track_id: afterAnchor.trackId,
+        timeline_start_us: framesToMicroseconds(afterAnchor.from, fps),
+        index: location.index,
+        ripple: true,
+      })
+      for (const id of changed) preconditions.push(preconditionForItem(previousItems.get(id)!, fps))
+    } else {
+      // Host mode defaults contiguous trims to ripple edits. The native store
+      // applies that as one trimmed clip plus uniformly shifted downstream
+      // clips, so recognize the full gesture and serialize it as one command
+      // batch instead of restoring the authoritative snapshot as ambiguous.
+      const trimIds = changed.filter((id) => {
         const before = previousItems.get(id)!
         const after = nextItems.get(id)!
+        if (before.type === 'caption_cue' || after.type === 'caption_cue') return false
         const facts = itemChangeFacts(before, after)
         return (
           facts.metadataUnchanged &&
           facts.transformUnchanged &&
-          facts.sourceUnchanged &&
-          facts.durationUnchanged &&
-          !facts.timelineUnchanged &&
           facts.sameTrack &&
-          before.trackId === beforeTrim.trackId &&
-          before.from >= oldTrimEnd &&
-          after.from - before.from === shift
+          (!facts.sourceUnchanged || !facts.durationUnchanged)
         )
       })
+      const trimId = trimIds.length === 1 ? trimIds[0] : null
+      const beforeTrim = trimId ? previousItems.get(trimId) : null
+      const afterTrim = trimId ? nextItems.get(trimId) : null
+      const shift =
+        beforeTrim && afterTrim ? afterTrim.durationInFrames - beforeTrim.durationInFrames : 0
+      const oldTrimEnd = beforeTrim ? beforeTrim.from + beforeTrim.durationInFrames : 0
+      const movedIds = trimId ? changed.filter((id) => id !== trimId) : []
+      const isUniformContiguousRipple =
+        !!trimId &&
+        !!beforeTrim &&
+        !!afterTrim &&
+        isFrameClip(beforeTrim) &&
+        isFrameClip(afterTrim) &&
+        shift !== 0 &&
+        movedIds.length > 0 &&
+        movedIds.every((id) => {
+          const before = previousItems.get(id)!
+          const after = nextItems.get(id)!
+          const facts = itemChangeFacts(before, after)
+          return (
+            facts.metadataUnchanged &&
+            facts.transformUnchanged &&
+            facts.sourceUnchanged &&
+            facts.durationUnchanged &&
+            !facts.timelineUnchanged &&
+            facts.sameTrack &&
+            before.trackId === beforeTrim.trackId &&
+            before.from >= oldTrimEnd &&
+            after.from - before.from === shift
+          )
+        })
 
-    if (!isUniformContiguousRipple || !trimId || !beforeTrim || !afterTrim) {
-      const detail: HostEditRejectionDetail = {
-        code: 'ambiguous_change',
-        changeCounts: { added: added.length, removed: removed.length, changed: changed.length },
+      if (!isUniformContiguousRipple || !trimId || !beforeTrim || !afterTrim) {
+        const detail: HostEditRejectionDetail = {
+          code: 'ambiguous_change',
+          changeCounts: { added: added.length, removed: removed.length, changed: changed.length },
+        }
+        return {
+          batch: null,
+          reason: `Multiple or ambiguous timeline changes are unsupported${describeRejection(detail)}`,
+          detail,
+        }
       }
-      return {
-        batch: null,
-        reason: `Multiple or ambiguous timeline changes are unsupported${describeRejection(detail)}`,
-        detail,
-      }
-    }
 
-    const [beforeSourceStart, beforeSourceEnd] = sourceBounds(beforeTrim)
-    const [afterSourceStart, afterSourceEnd] = sourceBounds(afterTrim)
-    const edge =
-      afterTrim.from !== beforeTrim.from ||
-      (afterSourceStart !== beforeSourceStart && afterSourceEnd === beforeSourceEnd)
-        ? 'start'
-        : 'end'
-    const trimTimelineFrame =
-      edge === 'start' ? beforeTrim.from - shift : afterTrim.from + afterTrim.durationInFrames
-    const trimSourceFrame = edge === 'start' ? afterSourceStart : afterSourceEnd
-    const requiredCommands = changed.length + (edge === 'start' ? 1 : 0)
-    if (commands.length + requiredCommands > MAX_COMMANDS_PER_OPERATION) {
-      return {
-        batch: null,
-        reason: `Ripple trim exceeds the ${MAX_COMMANDS_PER_OPERATION}-command host operation limit`,
+      const [beforeSourceStart, beforeSourceEnd] = sourceBounds(beforeTrim)
+      const [afterSourceStart, afterSourceEnd] = sourceBounds(afterTrim)
+      const edge =
+        afterTrim.from !== beforeTrim.from ||
+        (afterSourceStart !== beforeSourceStart && afterSourceEnd === beforeSourceEnd)
+          ? 'start'
+          : 'end'
+      const trimTimelineFrame =
+        edge === 'start' ? beforeTrim.from - shift : afterTrim.from + afterTrim.durationInFrames
+      const trimSourceFrame = edge === 'start' ? afterSourceStart : afterSourceEnd
+      const requiredCommands = changed.length + (edge === 'start' ? 1 : 0)
+      if (commands.length + requiredCommands > MAX_COMMANDS_PER_OPERATION) {
+        return {
+          batch: null,
+          reason: `Ripple trim exceeds the ${MAX_COMMANDS_PER_OPERATION}-command host operation limit`,
+        }
       }
-    }
 
-    commands.push({
-      command_id: `trim-${trimId}`,
-      type: 'trim_item',
-      item_id: trimId,
-      edge,
-      timeline_us: framesToMicroseconds(trimTimelineFrame, fps),
-      source_us: framesToMicroseconds(trimSourceFrame, fps),
-    })
-    preconditions.push(preconditionForItem(beforeTrim, fps))
-
-    // Ripple-start anchors the trimmed item at its original timeline position.
-    // The wire trim moves its leading edge first, then this move restores the
-    // anchor while preserving the newly shortened source/timeline span.
-    if (edge === 'start') {
-      const location = itemLocation(next, trimId)
-      if (!location) return { batch: null, reason: 'The trimmed item no longer has a track' }
       commands.push({
-        command_id: `anchor-${trimId}`,
-        type: 'move_item',
+        command_id: `trim-${trimId}`,
+        type: 'trim_item',
         item_id: trimId,
-        to_track_id: afterTrim.trackId,
-        timeline_start_us: framesToMicroseconds(afterTrim.from, fps),
-        index: location.index,
+        edge,
+        timeline_us: framesToMicroseconds(trimTimelineFrame, fps),
+        source_us: framesToMicroseconds(trimSourceFrame, fps),
       })
-    }
+      preconditions.push(preconditionForItem(beforeTrim, fps))
 
-    for (const id of movedIds) {
-      const before = previousItems.get(id)!
-      const after = nextItems.get(id)!
-      const location = itemLocation(next, id)
-      if (!location) return { batch: null, reason: 'A rippled item no longer has a track' }
-      commands.push({
-        command_id: `move-${id}`,
-        type: 'move_item',
-        item_id: id,
-        to_track_id: after.trackId,
-        timeline_start_us: framesToMicroseconds(after.from, fps),
-        index: location.index,
-      })
-      preconditions.push(preconditionForItem(before, fps))
+      // Ripple-start anchors the trimmed item at its original timeline position.
+      // The wire trim moves its leading edge first, then this move restores the
+      // anchor while preserving the newly shortened source/timeline span.
+      if (edge === 'start') {
+        const location = itemLocation(next, trimId)
+        if (!location) return { batch: null, reason: 'The trimmed item no longer has a track' }
+        commands.push({
+          command_id: `anchor-${trimId}`,
+          type: 'move_item',
+          item_id: trimId,
+          to_track_id: afterTrim.trackId,
+          timeline_start_us: framesToMicroseconds(afterTrim.from, fps),
+          index: location.index,
+        })
+      }
+
+      for (const id of movedIds) {
+        const before = previousItems.get(id)!
+        const after = nextItems.get(id)!
+        const location = itemLocation(next, id)
+        if (!location) return { batch: null, reason: 'A rippled item no longer has a track' }
+        commands.push({
+          command_id: `move-${id}`,
+          type: 'move_item',
+          item_id: id,
+          to_track_id: after.trackId,
+          timeline_start_us: framesToMicroseconds(after.from, fps),
+          index: location.index,
+        })
+        preconditions.push(preconditionForItem(before, fps))
+      }
     }
   } else if (removed.length === 0 && added.length === 0 && changed.length === 1) {
     const id = changed[0]!
@@ -879,6 +1030,25 @@ export class HostEditorController {
     return this.submitEdit(derived.batch)
   }
 
+  async requestSetItemAttachment(
+    itemIds: readonly string[],
+    rippleLinked: boolean,
+  ): Promise<HostControllerResult> {
+    const derived = deriveSetItemAttachment(this.snapshot.timeline, itemIds, rippleLinked)
+    if (!derived.batch) {
+      this.notify({
+        kind: 'unsupported',
+        message: derived.reason ?? 'Attachment change is unavailable',
+      })
+      return {
+        status: 'unsupported',
+        snapshot: this.getSnapshot(),
+        reason: derived.reason ?? 'Attachment change is unavailable',
+      }
+    }
+    return this.submitEdit(derived.batch)
+  }
+
   async submitEdit(batch: EditCommandBatch): Promise<HostControllerResult> {
     const unsupported = batch.commands.find((command) => {
       const capability = capabilityForCommand(command.type)
diff --git a/src/features/editor/host/document.ts b/src/features/editor/host/document.ts
index 2564777cc..6faea0b97 100644
--- a/src/features/editor/host/document.ts
+++ b/src/features/editor/host/document.ts
@@ -25,9 +25,17 @@ export type NativeTimelineConversionResult =
   | { ok: true; document: FreeCutFrameDocument }
   | { ok: false; failure: NativeTimelineConversionFailure }
 
-function safeDurationFrames(asset: EmbeddedEditorAsset, fps: number): number {
-  if (!Number.isFinite(asset.durationSeconds) || asset.durationSeconds <= 0) return 1
-  return Math.max(1, Math.round(asset.durationSeconds * fps))
+function safeDurationFrames(asset: EmbeddedEditorAsset, fps: number, sourceEnd?: number): number {
+  const probed =
+    Number.isFinite(asset.durationSeconds) && asset.durationSeconds > 0
+      ? Math.max(1, Math.round(asset.durationSeconds * fps))
+      : 1
+  // Never let the bound undercut the source range the clip already occupies:
+  // an unprobed (or bogus-tiny) asset duration would otherwise surface as a
+  // 1-frame sourceDuration, and the trim clamp turns any end-extend drag on
+  // such a clip into a collapse to 1 frame. Flooring at the in-use range
+  // keeps the clip intact; the handle re-opens once the probe lands.
+  return Math.max(probed, Math.ceil(sourceEnd ?? 0), 1)
 }
 
 // fallow-ignore-next-line complexity
@@ -157,6 +165,7 @@ function nativeItemFromHostItem(
       label: item.text || 'Text',
       text: item.text,
       ...linkedGroupMetadata(item.linkedGroupId),
+      ...(item.rippleLinked !== undefined ? { rippleLinked: item.rippleLinked } : {}),
       color: textColor,
       ...(typeof item.style?.font_family === 'string'
         ? { fontFamily: item.style.font_family }
@@ -184,6 +193,7 @@ function nativeItemFromHostItem(
       text: item.text,
       textRole: 'caption',
       ...linkedGroupMetadata(item.linkedGroupId),
+      ...(item.rippleLinked !== undefined ? { rippleLinked: item.rippleLinked } : {}),
       color: style?.color ?? '#ffffff',
       ...(typeof style?.font_family === 'string' ? { fontFamily: style.font_family } : {}),
       ...(typeof style?.font_size === 'number' ? { fontSize: style.font_size } : {}),
@@ -202,7 +212,9 @@ function nativeItemFromHostItem(
   }
 
   const asset = assets.get(item.mediaId)
-  const sourceDuration = asset ? safeDurationFrames(asset, asset.fps || 30) : undefined
+  const sourceDuration = asset
+    ? safeDurationFrames(asset, asset.fps || 30, item.sourceEnd)
+    : undefined
   const common = {
     id: item.id,
     trackId: item.trackId,
@@ -212,6 +224,7 @@ function nativeItemFromHostItem(
     mediaId: item.mediaId,
     src: '',
     ...linkedGroupMetadata(item.linkedGroupId),
+    ...(item.rippleLinked !== undefined ? { rippleLinked: item.rippleLinked } : {}),
     ...(sourceDuration !== undefined ? { sourceDuration } : {}),
     // Carry the host's source range through exactly as stated, absence
     // included.  A native item with no `sourceStart` plays from source frame
@@ -289,6 +302,7 @@ function frameItemToNativeComparable(
       sourceStart: item.sourceStart,
       sourceEnd: item.sourceEnd,
       ...linkedGroupMetadata(item.linkedGroupId),
+      ...(item.rippleLinked !== undefined ? { rippleLinked: item.rippleLinked } : {}),
       // Optional fields are emitted only when set so the comparable shape
       // matches host snapshots that omit them entirely.
       ...(item.volume !== undefined ? { volume: item.volume } : {}),
@@ -317,6 +331,7 @@ function frameItemToNativeComparable(
       durationInFrames: item.durationInFrames,
       text: item.text,
       ...linkedGroupMetadata(item.linkedGroupId),
+      ...(item.rippleLinked !== undefined ? { rippleLinked: item.rippleLinked } : {}),
       ...(Object.keys(style).length > 0 ? { style } : {}),
     }
   }
@@ -338,6 +353,7 @@ function frameItemToNativeComparable(
       durationInFrames: item.durationInFrames,
       text: item.text,
       ...linkedGroupMetadata(item.linkedGroupId),
+      ...(item.rippleLinked !== undefined ? { rippleLinked: item.rippleLinked } : {}),
       ...(Object.keys(style).length > 0 ? { style } : {}),
       ...(opacityOnly ? { opacity: transform.opacity } : {}),
       ...(transform !== undefined && !opacityOnly ? { transform } : {}),
diff --git a/src/features/editor/host/editor-surface.tsx b/src/features/editor/host/editor-surface.tsx
index 85785f493..be5aae1fb 100644
--- a/src/features/editor/host/editor-surface.tsx
+++ b/src/features/editor/host/editor-surface.tsx
@@ -126,7 +126,11 @@ export function FreeCutEditorSurface({ host }: { host: EditorHost }) {
             mode: 'host',
             capabilities,
             host,
-            timeline: { requestRippleDelete: state.runtime.requestRippleDelete },
+            timeline: {
+              requestRippleDelete: state.runtime.requestRippleDelete,
+              requestSetItemAttachment: (itemIds, rippleLinked) =>
+                state.runtime.requestSetItemAttachment(itemIds, rippleLinked),
+            },
           }}
         >
           <HostCaptionEditorProvider runtime={state.runtime}>
diff --git a/src/features/editor/host/runtime.ts b/src/features/editor/host/runtime.ts
index 1128616ee..b59871659 100644
--- a/src/features/editor/host/runtime.ts
+++ b/src/features/editor/host/runtime.ts
@@ -107,6 +107,19 @@ export class EmbeddedEditorHostRuntime implements EmbeddedEditorHostRuntimeContr
     }
   }
 
+  // Passed through EditorHostProvider and invoked by timeline item actions.
+  // fallow-ignore-next-line unused-class-member
+  async requestSetItemAttachment(itemIds: readonly string[], rippleLinked: boolean): Promise<void> {
+    try {
+      await this.controller.requestSetItemAttachment(itemIds, rippleLinked)
+    } catch (error) {
+      this.host.notify?.({
+        kind: 'error',
+        message: error instanceof Error ? error.message : 'Attachment change submission failed',
+      })
+    }
+  }
+
   /**
    * The host serves cross-origin media URLs, which rules out the Web Audio
    * clip graph (non-CORS cross-origin resources are silenced through
diff --git a/src/features/keyframes/deps/timeline-contract.ts b/src/features/keyframes/deps/timeline-contract.ts
index 9b3d1a884..493196078 100644
--- a/src/features/keyframes/deps/timeline-contract.ts
+++ b/src/features/keyframes/deps/timeline-contract.ts
@@ -7,7 +7,3 @@ export { useTimelineStore } from '@/features/timeline/stores/timeline-store'
 export { useItemsStore } from '@/features/timeline/stores/items-store'
 export { useKeyframesStore } from '@/features/timeline/stores/keyframes-store'
 export { useTransitionsStore } from '@/features/timeline/stores/transitions-store'
-export {
-  getEdgeScrollDelta,
-  getPlayheadEdgeScrollVelocity,
-} from '@/features/timeline/utils/playhead-edge-scroll'
diff --git a/src/features/media-library/components/media-library.tsx b/src/features/media-library/components/media-library.tsx
index 4bc935d72..5056c59f9 100644
--- a/src/features/media-library/components/media-library.tsx
+++ b/src/features/media-library/components/media-library.tsx
@@ -820,6 +820,7 @@ export const MediaLibrary = memo(function MediaLibrary({ onMediaSelect }: MediaL
                   <button
                     onClick={handleDeleteSelected}
                     disabled={!canDeleteMedia}
+                    aria-label={t('media.library.deleteSelectedAssets')}
                     className="flex items-center gap-1.5 h-7 px-2.5 rounded-md shrink-0
                       bg-destructive/10 border border-destructive/25 text-destructive
                       hover:bg-destructive/20 hover:border-destructive/40
diff --git a/src/features/preview/utils/mouse-drag-intent.ts b/src/features/preview/utils/mouse-drag-intent.ts
index ec2b29a34..d147d2e6b 100644
--- a/src/features/preview/utils/mouse-drag-intent.ts
+++ b/src/features/preview/utils/mouse-drag-intent.ts
@@ -17,7 +17,7 @@ interface MouseDragIntentOptions {
  * Runs a callback only after the pointer moves far enough to represent a drag.
  * A click or mouse-up without movement remains passive.
  */
-export function notifyOnMouseDragIntent(
+function notifyOnMouseDragIntent(
   start: MouseDragIntentStart,
   onDragIntent: () => void,
   options: MouseDragIntentOptions = {},
diff --git a/src/features/project-bundle/schemas/project-schema.ts b/src/features/project-bundle/schemas/project-schema.ts
index 64f877cd0..383acabf3 100644
--- a/src/features/project-bundle/schemas/project-schema.ts
+++ b/src/features/project-bundle/schemas/project-schema.ts
@@ -461,6 +461,7 @@ const timelineItemSchema = z
     mediaId: z.string().optional(),
     originId: z.string().optional(),
     linkedGroupId: z.string().optional(),
+    rippleLinked: z.boolean().optional(),
     type: itemTypeSchema,
     // Source fields
     src: z.string().optional(),
diff --git a/src/features/timeline/components/timeline-item/index.tsx b/src/features/timeline/components/timeline-item/index.tsx
index 2a8dfe158..a047ab1d4 100644
--- a/src/features/timeline/components/timeline-item/index.tsx
+++ b/src/features/timeline/components/timeline-item/index.tsx
@@ -726,6 +726,7 @@ export const TimelineItem = memo(function TimelineItem({
     handleJoinRight,
     handleDelete,
     handleRippleDelete,
+    handleToggleAttachment,
     handleLinkSelected,
     handleUnlinkSelected,
     handleReverseSelected,
@@ -993,6 +994,10 @@ export const TimelineItem = memo(function TimelineItem({
           onRippleDelete: handleRippleDelete,
           onDelete: handleDelete,
         }}
+        attachmentActions={{
+          isRippleLinked: item.rippleLinked !== false,
+          onToggle: handleToggleAttachment,
+        }}
       >
         <div
           ref={transformRef}
diff --git a/src/features/timeline/components/timeline-item/item-context-menu.test.tsx b/src/features/timeline/components/timeline-item/item-context-menu.test.tsx
index 59d059add..e7781e984 100644
--- a/src/features/timeline/components/timeline-item/item-context-menu.test.tsx
+++ b/src/features/timeline/components/timeline-item/item-context-menu.test.tsx
@@ -1,6 +1,6 @@
 import type { ComponentProps, ReactNode } from 'react'
 import { beforeEach, describe, expect, it, vi } from 'vite-plus/test'
-import { fireEvent, render, screen } from '@testing-library/react'
+import { cleanup, fireEvent, render, screen } from '@testing-library/react'
 import { useSelectionStore } from '@/shared/state/selection'
 import { ItemContextMenu } from './item-context-menu'
 import { EditorHostProvider } from '../../deps/editor'
@@ -171,6 +171,22 @@ describe('ItemContextMenu scene detection', () => {
   })
 })
 
+describe('ItemContextMenu sequence attachment', () => {
+  it('offers detach and reattach toggles', () => {
+    const onToggle = vi.fn()
+    renderContextMenu({ attachmentActions: { isRippleLinked: true, onToggle } })
+    fireEvent.click(screen.getByRole('button', { name: 'Detach from sequence' }))
+    expect(onToggle).toHaveBeenCalledTimes(1)
+    cleanup()
+
+    // The menu stays mounted after activation; rerendering is represented by
+    // the same component contract with the detached state.
+    renderContextMenu({ attachmentActions: { isRippleLinked: false, onToggle } })
+    fireEvent.click(screen.getByRole('button', { name: 'Reattach to sequence' }))
+    expect(onToggle).toHaveBeenCalledTimes(2)
+  })
+})
+
 describe('ItemContextMenu captions', () => {
   it('shows a single "Generate Captions" item when no transcript exists', () => {
     const onOpenCaptionDialog = vi.fn()
diff --git a/src/features/timeline/components/timeline-item/item-context-menu.tsx b/src/features/timeline/components/timeline-item/item-context-menu.tsx
index 9c82b05ee..295cb0966 100644
--- a/src/features/timeline/components/timeline-item/item-context-menu.tsx
+++ b/src/features/timeline/components/timeline-item/item-context-menu.tsx
@@ -117,12 +117,18 @@ type DestructiveActionsProps = ItemContextMenuSectionProps & {
   onDelete: () => void
 }
 
+type AttachmentActionsProps = ItemContextMenuSectionProps & {
+  isRippleLinked: boolean
+  onToggle: () => void
+}
+
 type JoinActionsConfig = Omit<JoinActionsProps, keyof ItemContextMenuSectionProps>
 type LinkActionsConfig = Omit<LinkActionsProps, keyof ItemContextMenuSectionProps>
 type MediaActionsConfig = Omit<MediaActionsProps, keyof ItemContextMenuSectionProps>
 type CaptionActionsConfig = Omit<CaptionActionsProps, keyof ItemContextMenuSectionProps>
 type CompositionActionsConfig = Omit<CompositionActionsProps, keyof ItemContextMenuSectionProps>
 type DestructiveActionsConfig = Omit<DestructiveActionsProps, keyof ItemContextMenuSectionProps>
+type AttachmentActionsConfig = Omit<AttachmentActionsProps, keyof ItemContextMenuSectionProps>
 
 type KeyframeActionsConfig = Omit<
   KeyframeActionsProps,
@@ -145,6 +151,7 @@ interface ItemContextMenuProps {
   trackLocked: boolean
   joinActions: JoinActionsConfig
   destructiveActions: DestructiveActionsConfig
+  attachmentActions?: AttachmentActionsConfig
   linkActions?: LinkActionsConfig
   keyframeActions?: KeyframeActionsConfig
   layoutActions?: LayoutActionsConfig
@@ -168,6 +175,7 @@ export const ItemContextMenu = memo(function ItemContextMenu({
   trackLocked,
   joinActions,
   destructiveActions,
+  attachmentActions,
   linkActions,
   keyframeActions,
   layoutActions,
@@ -202,6 +210,7 @@ export const ItemContextMenu = memo(function ItemContextMenu({
       trackLocked={trackLocked}
       joinActions={joinActions}
       destructiveActions={destructiveActions}
+      attachmentActions={attachmentActions}
       linkActions={linkActions}
       keyframeActions={keyframeActions}
       layoutActions={layoutActions}
@@ -254,6 +263,7 @@ const ItemContextMenuFull = memo(function ItemContextMenuFull({
   trackLocked,
   joinActions,
   destructiveActions,
+  attachmentActions,
   linkActions,
   keyframeActions,
   layoutActions,
@@ -343,6 +353,13 @@ const ItemContextMenuFull = memo(function ItemContextMenuFull({
           canRippleDelete={!hostMode}
           canDelete={canDeleteItem}
         />
+        {attachmentActions && (
+          <ContextMenuItem onClick={attachmentActions.onToggle}>
+            {attachmentActions.isRippleLinked
+              ? t('timeline.contextMenu.detachFromSequence', 'Detach from sequence')
+              : t('timeline.contextMenu.reattachToSequence', 'Reattach to sequence')}
+          </ContextMenuItem>
+        )}
       </ContextMenuContent>
     </ContextMenu>
   )
diff --git a/src/features/timeline/components/timeline-item/join-indicators.tsx b/src/features/timeline/components/timeline-item/join-indicators.tsx
index db1a6fa41..46c97036f 100644
--- a/src/features/timeline/components/timeline-item/join-indicators.tsx
+++ b/src/features/timeline/components/timeline-item/join-indicators.tsx
@@ -57,7 +57,7 @@ export const ZoomGatedJoinIndicators = memo(function ZoomGatedJoinIndicators(
  * Join indicators for timeline items
  * Shows glowing edges when clips can be joined with neighbors
  */
-export const JoinIndicators = memo(function JoinIndicators({
+const JoinIndicators = memo(function JoinIndicators({
   hasJoinableLeft,
   hasJoinableRight,
   trackLocked,
diff --git a/src/features/timeline/components/timeline-item/use-timeline-item-actions.ts b/src/features/timeline/components/timeline-item/use-timeline-item-actions.ts
index 54a042a38..1fa39df0e 100644
--- a/src/features/timeline/components/timeline-item/use-timeline-item-actions.ts
+++ b/src/features/timeline/components/timeline-item/use-timeline-item-actions.ts
@@ -59,6 +59,7 @@ import {
   DEFAULT_FILLER_REMOVAL_SETTINGS,
 } from '../../utils/filler-word-removal-preview'
 import { mapSceneCutTimesToTimelineFrames } from '../../utils/scene-cut-frames'
+import { setItemAttachment } from '../../stores/actions/item-actions'
 
 const logger = createLogger('UseTimelineItemActions')
 
@@ -175,6 +176,19 @@ export function useTimelineItemActions({
     }
   }, [])
 
+  const handleToggleAttachment = useCallback(() => {
+    const selectedItemIds = useSelectionStore.getState().selectedItemIds
+    const ids = selectedItemIds.length > 0 ? selectedItemIds : [item.id]
+    const nextValue = item.rippleLinked === false
+    if (editorMode === 'host') {
+      if (hostTimeline?.requestSetItemAttachment)
+        void hostTimeline.requestSetItemAttachment(ids, nextValue)
+      else host?.notify?.({ kind: 'unsupported', message: 'Attachment changes are unavailable' })
+      return
+    }
+    setItemAttachment(ids, nextValue)
+  }, [editorMode, host, hostTimeline, item.id, item.rippleLinked])
+
   const handleLinkSelected = useCallback(() => {
     const selectedItemIds = useSelectionStore.getState().selectedItemIds
     void linkItems(selectedItemIds)
@@ -607,6 +621,7 @@ export function useTimelineItemActions({
     handleJoinRight,
     handleDelete,
     handleRippleDelete,
+    handleToggleAttachment,
     handleLinkSelected,
     handleUnlinkSelected,
     handleReverseSelected,
diff --git a/src/features/timeline/hooks/use-timeline-drag.ts b/src/features/timeline/hooks/use-timeline-drag.ts
index d450d8595..fe89e27de 100644
--- a/src/features/timeline/hooks/use-timeline-drag.ts
+++ b/src/features/timeline/hooks/use-timeline-drag.ts
@@ -34,6 +34,7 @@ import { createLogger } from '@/shared/logging/logger'
 import { createRafCoalescedCallback } from '../utils/raf-coalesced-callback'
 import { resolveEffectiveTrackStates } from '../utils/group-utils'
 import { suppressPostTimelineGestureClick } from '../components/timeline-item/post-drag-click-guard'
+import { resolveAttachedChain } from '../utils/attached-chain'
 
 const logger = createLogger('TimelineDrag')
 
@@ -542,7 +543,8 @@ function resolveDraggedItemStates(
       ? expandSelectionWithLinkedItems(allItems, currentSelectedIds)
       : currentSelectedIds
     : linkedIds
-  const itemsToDrag = expandItemIdsWithAttachedCaptions(allItems, baseItemsToDrag)
+  const attachedBaseIds = baseItemsToDrag.flatMap((id) => resolveAttachedChain(allItems, id))
+  const itemsToDrag = expandItemIdsWithAttachedCaptions(allItems, [...new Set(attachedBaseIds)])
   const unlockedItemIds = filterUnlockedItemIds(
     allItems,
     resolveEffectiveTrackStates(currentTracks),
diff --git a/src/features/timeline/hooks/use-timeline-trim.ts b/src/features/timeline/hooks/use-timeline-trim.ts
index 2ca8a3016..f08282a3b 100644
--- a/src/features/timeline/hooks/use-timeline-trim.ts
+++ b/src/features/timeline/hooks/use-timeline-trim.ts
@@ -55,6 +55,7 @@ import {
 } from '../utils/trim-edit-constraints'
 import { getTransitionBridgeAtHandle } from '../utils/transition-edit-guards'
 import { createRafCoalescedCallback } from '../utils/raf-coalesced-callback'
+import { resolveAttachedRippleTail } from '../utils/attached-chain'
 
 interface TrimState {
   isTrimming: boolean
@@ -105,12 +106,14 @@ function getRippleDownstreamItemIds(
 ): Set<string> {
   const currentEnd = currentItem.from + currentItem.durationInFrames
   const downstreamItemIds = new Set<string>()
+  const attachedIds = new Set(resolveAttachedRippleTail(allItems, currentItem.id))
 
   for (const other of allItems) {
     if (
       other.id !== currentItem.id &&
       other.trackId === currentItem.trackId &&
-      other.from >= currentEnd
+      other.from >= currentEnd &&
+      attachedIds.has(other.id)
     ) {
       downstreamItemIds.add(other.id)
     }
diff --git a/src/features/timeline/stores/actions/edit/trim-actions.ts b/src/features/timeline/stores/actions/edit/trim-actions.ts
index 2951217d6..4b21a251e 100644
--- a/src/features/timeline/stores/actions/edit/trim-actions.ts
+++ b/src/features/timeline/stores/actions/edit/trim-actions.ts
@@ -38,6 +38,7 @@ import {
   requestPostEditWarmForItems,
 } from './shared'
 import type { TimelineItem, TimelineTrack } from '@/types/timeline'
+import { resolveAttachedRippleTail } from '../../../utils/attached-chain'
 
 function keepTightestDelta(requested: number, candidate: number): number {
   return requested < 0 ? Math.max(requested, candidate) : Math.min(requested, candidate)
@@ -230,6 +231,9 @@ function addRippleTrimDownstreamMutationIds(params: {
   mutationIds: Set<string>
 }): void {
   const transitions = useTransitionsStore.getState().transitions
+  const attachedIds = new Set(
+    params.synced.flatMap((syncedItem) => resolveAttachedRippleTail(params.items, syncedItem.id)),
+  )
   for (const syncedItem of params.synced) {
     const oldSyncedEnd = syncedItem.from + syncedItem.durationInFrames
     const transitionNeighbors = new Set(
@@ -239,7 +243,10 @@ function addRippleTrimDownstreamMutationIds(params: {
     )
     for (const candidate of params.items) {
       if (params.syncedIds.has(candidate.id) || candidate.trackId !== syncedItem.trackId) continue
-      if (candidate.from >= oldSyncedEnd || transitionNeighbors.has(candidate.id)) {
+      if (
+        attachedIds.has(candidate.id) &&
+        (candidate.from >= oldSyncedEnd || transitionNeighbors.has(candidate.id))
+      ) {
         params.mutationIds.add(candidate.id)
       }
     }
@@ -702,6 +709,9 @@ export function rippleTrimItem(id: string, handle: 'start' | 'end', trimDelta: n
       if (clampedTrimDelta === 0) return
       const oldFrom = item.from
       const oldEnd = item.from + item.durationInFrames
+      const attachedIds = new Set(
+        synced.flatMap((syncedItem) => resolveAttachedRippleTail(store.items, syncedItem.id)),
+      )
       if (handle === 'start')
         store._trimItemStart(id, clampedTrimDelta, { skipAdjacentClamp: true })
       else store._trimItemEnd(id, clampedTrimDelta, { skipAdjacentClamp: true })
@@ -749,7 +759,12 @@ export function rippleTrimItem(id: string, handle: 'start' | 'end', trimDelta: n
             if (transition.leftClipId === syncedItem.id) neighbors.add(transition.rightClipId)
           }
           for (const candidate of fresh) {
-            if (syncedIds.has(candidate.id) || candidate.trackId !== before.trackId) continue
+            if (
+              syncedIds.has(candidate.id) ||
+              candidate.trackId !== before.trackId ||
+              !attachedIds.has(candidate.id)
+            )
+              continue
             if (candidate.from >= oldSyncedEnd || neighbors.has(candidate.id))
               deltas.set(candidate.id, shift)
           }
diff --git a/src/features/timeline/stores/actions/item-actions.ts b/src/features/timeline/stores/actions/item-actions.ts
index 245cea6b4..3332c3f9d 100644
--- a/src/features/timeline/stores/actions/item-actions.ts
+++ b/src/features/timeline/stores/actions/item-actions.ts
@@ -56,6 +56,7 @@ import {
   isTimelineTrackLocked,
   partitionItemMutationIdsByLock,
 } from '../../utils/track-lock-invariants'
+import { resolveAttachedChain, resolveAttachedRippleTail } from '../../utils/attached-chain'
 
 const LOCK_PROTECTED_ITEM_FIELDS = new Set([
   'from',
@@ -118,6 +119,34 @@ function areMoveUpdatesUnlocked(
   )
 }
 
+function expandMoveUpdatesWithAttachedChain(
+  updates: Array<{ id: string; from: number; trackId?: string }>,
+): Array<{ id: string; from: number; trackId?: string }> {
+  const items = useItemsStore.getState().items
+  const byId = new Map(items.map((item) => [item.id, item]))
+  const result = new Map<string, { id: string; from: number; trackId?: string }>()
+  for (const update of updates) {
+    const anchor = byId.get(update.id)
+    if (!anchor) continue
+    const delta = update.from - anchor.from
+    for (const id of resolveAttachedChain(items, update.id)) {
+      const attached = byId.get(id)
+      if (!attached || result.has(id)) continue
+      result.set(id, {
+        id,
+        from: attached.from + delta,
+        ...(id === update.id && update.trackId ? { trackId: update.trackId } : {}),
+      })
+    }
+  }
+  for (const update of updates) {
+    // Explicit cohort/selection assignments (including destination tracks)
+    // always win over an implicit attachment expansion.
+    result.set(update.id, { ...update, from: update.from })
+  }
+  return [...result.values()]
+}
+
 function pruneLayerGroupsAfterItemRemoval(): void {
   const store = useItemsStore.getState()
   const nextTracks = pruneEmptyLayerGroupHierarchy(store.tracks, store.items)
@@ -1041,7 +1070,12 @@ function buildBaseRippleShifts(
   for (const item of remainingItems) {
     let shiftAmount = 0
     for (const deletedItem of deletedItems) {
+      const chainIds = resolveAttachedRippleTail(
+        [...remainingItems, ...deletedItems],
+        deletedItem.id,
+      )
       if (
+        chainIds.includes(item.id) &&
         deletedItem.trackId === item.trackId &&
         deletedItem.from + deletedItem.durationInFrames <= item.from
       ) {
@@ -1371,32 +1405,36 @@ export function trackPushItems(anchorId: string, delta: number): void {
 export function moveItem(id: string, newFrom: number, newTrackId?: string): void {
   const item = useItemsStore.getState().itemById[id]
   if (!item) return
-  if (!areMoveUpdatesUnlocked([{ id, from: newFrom, trackId: newTrackId }])) return
+  const expandedUpdates = expandMoveUpdatesWithAttachedChain([
+    { id, from: newFrom, trackId: newTrackId },
+  ])
+  if (!areMoveUpdatesUnlocked(expandedUpdates)) return
 
   execute(
     'MOVE_ITEM',
     () => {
-      useItemsStore.getState()._moveItem(id, newFrom, newTrackId)
+      useItemsStore.getState()._moveItems(expandedUpdates)
 
       // Repair transitions
-      applyTransitionRepairs([id])
+      applyTransitionRepairs(expandedUpdates.map((update) => update.id))
 
       useTimelineSettingsStore.getState().markDirty()
       warnIfOverlapping('MOVE_ITEM')
     },
-    { id, newFrom, newTrackId },
+    { id, newFrom, newTrackId, attachedCount: expandedUpdates.length },
   )
 }
 
 export function moveItems(updates: Array<{ id: string; from: number; trackId?: string }>): void {
-  if (!areMoveUpdatesUnlocked(updates)) return
+  const expandedUpdates = expandMoveUpdatesWithAttachedChain(updates)
+  if (!areMoveUpdatesUnlocked(expandedUpdates)) return
 
   execute(
     'MOVE_ITEMS',
     () => {
-      useItemsStore.getState()._moveItems(updates)
+      useItemsStore.getState()._moveItems(expandedUpdates)
 
-      const movedItemIds = new Set(updates.map((u) => u.id))
+      const movedItemIds = new Set(expandedUpdates.map((u) => u.id))
       const items = useItemsStore.getState().items
       const transitions = useTransitionsStore.getState().transitions
 
@@ -1419,12 +1457,12 @@ export function moveItems(updates: Array<{ id: string; from: number; trackId?: s
 
       // Apply updated transitions (with trackId fixes) then repair
       useTransitionsStore.getState().setTransitions(updatedTransitions)
-      applyTransitionRepairs(updates.map((u) => u.id))
+      applyTransitionRepairs(expandedUpdates.map((u) => u.id))
 
       useTimelineSettingsStore.getState().markDirty()
       warnIfOverlapping('MOVE_ITEMS')
     },
-    { count: updates.length },
+    { count: expandedUpdates.length },
   )
 }
 
@@ -1432,15 +1470,16 @@ export function moveItemsWithTrackChanges(
   tracks: TimelineTrack[],
   updates: Array<{ id: string; from: number; trackId?: string }>,
 ): void {
-  if (!areMoveUpdatesUnlocked(updates, tracks)) return
+  const expandedUpdates = expandMoveUpdatesWithAttachedChain(updates)
+  if (!areMoveUpdatesUnlocked(expandedUpdates, tracks)) return
 
   execute(
     'MOVE_ITEMS_WITH_TRACKS',
     () => {
       useItemsStore.getState().setTracks(tracks)
-      useItemsStore.getState()._moveItems(updates)
+      useItemsStore.getState()._moveItems(expandedUpdates)
 
-      const movedItemIds = new Set(updates.map((u) => u.id))
+      const movedItemIds = new Set(expandedUpdates.map((u) => u.id))
       const items = useItemsStore.getState().items
       const transitions = useTransitionsStore.getState().transitions
 
@@ -1460,11 +1499,25 @@ export function moveItemsWithTrackChanges(
       })
 
       useTransitionsStore.getState().setTransitions(updatedTransitions)
-      applyTransitionRepairs(updates.map((u) => u.id))
+      applyTransitionRepairs(expandedUpdates.map((u) => u.id))
       useTimelineSettingsStore.getState().markDirty()
       warnIfOverlapping('MOVE_ITEMS_WITH_TRACKS')
     },
-    { count: updates.length, trackCount: tracks.length },
+    { count: expandedUpdates.length, trackCount: tracks.length },
+  )
+}
+
+export function setItemAttachment(itemIds: readonly string[], rippleLinked: boolean): void {
+  const ids = [...new Set(itemIds)]
+  if (ids.length === 0 || !areItemMutationsUnlocked(ids)) return
+  execute(
+    'SET_ITEM_ATTACHMENT',
+    () => {
+      const store = useItemsStore.getState()
+      for (const id of ids) store._updateItem(id, { rippleLinked })
+      useTimelineSettingsStore.getState().markDirty()
+    },
+    { itemIds: ids, rippleLinked },
   )
 }
 
diff --git a/src/features/timeline/stores/timeline-store-facade.ts b/src/features/timeline/stores/timeline-store-facade.ts
index 4379c0459..e1e2f2429 100644
--- a/src/features/timeline/stores/timeline-store-facade.ts
+++ b/src/features/timeline/stores/timeline-store-facade.ts
@@ -126,6 +126,7 @@ function getSnapshot(): TimelineState & TimelineActions {
       moveItem: timelineActions.moveItem,
       moveItems: timelineActions.moveItems,
       moveItemsWithTrackChanges: timelineActions.moveItemsWithTrackChanges,
+      setItemAttachment: timelineActions.setItemAttachment,
       duplicateItems: timelineActions.duplicateItems,
       duplicateItemsWithTrackChanges: timelineActions.duplicateItemsWithTrackChanges,
       trimItemStart: timelineActions.trimItemStart,
diff --git a/src/features/timeline/types.ts b/src/features/timeline/types.ts
index e4cc36f90..2a4ffeacc 100644
--- a/src/features/timeline/types.ts
+++ b/src/features/timeline/types.ts
@@ -84,6 +84,7 @@ export interface TimelineActions {
     tracks: TimelineTrack[],
     updates: Array<{ id: string; from: number; trackId?: string }>,
   ) => void
+  setItemAttachment: (itemIds: readonly string[], rippleLinked: boolean) => void
   duplicateItems: (itemIds: string[], positions: Array<{ from: number; trackId: string }>) => void
   duplicateItemsWithTrackChanges: (
     tracks: TimelineTrack[],
diff --git a/src/features/timeline/utils/attached-chain.test.ts b/src/features/timeline/utils/attached-chain.test.ts
new file mode 100644
index 000000000..2ef05db10
--- /dev/null
+++ b/src/features/timeline/utils/attached-chain.test.ts
@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vite-plus/test'
+import type { VideoItem } from '@/types/timeline'
+import { buildAttachedMoveUpdates, resolveAttachedChain } from './attached-chain'
+
+function clip(
+  id: string,
+  from: number,
+  durationInFrames: number,
+  options: Partial<VideoItem> = {},
+): VideoItem {
+  return {
+    type: 'video',
+    id,
+    trackId: options.trackId ?? 'v1',
+    from,
+    durationInFrames,
+    label: id,
+    mediaId: id,
+    src: '',
+    ...options,
+  }
+}
+
+describe('attached sequence chains', () => {
+  it('resolves only touching forward items and preserves gaps', () => {
+    const items = [clip('a', 0, 10), clip('b', 10, 5), clip('gap', 20, 5), clip('tail', 25, 5)]
+    expect(resolveAttachedChain(items, 'a')).toEqual(['a', 'b'])
+    expect(buildAttachedMoveUpdates(items, 'a', 4)).toEqual([
+      { id: 'a', from: 4 },
+      { id: 'b', from: 14 },
+    ])
+  })
+
+  it('treats false as a hard break while missing metadata stays attached', () => {
+    const items = [clip('a', 0, 10), clip('b', 10, 5, { rippleLinked: false }), clip('c', 15, 5)]
+    expect(resolveAttachedChain(items, 'a')).toEqual(['a'])
+    expect(resolveAttachedChain(items, 'b')).toEqual(['b'])
+  })
+
+  it('moves linked A/V cohorts with the sequence anchor', () => {
+    const items = [
+      clip('video-a', 0, 10, { linkedGroupId: 'g' }),
+      clip('audio-a', 0, 10, { trackId: 'a1', linkedGroupId: 'g' }),
+      clip('video-b', 10, 5),
+    ]
+    expect(new Set(resolveAttachedChain(items, 'video-a'))).toEqual(
+      new Set(['video-a', 'audio-a', 'video-b']),
+    )
+  })
+})
diff --git a/src/features/timeline/utils/attached-chain.ts b/src/features/timeline/utils/attached-chain.ts
new file mode 100644
index 000000000..7a44bacdc
--- /dev/null
+++ b/src/features/timeline/utils/attached-chain.ts
@@ -0,0 +1,122 @@
+import type { TimelineItem } from '@/types/timeline'
+import { getLinkedItems } from './linked-items'
+
+/** Missing attachment metadata is intentionally attached for compatibility. */
+function isRippleLinked(item: Pick<TimelineItem, 'rippleLinked'>): boolean {
+  return item.rippleLinked !== false
+}
+
+function enqueueIfMissing(item: TimelineItem, included: Set<string>, queue: TimelineItem[]): void {
+  if (included.has(item.id)) return
+  included.add(item.id)
+  queue.push(item)
+}
+
+function enqueueLinkedCohort(
+  items: readonly TimelineItem[],
+  current: TimelineItem,
+  included: Set<string>,
+  queue: TimelineItem[],
+): void {
+  for (const cohort of getLinkedItems([...items], current.id))
+    enqueueIfMissing(cohort, included, queue)
+}
+
+function enqueueRippleDownstream(
+  items: readonly TimelineItem[],
+  current: TimelineItem,
+  included: Set<string>,
+  queue: TimelineItem[],
+): void {
+  const end = current.from + current.durationInFrames
+  const downstream = items
+    .filter((candidate) => candidate.trackId === current.trackId && candidate.from >= end)
+    .sort((left, right) => left.from - right.from || left.id.localeCompare(right.id))
+  for (const candidate of downstream) {
+    if (!isRippleLinked(candidate)) break
+    enqueueIfMissing(candidate, included, queue)
+  }
+}
+
+/**
+ * Resolve the forward attachment chain for an anchor. A chain advances only
+ * across an exact touching boundary on the same lane. Linked A/V cohorts are
+ * added as a unit, but linkedGroupId never creates sequence attachments by
+ * itself. A false rippleLinked value is a hard break.
+ */
+export function resolveAttachedChain(items: readonly TimelineItem[], anchorId: string): string[] {
+  const byId = new Map(items.map((item) => [item.id, item]))
+  const anchor = byId.get(anchorId)
+  if (!anchor) return []
+
+  const result: string[] = []
+  const included = new Set<string>()
+  const queue: TimelineItem[] = [anchor]
+
+  while (queue.length > 0) {
+    const current = queue.shift()!
+    if (included.has(current.id)) continue
+    included.add(current.id)
+    result.push(current.id)
+
+    for (const cohortItem of getLinkedItems([...items], current.id)) {
+      if (!included.has(cohortItem.id)) queue.push(cohortItem)
+    }
+    // An explicit break stops the sequence tail but never breaks linked A/V
+    // cohort synchronization itself.
+    if (!isRippleLinked(current)) continue
+
+    const end = current.from + current.durationInFrames
+    const next = items
+      .filter(
+        (candidate) =>
+          candidate.trackId === current.trackId &&
+          candidate.id !== current.id &&
+          candidate.from === end &&
+          isRippleLinked(candidate),
+      )
+      .sort((left, right) => left.id.localeCompare(right.id))[0]
+    if (next && !included.has(next.id)) queue.push(next)
+  }
+
+  return result
+}
+
+/** Ripple edits retain their historical tail behavior, but stop at a break. */
+export function resolveAttachedRippleTail(
+  items: readonly TimelineItem[],
+  anchorId: string,
+): string[] {
+  const byId = new Map(items.map((item) => [item.id, item]))
+  const anchor = byId.get(anchorId)
+  if (!anchor) return []
+  const result = new Set<string>([anchorId])
+  const queue: TimelineItem[] = [anchor]
+  while (queue.length) {
+    const current = queue.shift()!
+    if (!isRippleLinked(current)) continue
+    enqueueLinkedCohort(items, current, result, queue)
+    enqueueRippleDownstream(items, current, result, queue)
+  }
+  return items.filter((item) => result.has(item.id)).map((item) => item.id)
+}
+
+export function buildAttachedMoveUpdates(
+  items: readonly TimelineItem[],
+  anchorId: string,
+  deltaFrames: number,
+  trackId?: string,
+): Array<{ id: string; from: number; trackId?: string }> {
+  const byId = new Map(items.map((item) => [item.id, item]))
+  return resolveAttachedChain(items, anchorId).flatMap((id) => {
+    const item = byId.get(id)
+    if (!item) return []
+    return [
+      {
+        id,
+        from: item.from + deltaFrames,
+        ...(id === anchorId && trackId ? { trackId } : {}),
+      },
+    ]
+  })
+}
diff --git a/src/features/timeline/utils/playhead-edge-scroll.ts b/src/features/timeline/utils/playhead-edge-scroll.ts
index 9fe68d09e..fd1cb7931 100644
--- a/src/features/timeline/utils/playhead-edge-scroll.ts
+++ b/src/features/timeline/utils/playhead-edge-scroll.ts
@@ -26,10 +26,6 @@ export function getPlayheadEdgeScrollVelocity(clientX: number, bounds: Horizonta
   return 0
 }
 
-export function getVisiblePlayheadClientX(clientX: number, bounds: HorizontalBounds): number {
-  return Math.max(bounds.left, Math.min(Math.max(bounds.left, bounds.right - 1), clientX))
-}
-
 export function getEdgeScrollDelta(velocity: number, timestamp: number, previousTimestamp: number) {
   const elapsedSeconds = Math.min(32, Math.max(0, timestamp - previousTimestamp)) / 1000
   return velocity * elapsedSeconds
diff --git a/src/features/timeline/utils/timeline-dom-density.ts b/src/features/timeline/utils/timeline-dom-density.ts
index 61e3fafa7..a58be10a2 100644
--- a/src/features/timeline/utils/timeline-dom-density.ts
+++ b/src/features/timeline/utils/timeline-dom-density.ts
@@ -12,8 +12,8 @@ export const DENSE_TIMELINE_OVERVIEW_ITEM_THRESHOLD = DENSE_TIMELINE_TRACK_ITEM_
 export const DENSE_TIMELINE_MAX_OVERVIEW_BUCKETS_PER_TRACK = 1024
 
 export const DEFAULT_TIMELINE_ITEM_CULL_BUFFER_PX = 2000
-export const DENSE_TIMELINE_ITEM_CULL_BUFFER_PX = 600
-export const COMPACT_TIMELINE_ITEM_MAX_WIDTH_PX = 36
+const DENSE_TIMELINE_ITEM_CULL_BUFFER_PX = 600
+const COMPACT_TIMELINE_ITEM_MAX_WIDTH_PX = 36
 const MIXED_TIMELINE_COMPACT_ZOOM_STEP = 1.12
 
 export interface TimelineItemDurationBounds {
@@ -98,13 +98,7 @@ export function countCompactTimelineItemsAtZoom(
   let high = sortedDurationsInFrames.length
   while (low < high) {
     const middle = (low + high) >> 1
-    if (
-      isTimelineItemCompactAtZoom(
-        sortedDurationsInFrames[middle]!,
-        fps,
-        pixelsPerSecond,
-      )
-    ) {
+    if (isTimelineItemCompactAtZoom(sortedDurationsInFrames[middle]!, fps, pixelsPerSecond)) {
       low = middle + 1
     } else {
       high = middle
diff --git a/src/features/timeline/utils/trim-utils.test.ts b/src/features/timeline/utils/trim-utils.test.ts
index 65668ce5c..ecfe3e6d3 100644
--- a/src/features/timeline/utils/trim-utils.test.ts
+++ b/src/features/timeline/utils/trim-utils.test.ts
@@ -270,4 +270,49 @@ describe('clampToAdjacentItems', () => {
       expect(clampTrimAmount(reversed, 'start', -100, 30).clampedAmount).toBe(-60)
     })
   })
+
+  describe('inconsistent source bounds (unprobed asset duration)', () => {
+    // Host snapshots map an asset with missing/zero duration to a 1-frame
+    // sourceDuration. An extend drag must no-op against such a bound — never
+    // clamp to a negative delta that collapses the clip toward 1 frame.
+    const poisoned = makeItem({
+      id: 'poisoned',
+      trackId,
+      from: 0,
+      durationInFrames: 150,
+      type: 'video',
+      sourceStart: 0,
+      sourceEnd: 150,
+      sourceDuration: 1,
+      sourceFps: 30,
+      speed: 1,
+    })
+
+    it('end-extend clamps to a no-op instead of collapsing the clip', () => {
+      expect(clampTrimAmount(poisoned, 'end', 10, 30).clampedAmount).toBe(0)
+      expect(clampTrimAmount(poisoned, 'end', 10, 30).maxExtend).toBe(0)
+    })
+
+    it('end-shrink still passes through', () => {
+      expect(clampTrimAmount(poisoned, 'end', -30, 30).clampedAmount).toBe(-30)
+    })
+
+    it('reversed start-extend clamps to a no-op when sourceDuration undercuts sourceEnd', () => {
+      const reversedPoisoned = makeItem({
+        id: 'reversed-poisoned',
+        trackId,
+        from: 0,
+        durationInFrames: 150,
+        type: 'video',
+        isReversed: true,
+        sourceStart: 0,
+        sourceEnd: 150,
+        sourceDuration: 1,
+        sourceFps: 30,
+        speed: 1,
+      })
+      expect(clampTrimAmount(reversedPoisoned, 'start', -10, 30).clampedAmount).toBe(0)
+      expect(clampTrimAmount(reversedPoisoned, 'start', -10, 30).maxExtend).toBe(0)
+    })
+  })
 })
diff --git a/src/features/timeline/utils/trim-utils.ts b/src/features/timeline/utils/trim-utils.ts
index 868f0658a..d94e13f09 100644
--- a/src/features/timeline/utils/trim-utils.ts
+++ b/src/features/timeline/utils/trim-utils.ts
@@ -72,14 +72,18 @@ export function clampTrimAmount(
         maxExtend =
           item.isReversed === true && sourceDuration !== undefined
             ? getMaxStartExtension(
-                sourceDuration - (sourceEnd ?? sourceDuration),
+                // A sourceDuration shorter than the clip's own sourceEnd is
+                // inconsistent data (e.g. an asset whose duration failed to
+                // probe). Floor at zero so an extend clamps to a no-op instead
+                // of a positive delta that shrinks the clip.
+                Math.max(0, sourceDuration - (sourceEnd ?? sourceDuration)),
                 speed,
                 effectiveSourceFps,
                 timelineFps,
               )
             : getMaxStartExtension(sourceStart, speed, effectiveSourceFps, timelineFps)
         if (-trimAmount > maxExtend) {
-          clampedAmount = -maxExtend
+          clampedAmount = maxExtend === 0 ? 0 : -maxExtend
         }
       }
     } else {
@@ -90,9 +94,9 @@ export function clampTrimAmount(
         const maxDuration =
           item.durationInFrames +
           getMaxStartExtension(sourceStart, speed, effectiveSourceFps, timelineFps)
-        maxExtend = maxDuration - item.durationInFrames
-        if (item.durationInFrames + trimAmount > maxDuration) {
-          clampedAmount = maxDuration - item.durationInFrames
+        maxExtend = Math.max(0, maxDuration - item.durationInFrames)
+        if (trimAmount > maxExtend) {
+          clampedAmount = maxExtend
         }
       } else if (sourceDuration !== undefined) {
         const maxDuration = calcMaxDuration(
@@ -102,10 +106,14 @@ export function clampTrimAmount(
           effectiveSourceFps,
           timelineFps,
         )
-        maxExtend = maxDuration - item.durationInFrames
+        // A maxDuration below the clip's current duration means the stored
+        // source bound contradicts the clip's window (e.g. an asset whose
+        // duration is unknown). An extend must clamp to a no-op then, never
+        // to a negative delta that would collapse the clip toward 1 frame.
+        maxExtend = Math.max(0, maxDuration - item.durationInFrames)
 
-        if (item.durationInFrames + trimAmount > maxDuration) {
-          clampedAmount = maxDuration - item.durationInFrames
+        if (trimAmount > maxExtend) {
+          clampedAmount = maxExtend
         }
       }
     }
diff --git a/src/runtime/composition-runtime/deps/player-contract.ts b/src/runtime/composition-runtime/deps/player-contract.ts
index 922a9cd89..f83412bf6 100644
--- a/src/runtime/composition-runtime/deps/player-contract.ts
+++ b/src/runtime/composition-runtime/deps/player-contract.ts
@@ -12,7 +12,7 @@ export {
 } from '@/runtime/player/composition'
 export { VideoConfigProvider } from '@/runtime/player/VideoConfigProvider'
 export { useVideoConfig } from '@/runtime/player/video-config-context'
-export { useBridgedCurrentFrame, useBridgedIsPlaying } from '@/runtime/player/clock'
+export { useBridgedIsPlaying } from '@/runtime/player/clock'
 export {
   useClock,
   useClockFrameSelector,
diff --git a/src/runtime/composition-runtime/hooks/use-player-compat.ts b/src/runtime/composition-runtime/hooks/use-player-compat.ts
index 1504e422a..863f49a58 100644
--- a/src/runtime/composition-runtime/hooks/use-player-compat.ts
+++ b/src/runtime/composition-runtime/hooks/use-player-compat.ts
@@ -6,10 +6,7 @@
  */
 
 import { useVideoConfig as useCustomVideoConfig } from '@/runtime/composition-runtime/deps/player'
-import {
-  useBridgedCurrentFrame,
-  useBridgedIsPlaying,
-} from '@/runtime/composition-runtime/deps/player'
+import { useBridgedIsPlaying } from '@/runtime/composition-runtime/deps/player'
 
 /**
  * Get video config (fps, width, height, durationInFrames) from the custom player context.
@@ -18,13 +15,6 @@ export function useVideoConfig() {
   return useCustomVideoConfig()
 }
 
-/**
- * Get current frame from the custom player's Clock.
- */
-export function useCurrentFrame() {
-  return useBridgedCurrentFrame()
-}
-
 /**
  * Get playing state from the custom player's Clock.
  */
diff --git a/src/runtime/player/clock/ClockBridge.ts b/src/runtime/player/clock/ClockBridge.ts
index 4d076081d..7da63dc53 100644
--- a/src/runtime/player/clock/ClockBridge.ts
+++ b/src/runtime/player/clock/ClockBridge.ts
@@ -2,7 +2,6 @@ export { ClockBridgeProvider } from './ClockBridgeProvider'
 export {
   useBridgedTimelineContext,
   useBridgedSetTimelineContext,
-  useBridgedCurrentFrame,
   useBridgedIsPlaying,
   useBridgedSetTimelineFrame,
   useBridgedActualFirstFrame,
diff --git a/src/runtime/player/clock/index.ts b/src/runtime/player/clock/index.ts
index d6a10c2cb..a0d538082 100644
--- a/src/runtime/player/clock/index.ts
+++ b/src/runtime/player/clock/index.ts
@@ -10,7 +10,6 @@ export {
   ClockBridgeProvider,
   useBridgedTimelineContext,
   useBridgedSetTimelineContext,
-  useBridgedCurrentFrame,
   useBridgedIsPlaying,
   useBridgedSetTimelineFrame,
   useBridgedActualFirstFrame,
diff --git a/src/types/project.ts b/src/types/project.ts
index 6c4e44a0f..a93d8cb0d 100644
--- a/src/types/project.ts
+++ b/src/types/project.ts
@@ -85,6 +85,7 @@ export interface ProjectTimeline {
       mediaId?: string
       originId?: string // Tracks lineage for stable React keys
       linkedGroupId?: string
+      rippleLinked?: boolean
       type:
         | 'video'
         | 'audio'
diff --git a/src/types/timeline.ts b/src/types/timeline.ts
index 4fa73e6ba..ff099fa06 100644
--- a/src/types/timeline.ts
+++ b/src/types/timeline.ts
@@ -65,6 +65,8 @@ type BaseTimelineItem = {
   compositionId?: string // Reference to a sub-composition for compound wrappers
   originId?: string // Tracks lineage - items from same split share this for stable React keys
   linkedGroupId?: string // Links paired timeline items like synced video/audio companions
+  /** Sequence attachment; omitted means attached, false is an explicit break. */
+  rippleLinked?: boolean
   // Trim properties for media items
   trimStart?: number // Frames trimmed from start of source media
   trimEnd?: number // Frames trimmed from end of source media