fix(timeline): lever l'ambiguïté quand deux clips partagent le même média

Un trim était stocké en temps source PAR ASSET, sans identité de clip. Dès que
deux clips tirent du même média (clip dupliqué, même enregistrement posé deux
fois), ils partagent le même espace de coordonnées : « sur quel clip est cette
coupe ? » n'avait pas de réponse, et chaque lecteur en inventait une. Un seul
défaut, trois symptômes :

  - transcript : la coupe apparaissait sur LES DEUX clips ;
  - règle : la pastille était dessinée sur le PREMIER ;
  - lecture/export : la plage était retirée des DEUX clips.

AxcutTrimRange gagne `clipId` — `startSec`/`endSec` SONT déjà la fenêtre source,
donc c'était la seule pièce manquante pour rejoindre l'ancre de clip v5 que
zoom/annotation/speed ont depuis longtemps. `trimAppliesToClip` est désormais la
définition unique par laquelle passent buildClipSection, trimToTimelineSpan et
resolvePlaybackSegments. Un trim sans `clipId` garde le sens historique par
asset : les documents existants se lisent exactement comme avant.

Schéma 6 -> 7. La migration VENTILE au lieu de choisir : un trim stocké devient
une ligne ancrée par clip couvert, chacune bornée à la fenêtre de son clip. Un
trim v6 coupait réellement tous les clips de son asset, donc le rendu ne bouge
pas — mais les lignes sont maintenant adressables séparément, ce qui permet de
supprimer la copie posée sur le clip qu'on ne visait pas. Un trim ne couvrant
aucun clip est conservé tel quel plutôt que supprimé.

