Re-converge writeMorphemeGloss clear path onto identical sibling

The clear branch returned before mergeIntoIdenticalPayload, so clearing
a
morpheme gloss back to a sibling's state left a duplicate payload the
write
path would have collapsed (double-counting the form in the suggestion
pool).
Merge on the clear path too, making dedupe symmetric across both
directions.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: alex-rawlings-yyc

src/__tests__/store/analysisSlice.test.ts

@@ -1576,6 +1576,105 @@ describe('writeMorphemeGloss', () => {
       store.getState().analysis.analysis.tokenAnalyses[0].morphemes?.[0].gloss,
     ).toBeUndefined();
   });
+
+  it('re-converges onto an identical sibling after a morpheme gloss edit', () => {
+    // Two payloads for "cats" differ only in morpheme-0's gloss; glossing tok-1's morpheme to match
+    // tok-2's makes them content-identical, so the two payloads should collapse back onto one.
+    const ta1: TokenAnalysis = {
+      id: 'ta-1',
+      surfaceText: 'cats',
+      morphemes: [
+        { id: 'm-1', form: 'cat', writingSystem: 'und' },
+        { id: 'm-2', form: '-s', writingSystem: 'und', gloss: { und: 'PL' } },
+      ],
+    };
+    const ta2: TokenAnalysis = {
+      id: 'ta-2',
+      surfaceText: 'cats',
+      morphemes: [
+        { id: 'm-3', form: 'cat', writingSystem: 'und', gloss: { und: 'feline' } },
+        { id: 'm-4', form: '-s', writingSystem: 'und', gloss: { und: 'PL' } },
+      ],
+    };
+    const store = createAnalysisStore({
+      analysis: {
+        analysis: {
+          ...emptyAnalysis(),
+          tokenAnalyses: [ta1, ta2],
+          tokenAnalysisLinks: [
+            {
+              analysisId: 'ta-1',
+              status: 'approved',
+              token: { tokenRef: 'tok-1', surfaceText: 'cats' },
+            },
+            {
+              analysisId: 'ta-2',
+              status: 'approved',
+              token: { tokenRef: 'tok-2', surfaceText: 'cats' },
+            },
+          ],
+        },
+        analysisLanguage: 'und',
+      },
+    });
+
+    store.dispatch(writeMorphemeGloss({ tokenRef: 'tok-1', morphemeId: 'm-1', value: 'feline' }));
+
+    const { tokenAnalyses, tokenAnalysisLinks } = store.getState().analysis.analysis;
+    expect(tokenAnalyses).toHaveLength(1);
+    expect(tokenAnalysisLinks).toHaveLength(2);
+    expect(tokenAnalysisLinks.every((l) => l.analysisId === tokenAnalyses[0].id)).toBe(true);
+  });
+
+  it('re-converges onto an identical sibling after clearing a morpheme gloss', () => {
+    // Two payloads for "cats" differ only in that tok-1's morpheme-0 carries a stray gloss; clearing
+    // it makes the two payloads content-identical, so they should collapse back onto one — the clear
+    // path must re-converge symmetrically with the write path, not leave a duplicate behind.
+    const ta1: TokenAnalysis = {
+      id: 'ta-1',
+      surfaceText: 'cats',
+      morphemes: [
+        { id: 'm-1', form: 'cat', writingSystem: 'und', gloss: { und: 'feline' } },
+        { id: 'm-2', form: '-s', writingSystem: 'und', gloss: { und: 'PL' } },
+      ],
+    };
+    const ta2: TokenAnalysis = {
+      id: 'ta-2',
+      surfaceText: 'cats',
+      morphemes: [
+        { id: 'm-3', form: 'cat', writingSystem: 'und' },
+        { id: 'm-4', form: '-s', writingSystem: 'und', gloss: { und: 'PL' } },
+      ],
+    };
+    const store = createAnalysisStore({
+      analysis: {
+        analysis: {
+          ...emptyAnalysis(),
+          tokenAnalyses: [ta1, ta2],
+          tokenAnalysisLinks: [
+            {
+              analysisId: 'ta-1',
+              status: 'approved',
+              token: { tokenRef: 'tok-1', surfaceText: 'cats' },
+            },
+            {
+              analysisId: 'ta-2',
+              status: 'approved',
+              token: { tokenRef: 'tok-2', surfaceText: 'cats' },
+            },
+          ],
+        },
+        analysisLanguage: 'und',
+      },
+    });
+
+    store.dispatch(writeMorphemeGloss({ tokenRef: 'tok-1', morphemeId: 'm-1', value: '' }));
+
+    const { tokenAnalyses, tokenAnalysisLinks } = store.getState().analysis.analysis;
+    expect(tokenAnalyses).toHaveLength(1);
+    expect(tokenAnalysisLinks).toHaveLength(2);
+    expect(tokenAnalysisLinks.every((l) => l.analysisId === tokenAnalyses[0].id)).toBe(true);
+  });
 });
 
 describe('selectApprovedMorphemes', () => {

src/store/analysisSlice.ts

@@ -616,6 +616,11 @@ const analysisSlice = createSlice({
      * itself is kept (a breakdown is content in its own right), so unlike `writeGloss` this never
      * removes the enclosing analysis.
      *
+     * Both the write and the clear are identity-changing edits, so each re-converges onto an
+     * existing content-identical payload ({@link mergeIntoIdenticalPayload}) — keeping the create
+     * path's dedupe invariant symmetric across both directions, so a clear back to a sibling's
+     * state never leaves a duplicate.
+     *
      * @param state - Current slice state (Immer draft).
      * @param action - Action carrying the morpheme gloss payload.
      */
@@ -635,11 +640,23 @@ const analysisSlice = createSlice({
           delete morpheme.gloss[lang];
           if (Object.keys(morpheme.gloss).length === 0) delete morpheme.gloss;
         }
+        // Clearing a morpheme gloss is itself an identity-changing edit: dropping the gloss can make
+        // this payload identical to a sibling whose only difference was that gloss, so re-converge
+        // here too — the write branch below does the same. Without this the dedupe is asymmetric
+        // (an edit re-merges, a clear back to the sibling's state leaves a duplicate the suggestion
+        // pool would double-count), and unlike writeGloss this clear keeps the morpheme record, so
+        // the duplicate payload survives rather than being reclaimed.
+        mergeIntoIdenticalPayload(state, resolved.analysis);
         return;
       }
 
       if (!morpheme.gloss) morpheme.gloss = {};
       morpheme.gloss[lang] = value;
+      // A morpheme gloss is part of analysis identity (see analysesAreIdentical), so editing one
+      // in place can make this payload identical to an existing one (e.g. a homograph whose only
+      // difference was this morpheme's gloss); re-converge so the dedupe the create path guarantees
+      // on first write also holds after morpheme gloss edits (mirrors writeGloss/writeMorphemes).
+      mergeIntoIdenticalPayload(state, resolved.analysis);
     },
     forkAnalysisForToken: {
       /**