Merge pull request #1945

Author: callumalpass

docs/releases/unreleased.md

@@ -47,10 +47,13 @@ Example:
   - Thanks to @joseluisgonzalezdelgado-ctrl for reporting.
 - (#1939) Fixed the task Details field rendering as a small nested textarea when the embedded editor falls back.
   - Thanks to @g-arthurvanderbilt for reporting and @cookbr for confirming the desktop impact.
+- Fixed tag and modal preview edge cases found during validation: double-hash tags no longer match the task tag, empty tag lists stay empty when read back, and natural-language previews remain visible when enabled.
 - (#1941) Fixed mobile Kanban boards scrolling the whole board vertically instead of keeping each list independently scrollable.
   - Thanks to @pxxush for reporting.
 - (#1943) Fixed MCP task-query tool instructions so filter operators match the operators TaskNotes actually accepts.
-  - Thanks to @jordankbartos for reporting.
+  - Thanks to @jordankbartos for reporting and proposing a fix in #1944.
+- (#1945) Fixed Google Calendar export so overlapping sync services do not create duplicate events for the same task while the saved event ID is still catching up.
+  - Thanks to @martin-forge for reporting and contributing the fix.
 - (#1946) Fixed the bottom task in virtualized Task List Bases being partially hidden behind Obsidian's mobile bottom bar.
   - Thanks to @3zra47 for reporting.
 - (#1947) Fixed mobile Task List cards with left-positioned subtask chevrons so the chevron remains visible and project/detail badges stay on the main row.

src/core/fieldMapping.ts

@@ -302,9 +302,7 @@ export function mapTaskFromFrontmatter(
 
 	if (frontmatter.tags !== undefined) {
 		const tags = getFrontmatterTags(frontmatter.tags);
-		if (tags.length > 0) {
-			mapped.tags = tags;
-		}
+		mapped.tags = tags;
 		mapped.archived = tags.includes(normalizeTagForComparison(mapping.archiveTag));
 	}
 

src/services/TaskCalendarSyncService.ts

@@ -99,6 +99,18 @@ function isAlreadyDeletedError(error: unknown): boolean {
  * Handles creating, updating, and deleting calendar events when tasks change.
  */
 export class TaskCalendarSyncService {
+	/** In-flight create operations keyed by calendar and task path to avoid duplicate Google events */
+	private static pendingEventCreates: Map<string, Promise<string>> = new Map();
+
+	/** In-flight detached exception creates keyed by calendar and task path */
+	private static pendingExceptionEventCreates: Map<string, Promise<string>> = new Map();
+
+	/** Event IDs written during this session, used while Obsidian metadata catches up */
+	private static taskEventIdCache: Map<string, string> = new Map();
+
+	/** Detached exception event IDs written during this session */
+	private static taskExceptionEventIdCache: Map<string, string> = new Map();
+
 	private plugin: TaskNotesPlugin;
 	private googleCalendarService: GoogleCalendarService;
 	private rateLimitChain: Promise<unknown> = Promise.resolve();
@@ -119,15 +131,6 @@ export class TaskCalendarSyncService {
 	/** Store the latest explicitly passed task object during debounce to avoid cache race conditions */
 	private pendingTasks: Map<string, TaskInfo> = new Map();
 
-	/** In-flight create operations keyed by task path to avoid duplicate Google events */
-	private pendingEventCreates: Map<string, Promise<string>> = new Map();
-
-	/** Event IDs written during this session, used while Obsidian metadata catches up */
-	private taskEventIdCache: Map<string, string> = new Map();
-
-	/** Detached recurring exception event IDs written during this session */
-	private taskExceptionEventIdCache: Map<string, string> = new Map();
-
 	/** Last calendar-relevant task fingerprint persisted after successful syncs */
 	private calendarFingerprints: Map<string, string> | null = null;
 
@@ -136,6 +139,64 @@ export class TaskCalendarSyncService {
 		this.googleCalendarService = googleCalendarService;
 	}
 
+	private static getTaskCalendarCacheKey(taskPath: string, calendarId?: string): string {
+		return calendarId ? `${calendarId}::${taskPath}` : taskPath;
+	}
+
+	private static deleteTaskPathEntries(cache: Map<string, unknown>, taskPath: string): void {
+		cache.delete(TaskCalendarSyncService.getTaskCalendarCacheKey(taskPath));
+		for (const key of Array.from(cache.keys())) {
+			if (key.endsWith(`::${taskPath}`)) {
+				cache.delete(key);
+			}
+		}
+	}
+
+	private static clearTaskEventIdCache(taskPath: string, calendarId?: string): void {
+		if (calendarId) {
+			TaskCalendarSyncService.taskEventIdCache.delete(
+				TaskCalendarSyncService.getTaskCalendarCacheKey(taskPath, calendarId)
+			);
+			return;
+		}
+
+		TaskCalendarSyncService.deleteTaskPathEntries(
+			TaskCalendarSyncService.taskEventIdCache,
+			taskPath
+		);
+	}
+
+	private static clearTaskExceptionEventIdCache(
+		taskPath: string,
+		calendarId?: string
+	): void {
+		if (calendarId) {
+			TaskCalendarSyncService.taskExceptionEventIdCache.delete(
+				TaskCalendarSyncService.getTaskCalendarCacheKey(taskPath, calendarId)
+			);
+			return;
+		}
+
+		TaskCalendarSyncService.deleteTaskPathEntries(
+			TaskCalendarSyncService.taskExceptionEventIdCache,
+			taskPath
+		);
+	}
+
+	static clearSharedGoogleCalendarSyncStateForTests(): void {
+		TaskCalendarSyncService.pendingEventCreates.clear();
+		TaskCalendarSyncService.pendingExceptionEventCreates.clear();
+		TaskCalendarSyncService.taskEventIdCache.clear();
+		TaskCalendarSyncService.taskExceptionEventIdCache.clear();
+	}
+
+	private getTaskEventIdCacheKey(taskPath: string, calendarId?: string): string {
+		return TaskCalendarSyncService.getTaskCalendarCacheKey(
+			taskPath,
+			calendarId || this.plugin.settings.googleCalendarExport.targetCalendarId
+		);
+	}
+
 	private profileAsync<T>(
 		name: string,
 		fn: () => Promise<T>,
@@ -178,9 +239,6 @@ export class TaskCalendarSyncService {
 		this.pendingSyncs.clear();
 		this.previousTaskState.clear();
 		this.pendingTasks.clear();
-		this.pendingEventCreates.clear();
-		this.taskEventIdCache.clear();
-		this.taskExceptionEventIdCache.clear();
 		this.calendarFingerprints = null;
 	}
 
@@ -1235,7 +1293,12 @@ export class TaskCalendarSyncService {
 	 * Get the Google Calendar event ID from the task's frontmatter
 	 */
 	getTaskEventId(task: TaskInfo): string | undefined {
-		return task.googleCalendarEventId || this.taskEventIdCache.get(task.path);
+		return (
+			task.googleCalendarEventId ||
+			TaskCalendarSyncService.taskEventIdCache.get(
+				this.getTaskEventIdCacheKey(task.path)
+			)
+		);
 	}
 
 	/**
@@ -1244,7 +1307,9 @@ export class TaskCalendarSyncService {
 	getTaskExceptionEventId(task: TaskInfo): string | undefined {
 		return (
 			task.googleCalendarExceptionEventId ||
-			this.taskExceptionEventIdCache.get(task.path)
+			TaskCalendarSyncService.taskExceptionEventIdCache.get(
+				this.getTaskEventIdCacheKey(task.path)
+			)
 		);
 	}
 
@@ -1296,7 +1361,11 @@ export class TaskCalendarSyncService {
 	/**
 	 * Save the Google Calendar event ID to the task's frontmatter
 	 */
-	private async saveTaskEventId(taskPath: string, eventId: string): Promise<void> {
+	private async saveTaskEventId(
+		taskPath: string,
+		eventId: string,
+		calendarId?: string
+	): Promise<void> {
 		const file = this.plugin.app.vault.getAbstractFileByPath(taskPath);
 		if (!(file instanceof TFile)) {
 			tasknotesLogger.warn(`Cannot save event ID: file not found at ${taskPath}`, {
@@ -1310,9 +1379,13 @@ export class TaskCalendarSyncService {
 		await processVaultFrontMatter(this.plugin.app, file, (frontmatter) => {
 			frontmatter[fieldName] = eventId;
 		});
-		this.taskEventIdCache.set(taskPath, eventId);
+		TaskCalendarSyncService.taskEventIdCache.set(
+			this.getTaskEventIdCacheKey(taskPath, calendarId),
+			eventId
+		);
 
-		const targetCalendarId = this.plugin.settings.googleCalendarExport.targetCalendarId;
+		const targetCalendarId =
+			calendarId || this.plugin.settings.googleCalendarExport.targetCalendarId;
 		if (targetCalendarId) {
 			await this.upsertEventIndex(taskPath, targetCalendarId, eventId);
 		}
@@ -1328,7 +1401,7 @@ export class TaskCalendarSyncService {
 				category: "provider",
 				operation: "remove-event-id-file-not-found",
 			});
-			this.taskEventIdCache.delete(taskPath);
+			TaskCalendarSyncService.clearTaskEventIdCache(taskPath);
 			await this.removeEventIndexForTask(taskPath);
 			return;
 		}
@@ -1337,7 +1410,7 @@ export class TaskCalendarSyncService {
 		await processVaultFrontMatter(this.plugin.app, file, (frontmatter) => {
 			delete frontmatter[fieldName];
 		});
-		this.taskEventIdCache.delete(taskPath);
+		TaskCalendarSyncService.clearTaskEventIdCache(taskPath);
 		await this.removeEventIndexForTask(taskPath);
 	}
 
@@ -1350,7 +1423,8 @@ export class TaskCalendarSyncService {
 				| "googleCalendarExceptionOriginalScheduled"
 				| "googleCalendarMovedOriginalDates"
 			>
-		>
+		>,
+		calendarId?: string
 	): Promise<void> {
 		const file = this.plugin.app.vault.getAbstractFileByPath(taskPath);
 		if (!(file instanceof TFile)) {
@@ -1394,12 +1468,12 @@ export class TaskCalendarSyncService {
 
 		if ("googleCalendarExceptionEventId" in updates) {
 			if (updates.googleCalendarExceptionEventId) {
-				this.taskExceptionEventIdCache.set(
-					taskPath,
+				TaskCalendarSyncService.taskExceptionEventIdCache.set(
+					this.getTaskEventIdCacheKey(taskPath, calendarId),
 					updates.googleCalendarExceptionEventId
 				);
 			} else {
-				this.taskExceptionEventIdCache.delete(taskPath);
+				TaskCalendarSyncService.clearTaskExceptionEventIdCache(taskPath, calendarId);
 			}
 		}
 	}
@@ -2017,7 +2091,7 @@ export class TaskCalendarSyncService {
 			? createdEvent.id.slice(prefix.length)
 			: createdEvent.id;
 
-		await this.saveTaskEventId(task.path, eventId);
+		await this.saveTaskEventId(task.path, eventId, calendarId);
 		return eventId;
 	}
 
@@ -2111,10 +2185,14 @@ export class TaskCalendarSyncService {
 				}
 			}
 
-			await this.saveTaskExceptionMetadata(task.path, {
-				googleCalendarExceptionEventId: undefined,
-				googleCalendarExceptionOriginalScheduled: undefined,
-			});
+			await this.saveTaskExceptionMetadata(
+				task.path,
+				{
+					googleCalendarExceptionEventId: undefined,
+					googleCalendarExceptionOriginalScheduled: undefined,
+				},
+				targetCalendarId
+			);
 			return;
 		}
 
@@ -2137,29 +2215,64 @@ export class TaskCalendarSyncService {
 				if (getErrorStatus(error) !== 404) {
 					throw error;
 				}
-				await this.saveTaskExceptionMetadata(task.path, {
-					googleCalendarExceptionEventId: undefined,
-				});
+				await this.saveTaskExceptionMetadata(
+					task.path,
+					{
+						googleCalendarExceptionEventId: undefined,
+					},
+					targetCalendarId
+				);
 			}
 		}
 
-		const createdEvent = await this.withGoogleRateLimit(() =>
+		const createCacheKey = this.getTaskEventIdCacheKey(task.path, targetCalendarId);
+		const pendingCreate =
+			TaskCalendarSyncService.pendingExceptionEventCreates.get(createCacheKey);
+		if (pendingCreate) {
+			const eventId = await pendingCreate;
+			await this.withGoogleRateLimit(() =>
+				this.googleCalendarService.updateEvent(targetCalendarId, eventId, eventData)
+			);
+			return;
+		}
+
+		const createPromise = this.withGoogleRateLimit(() =>
 			this.googleCalendarService.createEvent(targetCalendarId, {
 				...eventData,
 				isAllDay: !!eventData.start.date,
 			})
-		);
-		const prefix = `google-${targetCalendarId}-`;
-		const eventId = createdEvent.id.startsWith(prefix)
-			? createdEvent.id.slice(prefix.length)
-			: createdEvent.id;
+		).then(async (createdEvent) => {
+			const prefix = `google-${targetCalendarId}-`;
+			const eventId = createdEvent.id.startsWith(prefix)
+				? createdEvent.id.slice(prefix.length)
+				: createdEvent.id;
 
-		await this.saveTaskExceptionMetadata(task.path, {
-			googleCalendarExceptionEventId: eventId,
-			googleCalendarExceptionOriginalScheduled: getDatePart(
-				task.googleCalendarExceptionOriginalScheduled || ""
-			),
+			await this.saveTaskExceptionMetadata(
+				task.path,
+				{
+					googleCalendarExceptionEventId: eventId,
+					googleCalendarExceptionOriginalScheduled: getDatePart(
+						task.googleCalendarExceptionOriginalScheduled || ""
+					),
+				},
+				targetCalendarId
+			);
+			return eventId;
 		});
+		TaskCalendarSyncService.pendingExceptionEventCreates.set(
+			createCacheKey,
+			createPromise
+		);
+		try {
+			await createPromise;
+		} finally {
+			if (
+				TaskCalendarSyncService.pendingExceptionEventCreates.get(createCacheKey) ===
+				createPromise
+			) {
+				TaskCalendarSyncService.pendingExceptionEventCreates.delete(createCacheKey);
+			}
+		}
 	}
 
 	/**
@@ -2232,7 +2345,12 @@ export class TaskCalendarSyncService {
 					)
 				);
 			} else {
-				const pendingCreate = this.pendingEventCreates.get(task.path);
+				const createCacheKey = this.getTaskEventIdCacheKey(
+					task.path,
+					targetCalendarId
+				);
+				const pendingCreate =
+					TaskCalendarSyncService.pendingEventCreates.get(createCacheKey);
 				if (pendingCreate) {
 					const eventId = await pendingCreate;
 					await this.withGoogleRateLimit(() =>
@@ -2244,12 +2362,18 @@ export class TaskCalendarSyncService {
 						eventData,
 						targetCalendarId
 					);
-					this.pendingEventCreates.set(task.path, createPromise);
+					TaskCalendarSyncService.pendingEventCreates.set(
+						createCacheKey,
+						createPromise
+					);
 					try {
 						await createPromise;
 					} finally {
-						if (this.pendingEventCreates.get(task.path) === createPromise) {
-							this.pendingEventCreates.delete(task.path);
+						if (
+							TaskCalendarSyncService.pendingEventCreates.get(createCacheKey) ===
+							createPromise
+						) {
+							TaskCalendarSyncService.pendingEventCreates.delete(createCacheKey);
 						}
 					}
 				}

src/utils/taskIdentification.ts

@@ -53,8 +53,6 @@ export function isTaskFrontmatter(
 
 	const tags = getFrontmatterTags(frontmatter.tags);
 	return tags.some((tag) => {
-		// Obsidian metadata cache prepends "#" to frontmatter tags.
-		const cleanTag = tag.startsWith("#") ? tag.slice(1) : tag;
-		return FilterUtils.matchesHierarchicalTagExact(cleanTag, settings.taskTag);
+		return FilterUtils.matchesHierarchicalTagExact(tag, settings.taskTag);
 	});
 }

styles/task-modal.css

@@ -1332,6 +1332,7 @@ body.is-mobile .tasknotes-plugin .task-project-item--task-card .task-project-rem
 
 .tasknotes-plugin .nl-preview-container.nl-preview-container--visible {
     display: block;
+    visibility: visible;
 }
 
 .tasknotes-plugin .nl-preview-item {