fix(mcp): keep cursor start before the recording state, and track waited-for takes

Restore set-recording-state's original order so startRecording cannot return
before cursor telemetry has started, document that a session's createdAt is
its recordingId, and record a waited-for take's start so setPointerTrack can
use it.

Author: EtienneLescot

electron/ipc/handlers.ts

@@ -4149,15 +4149,16 @@ export function registerIpcHandlers(
 	ipcMain.handle(
 		"set-recording-state",
 		async (_, recording: boolean, recordingId?: number, cursorCaptureMode?: CursorCaptureMode) => {
-			const source = selectedSource || { name: "Screen" };
-			setAppRecording(recording, source.name, recordingId);
 			const normalizedCursorCaptureMode =
 				normalizeCursorCaptureMode(cursorCaptureMode) ?? "editable-overlay";
 			if (recording && normalizedCursorCaptureMode === "editable-overlay") {
 				await startCursorRecording(recordingId);
 			} else {
 				await stopCursorRecording();
 			}
+
+			const source = selectedSource || { name: "Screen" };
+			setAppRecording(recording, source.name, recordingId);
 		},
 	);
 
@@ -4901,6 +4902,9 @@ export function registerIpcHandlers(
 		currentProjectPath = null;
 		if (normalizedSession) {
 			mcpAppRecorder.takeSaved(normalizedSession.screenVideoPath);
+			// Every capture path stamps the session's `createdAt` with its recordingId (the
+			// `Date.now()` it started at), so it names the take `recordingCompletion` tracks.
+			// Any other session (an opened file) carries a fresh `Date.now()` and matches none.
 			recordingCompletion.saved(normalizedSession.createdAt, normalizedSession.screenVideoPath);
 		}
 		return { success: true, session: currentRecordingSession };

electron/mcp/media-tools.test.ts

@@ -1139,6 +1139,34 @@ describe("waitForRecording through MCP", () => {
 		expect(runners.started).toEqual([]);
 	});
 
+	it("gives setPointerTrack the waited-for take's start, as stopRecording does", async () => {
+		const project = await documents.createProject("User take");
+		const completion = new RecordingCompletion();
+		completion.started(42, 1_000);
+		const sent: unknown[] = [];
+		const { observer, subscription } = await observing(completion, {
+			runTool: async (_name, args) => {
+				sent.push(args);
+				return { content: [{ type: "text", text: "ok" }] };
+			},
+		});
+		const waiting = observer.callTool({ name: "waitForRecording", arguments: {} });
+		await subscription;
+		completion.saved(42, videoPath);
+		completion.completed(42, {
+			projectId: project.project.id,
+			videoPath,
+			durationSec: 12,
+			autoZooms: 0,
+		});
+		await waiting;
+		await observer.callTool({
+			name: "setPointerTrack",
+			arguments: { projectId: project.project.id, events: [{ at: 1, x: 0.5, y: 0.5 }] },
+		});
+		expect(sent).toContainEqual(expect.objectContaining({ takes: { [videoPath]: 1_000 } }));
+	});
+
 	it("releases a client take after the user finishes it, so startRecording can record again", async () => {
 		const completion = new RecordingCompletion();
 		let id = 0;

electron/mcp/media-tools.ts

@@ -631,22 +631,23 @@ export function createMediaTools(deps: MediaToolDeps): MediaTools {
 		} catch (error) {
 			return text(error instanceof Error ? error.message : String(error), true);
 		}
-		startedAtByVideo.set(recorded.videoPath, running.startedAt);
 		return recordingResult(recorded, running.startedAt);
 	}
 
+	/** Also the one place a take's start is kept, so setPointerTrack finds a waited-for take. */
 	async function recordingResult(
 		recorded: RecordedTake,
 		recordingStartedAt: number,
 	): Promise<CallToolResult> {
+		startedAtByVideo.set(recorded.videoPath, recordingStartedAt);
 		const { projectId } = recorded;
 		return text(
 			JSON.stringify({
 				projectId,
 				checkpointId: await checkpointOf(projectId),
 				videoPath: recorded.videoPath,
 				durationSec: recorded.durationSec,
-				recordingStartedAt: recordingStartedAt,
+				recordingStartedAt,
 				autoZooms: recorded.autoZooms,
 				...(recorded.warnings?.length ? { warnings: recorded.warnings } : {}),
 			}),