Corollaires du modèle : `duplicateClip` copie explicitement les trims ancrés sur
la copie (avant c'était un effet de bord du match par asset), et `removeClip`
supprime ceux du clip effacé pour qu'un jumeau du même asset ne les ressuscite
pas.

--- Transcript : la même ambiguïté un cran plus haut

Un transcript appartient à l'ASSET, donc deux clips sur un média projettent le
même AxcutWord deux fois : `word.id` nomme un instant dans le média, pas un
élément à l'écran. `ClipWord.id` = `clipWordId(clip.id, word.id)` devient
l'identité à l'écran (clé React, data-word-id, surlignage du mot lu, ancre du
curseur), et `findCueWordId` choisit sa section par `cue.clipId`. Les jetons
[silence] rendent ce cloisonnement inconditionnel : withSilenceGaps les numérote
à partir de 1 dans chaque clip, donc `silence_1` existait dans tous les blocs.

--- Deux défauts adjacents, trouvés en vérifiant

Cliquer un mot du transcript appelait `onSeek(word.startSec)` — du temps SOURCE —
alors que handleSeek attend du temps TIMELINE. Invisible tant qu'un seul clip
siégeait à la position 0, où les deux coïncident ; le surlignage désormais
cloisonné le rendait manifeste.

Backspace/Delete devenaient un no-op silencieux dès qu'un mot déjà coupé se
trouvait sur leur trajet : la résolution tombait dessus et skipWordRange le
jetait comme non conservé. La marche saute maintenant les mots déjà coupés, dans
les deux sens ; une garde qui prétendait traiter le cas renvoyait le mot qu'elle
venait d'écarter et était morte de toute façon.

--- Suppression d'un trim = toute la pastille

Une coupe étirée par-dessus une frontière de clip est nécessairement 2+ lignes
(ventilateTimelineSpanToTrims) rendues comme une seule pastille. La suppression
filtrait par id, laissant la moitié continuer de couper. `dropTrimPillsByIds`
aligne les trois chemins (touche Suppr, inspecteur, outil LLM removeTrim) sur ce
que dropPillById fait déjà pour les autres types ; le contournement local de
FloatingInspector disparaît.

Tests : aucun test existant ne couvrait deux clips partageant un asset avec des
fenêtres source qui se chevauchent — le garde-fou le plus proche prenait des
fenêtres à 45 s d'écart, donc il passait malgré le défaut. Chaque nouveau test a
été vérifié en échec sans son correctif.

Author: EtienneLescot

electron/ai-edition/agent-tools.ts

@@ -340,6 +340,11 @@ export const addTrimArgs = z.object({
 	startSec: secondsSchema,
 	endSec: secondsSchema,
 	assetId: z.string().min(1).optional(),
+	// A cut belongs to ONE clip. Without this, a project where two clips draw from the same
+	// asset (a duplicated clip) cannot say which of them the model meant, and the cut lands
+	// on both. Resolved from the source range when the model omits it and only one clip
+	// matches; ambiguity is reported back rather than guessed.
+	clipId: z.string().min(1).optional(),
 	reason: z.string().default(""),
 });
 
@@ -601,6 +606,9 @@ export function documentSnapshotForModel(
 		trimRanges: document.timeline.trimRanges.map((s) => ({
 			id: s.id,
 			assetId: s.assetId,
+			// The clip the cut is on — the only thing separating two cuts over the same
+			// media. `null` is a pre-v7 cut that still applies to every clip of its asset.
+			clipId: s.clipId ?? null,
 			startSec: s.startSec,
 			endSec: s.endSec,
 			reason: s.reason,
@@ -872,9 +880,38 @@ export function executeAgentTool(
 			}
 			const startSec = Math.min(parsed.data.startSec, parsed.data.endSec);
 			const endSec = Math.max(parsed.data.startSec, parsed.data.endSec);
+
+			// Which clip the cut sits on. Named explicitly when the model says so; otherwise
+			// inferred from the source range — but only when the answer is unique. Two clips
+			// over the same asset covering that range is a real question the model has to
+			// answer (their ids are in the snapshot), not one to settle by picking the first.
+			const covering = document.timeline.clips.filter(
+				(c) =>
+					c.assetId === assetId &&
+					endSec > c.sourceStartSec &&
+					startSec < (c.sourceEndSec ?? Number.POSITIVE_INFINITY),
+			);
+			let clipId = parsed.data.clipId;
+			if (clipId) {
+				const target = document.timeline.clips.find((c) => c.id === clipId);
+				if (!target) return failure(`Unknown clip: ${clipId}`);
+				if (target.assetId !== assetId) {
+					return failure(`Clip ${clipId} does not use asset ${assetId}.`);
+				}
+			} else if (covering.length === 1) {
+				clipId = covering[0].id;
+			} else if (covering.length > 1) {
+				return failure(
+					`${covering.length} clips use asset ${assetId} over ${formatSec(startSec)} – ${formatSec(
+						endSec,
+					)} (${covering.map((c) => c.id).join(", ")}). Pass clipId to say which one to trim.`,
+				);
+			}
+
 			const trim = {
 				id: createId("trim"),
 				assetId,
+				...(clipId ? { clipId } : {}),
 				startSec,
 				endSec,
 				reason: parsed.data.reason,
@@ -904,12 +941,27 @@ export function executeAgentTool(
 			}
 			const startSec = Math.min(parsed.data.startSec, parsed.data.endSec);
 			const endSec = Math.max(parsed.data.startSec, parsed.data.endSec);
+			// Moving a cut out of the clip it is anchored to would leave it storing a range
+			// nothing plays — silently inert. Re-point it at the clip the new range actually
+			// lands in, but only when that clip is unique: with several candidates the old
+			// anchor is the better guess than an arbitrary one.
+			const reanchor = (trim: AxcutDocument["timeline"]["trimRanges"][number]) => {
+				if (!trim.clipId) return undefined;
+				const covers = (c: { sourceStartSec: number; sourceEndSec?: number }) =>
+					endSec > c.sourceStartSec && startSec < (c.sourceEndSec ?? Number.POSITIVE_INFINITY);
+				const current = document.timeline.clips.find((c) => c.id === trim.clipId);
+				if (current && covers(current)) return trim.clipId;
+				const candidates = document.timeline.clips.filter(
+					(c) => c.assetId === trim.assetId && covers(c),
+				);
+				return candidates.length === 1 ? candidates[0].id : trim.clipId;
+			};
 			const next: AxcutDocument = {
 				...document,
 				timeline: {
 					...document.timeline,
 					trimRanges: document.timeline.trimRanges.map((r) =>
-						r.id === trimRangeId ? { ...r, startSec, endSec } : r,
+						r.id === trimRangeId ? { ...r, clipId: reanchor(r), startSec, endSec } : r,
 					),
 				},
 			};

electron/ai-edition/deep-agent/service.ts

@@ -142,8 +142,9 @@ export const TOOL_DESCRIPTIONS: Record<string, string> = {
 	getCursorTrack:
 		"Read the recorded pointer track for an asset: where the cursor was over time, downsampled to a readable rate. Each point carries atSec (the asset's own source clock), virtualSec (the same instant on the edited timeline — the coordinate addZoom takes, null when no clip carries it), cx/cy as 0–1 fractions of the frame, and `shape`, an index into the pointer bitmaps the recording used (equal values are the same pointer; a change means the pointer changed, e.g. arrow to text caret). Points that are not plain moves carry `kind`; points a trim cuts out of playback carry `trimmed`. These are real samples, not a summary — reading what the pointer was doing is yours. Omit assetId for the primary asset. It answers `available:false` in two DIFFERENT ways you must not confuse: reason 'no-sidecar' means this asset was checked and genuinely has no telemetry, while reason 'unavailable' means it could not be read from here.",
 	addTrim:
-		"Add a trim range: a cut of a span inside a clip (this source-time span will not be played or exported) that does NOT split the clip. Times are in seconds of the asset's source time. This is the preferred (and for 'remove silences' requests, the only) way to handle silences; it preserves the user's placed clips and only adds a cut. Call this once per silent range.",
-	setTrim: "Move or resize an existing trim range by id. Times are source-time seconds.",
+		"Add a trim range: a cut of a span inside a clip (this source-time span will not be played or exported) that does NOT split the clip. Times are in seconds of the asset's source time. This is the preferred (and for 'remove silences' requests, the only) way to handle silences; it preserves the user's placed clips and only adds a cut. Call this once per silent range. A cut belongs to ONE clip: `clipId` is inferred when a single clip covers the range, but when several clips draw on the same asset over it the call FAILS and lists them — pass the `clipId` you mean (ids come from getCurrentDocument).",
+	setTrim:
+		"Move or resize an existing trim range by id. Times are source-time seconds. The cut follows to whichever clip the new range lands in, when that clip is unambiguous.",
 	setClipRange:
 		"Set a clip's in/out points (source-time seconds) to shorten its head or tail — distinct from a trim (which cuts a span inside the clip). All clips are re-laid back-to-back afterwards, so downstream clips shift automatically. Use this ONLY when the user explicitly asks to shorten or extend a user-placed clip. Do NOT use this for 'remove silences' or 'cut pauses' — for those, use addTrim.",
 	moveClip:

electron/ai-edition/document-service.test.ts

@@ -24,17 +24,17 @@ describe("DocumentService", () => {
 	});
 
 	describe("createProject", () => {
-		it("creates a v6 doc with the given title and writes it to disk", async () => {
+		it("creates a v7 doc with the given title and writes it to disk", async () => {
 			const doc = await service.createProject("Demo Project");
-			expect(doc.schemaVersion).toBe(6);
+			expect(doc.schemaVersion).toBe(7);
 			expect(doc.project.title).toBe("Demo Project");
 			expect(doc.project.id).toMatch(/^proj_/);
 			expect(doc.assets).toEqual([]);
 
 			const filePath = path.join(tempDir, `${doc.project.id}.openscreen`);
 			const raw = await fs.readFile(filePath, "utf8");
 			expect(JSON.parse(raw)).toMatchObject({
-				schemaVersion: 6,
+				schemaVersion: 7,
 				project: { title: "Demo Project" },
 			});
 		});

src/components/ai-edition/EditorEmptyState.test.tsx

@@ -25,7 +25,7 @@ const sampleDoc = vi.hoisted(() => ({
 	// load site (DocumentService, browserShim) runs `migrateRawDocumentToCurrent`
 	// before returning, and the renderer's `parseDocument` is a pure v6
 	// validator. Test fixtures model the post-hoist contract.
-	schemaVersion: 6,
+	schemaVersion: 7,
 	project: {
 		id: "proj_test",
 		title: "Test",

src/components/ai-edition/NewEditorShell.tsx

@@ -34,6 +34,7 @@ import {
 	type UnsavedChoice,
 } from "./Modals";
 import { Preview } from "./Preview";
+import type { TrimTarget } from "./RightPanes";
 import v4 from "./v4/EditorShellV4.module.css";
 import { type EditorMode, EditorTopBar } from "./v4/EditorTopBar";
 import { type Facet, FloatingInspector } from "./v4/FloatingInspector";
@@ -574,8 +575,17 @@ export function NewEditorShell() {
 	// apps/web/src/App.tsx. The serialised save + inside-the-chain doc
 	// read is owned by `useSequentialTimelineOps` above.
 	const handleAddTrimRange = useCallback(
-		(assetId: string, startSec: number, endSec: number, reason: string) => {
-			void applyTimelineOp({ type: "add_trim_range", assetId, startSec, endSec, reason });
+		(target: TrimTarget, startSec: number, endSec: number, reason: string) => {
+			// `clipId` is what keeps the cut on the block the user typed in: with two clips
+			// over the same media, an asset-only trim showed up on both (see `trimAppliesToClip`).
+			void applyTimelineOp({
+				type: "add_trim_range",
+				assetId: target.assetId,
+				clipId: target.clipId,
+				startSec,
+				endSec,
+				reason,
+			});
 		},
 		[applyTimelineOp],
 	);