fix: address PR #57 CodeRabbit feedback

- Acquire AniList post-watch in-flight lock before async gating to prevent duplicate writes
- Isolate manual watched mark result from AniList post-watch callback failures
- Report known-word cache clears as mutations during immediate append when state existed
- Add regression tests for each fix

src/main/runtime/anilist-post-watch.test.ts

@@ -121,6 +121,63 @@ test('createMaybeRunAnilistPostWatchUpdateHandler force-runs manual watched upda
   assert.ok(calls.includes('osd:updated ok'));
 });
 
+test('createMaybeRunAnilistPostWatchUpdateHandler blocks concurrent runs before async gating', async () => {
+  const calls: string[] = [];
+  let inFlight = false;
+  let resolveDuration!: (duration: number) => void;
+  const durationPromise = new Promise<number>((resolve) => {
+    resolveDuration = resolve;
+  });
+  const handler = createMaybeRunAnilistPostWatchUpdateHandler({
+    getInFlight: () => inFlight,
+    setInFlight: (value) => {
+      inFlight = value;
+      calls.push(`inflight:${value}`);
+    },
+    getResolvedConfig: () => ({}),
+    isAnilistTrackingEnabled: () => true,
+    getCurrentMediaKey: () => '/tmp/video.mkv',
+    hasMpvClient: () => true,
+    getTrackedMediaKey: () => '/tmp/video.mkv',
+    resetTrackedMedia: () => {},
+    getWatchedSeconds: () => 1000,
+    maybeProbeAnilistDuration: async () => {
+      calls.push('probe');
+      return await durationPromise;
+    },
+    ensureAnilistMediaGuess: async () => ({ title: 'Show', season: null, episode: 1 }),
+    hasAttemptedUpdateKey: () => false,
+    processNextAnilistRetryUpdate: async () => ({ ok: true, message: 'noop' }),
+    refreshAnilistClientSecretState: async () => 'token',
+    enqueueRetry: () => calls.push('enqueue'),
+    markRetryFailure: () => calls.push('mark-failure'),
+    markRetrySuccess: () => calls.push('mark-success'),
+    refreshRetryQueueState: () => calls.push('refresh'),
+    updateAnilistPostWatchProgress: async () => {
+      calls.push('update');
+      return { status: 'updated', message: 'updated ok' };
+    },
+    rememberAttemptedUpdateKey: () => calls.push('remember'),
+    showMpvOsd: (message) => calls.push(`osd:${message}`),
+    logInfo: (message) => calls.push(`info:${message}`),
+    logWarn: (message) => calls.push(`warn:${message}`),
+    minWatchSeconds: 600,
+    minWatchRatio: 0.85,
+  });
+
+  const firstRun = handler();
+  assert.deepEqual(calls, ['inflight:true', 'probe']);
+
+  await handler();
+  assert.deepEqual(calls, ['inflight:true', 'probe']);
+
+  resolveDuration(1000);
+  await firstRun;
+
+  assert.equal(calls.filter((call) => call === 'update').length, 1);
+  assert.equal(calls.at(-1), 'inflight:false');
+});
+
 test('createMaybeRunAnilistPostWatchUpdateHandler skips youtube playback entirely', async () => {
   const calls: string[] = [];
   const handler = createMaybeRunAnilistPostWatchUpdateHandler({

src/main/runtime/anilist-post-watch.ts

@@ -144,33 +144,36 @@ export function createMaybeRunAnilistPostWatchUpdateHandler(deps: {
       deps.resetTrackedMedia(mediaKey);
     }
 
+    let watchedSeconds = 0;
     if (!force) {
-      const watchedSeconds = deps.getWatchedSeconds();
+      watchedSeconds = deps.getWatchedSeconds();
       if (!Number.isFinite(watchedSeconds) || watchedSeconds < deps.minWatchSeconds) {
         return;
       }
-
-      const duration = await deps.maybeProbeAnilistDuration(mediaKey);
-      if (!duration || duration <= 0) {
-        return;
-      }
-      if (watchedSeconds / duration < deps.minWatchRatio) {
-        return;
-      }
-    }
-
-    const guess = await deps.ensureAnilistMediaGuess(mediaKey);
-    if (!guess?.title || !guess.episode || guess.episode <= 0) {
-      return;
-    }
-
-    const attemptKey = buildAnilistAttemptKey(mediaKey, guess.episode);
-    if (deps.hasAttemptedUpdateKey(attemptKey)) {
-      return;
     }
 
     deps.setInFlight(true);
     try {
+      if (!force) {
+        const duration = await deps.maybeProbeAnilistDuration(mediaKey);
+        if (!duration || duration <= 0) {
+          return;
+        }
+        if (watchedSeconds / duration < deps.minWatchRatio) {
+          return;
+        }
+      }
+
+      const guess = await deps.ensureAnilistMediaGuess(mediaKey);
+      if (!guess?.title || !guess.episode || guess.episode <= 0) {
+        return;
+      }
+
+      const attemptKey = buildAnilistAttemptKey(mediaKey, guess.episode);
+      if (deps.hasAttemptedUpdateKey(attemptKey)) {
+        return;
+      }
+
       await deps.processNextAnilistRetryUpdate();
       if (deps.hasAttemptedUpdateKey(attemptKey)) {
         return;