decap-cms-backend-github 3.8.2 → 3.8.3

package/dist/esm/API.js

@@ -8,7 +8,7 @@ import trimStart from 'lodash/trimStart';
 import trim from 'lodash/trim';
 import { oneLine } from 'common-tags';
 import { dirname } from 'path';
-import { getAllResponses, APIError, EditorialWorkflowError, localForage, basename, readFileMetadata, CMS_BRANCH_PREFIX, generateContentKey, DEFAULT_PR_BODY, MERGE_COMMIT_MESSAGE, PreviewState, parseContentKey, branchFromContentKey, isCMSLabel, labelToStatus, statusToLabel, contentKeyFromBranch, requestWithBackoff, unsentRequest, throwOnConflictingBranches } from 'decap-cms-lib-util';
+import { formatNoteBody, commentToNote, commentsToNotes, getAllResponses, APIError, EditorialWorkflowError, localForage, basename, readFileMetadata, CMS_BRANCH_PREFIX, generateContentKey, DEFAULT_PR_BODY, MERGE_COMMIT_MESSAGE, PreviewState, parseContentKey, branchFromContentKey, isCMSLabel, labelToStatus, statusToLabel, contentKeyFromBranch, requestWithBackoff, unsentRequest, throwOnConflictingBranches } from 'decap-cms-lib-util';
 export const API_NAME = 'GitHub';
 const {
   fetchWithTimeout: fetch
@@ -1220,44 +1220,14 @@ export default class API {
   /**
    * Constants for note formatting to aid with PR comment to note conversion
    */
-  static NOTE_STATUS_RESOLVED = 'RESOLVED';
-  static NOTE_STATUS_OPEN = 'OPEN';
   static NOTES_LABEL = 'decap-cms-notes';
   static NOTE_ISSUE_PREFIX = 'Notes: ';
-  // In Github we hide Decap Notes metadata in a HTML comment, that way we can track status of whether or not a note has been resolved (similar to GDocs)
-  static NOTE_REGEX = /^<!-- DecapCMS Note - Status: (RESOLVED|OPEN) -->([\s\S]+)$/;
-
-  /**
-   * Format a note for PR comment display
-   */
-  formatNoteForGithub(note) {
-    const status = note.resolved ? API.NOTE_STATUS_RESOLVED : API.NOTE_STATUS_OPEN;
-    return `<!-- DecapCMS Note - Status: ${status} -->
-${note.content}`;
-  }
 
   /**
    * Parse a GitHub comment into a Note object
    */
   parseCommentToNote(comment) {
-    if (!comment || !comment.body || !comment.user) {
-      throw new Error('Invalid comment structure');
-    }
-    const structuredMatch = comment.body.match(API.NOTE_REGEX);
-    const content = structuredMatch ? structuredMatch[2].trim() : comment.body;
-    const resolved = structuredMatch ? structuredMatch[1] === API.NOTE_STATUS_RESOLVED : false;
-    if (!content.trim()) {
-      throw new Error('Empty note content');
-    }
-    return {
-      id: comment.id.toString(),
-      author: comment.user.login,
-      avatarUrl: comment.user.avatar_url,
-      timestamp: comment.created_at,
-      content,
-      resolved,
-      entrySlug: ''
-    };
+    return commentToNote(comment);
   }
 
   /**
@@ -1304,13 +1274,13 @@ ${note.content}`;
    */
   async getIssueWithETag(issueNumber, etag) {
     try {
-      const headers = {
-        Authorization: `${this.tokenKeyword} ${this.token}`
-      };
-      if (etag) {
-        headers['If-None-Match'] = etag;
-      }
-      const response = await fetch(`${this.apiRoot}${this.repoURL}/issues/${issueNumber}`, {
+      // Raw fetch because `request` parses the body and drops the ETag header.
+      // Still built through urlFor/requestHeaders so subclasses can scope it to
+      // their own proxy; hand-building the URL and auth header breaks them.
+      const headers = await this.requestHeaders(etag ? {
+        'If-None-Match': etag
+      } : {});
+      const response = await fetch(this.urlFor(`${this.repoURL}/issues/${issueNumber}`, {}), {
         headers
       });
       if (response.status === 304) {
@@ -1321,10 +1291,7 @@ ${note.content}`;
       if (response.status === 200) {
         const issue = await response.json();
         const newETag = response.headers.get('ETag');
-        const commentsResponse = await fetch(`${this.apiRoot}${this.repoURL}/issues/${issueNumber}/comments`, {
-          headers
-        });
-        const commentsRaw = await commentsResponse.json();
+        const commentsRaw = await this.getIssueComments(issueNumber);
         const comments = commentsRaw.map(comment => ({
           id: comment.id,
           body: comment.body,
@@ -1372,14 +1339,23 @@ ${note.content}`;
   /**
    * Get comments from a GitHub issue
    */
+  /**
+   * Paged, because this endpoint defaults to 30 per page - a thread past that
+   * silently lost its older notes, in the pane and in polling alike.
+   *
+   * Errors propagate deliberately. Returning an empty list on a failed request
+   * is indistinguishable from a thread whose comments were all deleted: the
+   * polling manager would diff against it, emit `comment_deleted` for every
+   * note and blank the pane, then restore them on the next poll. Throwing
+   * leaves the manager's last state alone and lets it retry.
+   */
   async getIssueComments(issueNumber) {
-    try {
-      const response = await this.request(`${this.repoURL}/issues/${issueNumber}/comments`);
-      return Array.isArray(response) ? response : [];
-    } catch (error) {
-      console.error('Failed to get issue comments:', error);
-      return [];
-    }
+    const response = await this.requestAllPages(`${this.repoURL}/issues/${issueNumber}/comments`, {
+      params: {
+        per_page: 100
+      }
+    });
+    return Array.isArray(response) ? response : [];
   }
 
   /**
@@ -1390,7 +1366,7 @@ ${note.content}`;
       const response = await this.request(`${this.repoURL}/issues/${issueNumber}/comments`, {
         method: 'POST',
         body: JSON.stringify({
-          body: this.formatNoteForGithub(note)
+          body: formatNoteBody(note)
         })
       });
       return response.id.toString();
@@ -1408,7 +1384,7 @@ ${note.content}`;
       await this.request(`${this.repoURL}/issues/comments/${commentId}`, {
         method: 'PATCH',
         body: JSON.stringify({
-          body: this.formatNoteForGithub(note)
+          body: formatNoteBody(note)
         })
       });
     } catch (error) {
@@ -1497,11 +1473,8 @@ ${note.content}`;
       const comments = await this.getIssueComments(issue.number);
       const issueUrl = issue.html_url; // Get the issue URL once
 
-      // Add issueUrl to each note
-      return comments.map(comment => ({
-        ...this.parseCommentToNote(comment),
-        issueUrl // Add the issue URL to each note (this info is picked up by the UI to direct users to the source of the Notes in Github)
-      }));
+      // Add issueUrl to each note (this info is picked up by the UI to direct users to the source of the Notes in Github)
+      return commentsToNotes(comments, issueUrl, comment => this.parseCommentToNote(comment));
     } catch (error) {
       console.error('Failed to get entry notes:', error);
       return [];

package/dist/esm/implementation.js

@@ -1,10 +1,9 @@
 import semaphore from 'semaphore';
 import trimStart from 'lodash/trimStart';
 import { stripIndent } from 'common-tags';
-import { CURSOR_COMPATIBILITY_SYMBOL, Cursor, asyncLock, basename, getBlobSHA, entriesByFolder, entriesByFiles, unpublishedEntries, getMediaDisplayURL, getMediaAsBlob, filterByExtension, getPreviewStatus, runWithLock, blobToFileObj, contentKeyFromBranch, unsentRequest, branchFromContentKey } from 'decap-cms-lib-util';
+import { CURSOR_COMPATIBILITY_SYMBOL, Cursor, asyncLock, basename, getBlobSHA, entriesByFolder, entriesByFiles, unpublishedEntries, getMediaDisplayURL, getMediaAsBlob, filterByExtension, getPreviewStatus, runWithLock, blobToFileObj, contentKeyFromBranch, unsentRequest, branchFromContentKey, NotesPollingManager, markOwnNotes } from 'decap-cms-lib-util';
 import AuthenticationPage from './AuthenticationPage';
 import API, { API_NAME } from './API';
-import { ETagPollingManager } from './polling';
 import GraphQLAPI from './GraphQLAPI';
 import { jsx as _jsx } from "@emotion/react/jsx-runtime";
 const MAX_CONCURRENT_DOWNLOADS = 10;
@@ -292,7 +291,7 @@ export default class GitHub {
     // }
 
     if (this.api && !this.pollingManager) {
-      this.pollingManager = new ETagPollingManager(this.api, 15000);
+      this.pollingManager = new NotesPollingManager(this.api, 15000);
     }
     // Authorized user
     return {
@@ -624,43 +623,61 @@ export default class GitHub {
 
   // Notes implementation, which is an abstraction to Github's PR issue comments.
 
+  /**
+   * Who the signed-in editor is, as a note records them: a display name for the
+   * pane and a stable id for the ownership check behind Edit/Resolve/Delete.
+   */
+  async noteAuthorIdentity() {
+    const currentUser = await this.currentUser({
+      token: this.token
+    });
+    return {
+      author: currentUser.login || currentUser.name || '',
+      // No id on purpose: GitHub reports the author's current login on every
+      // read, so ownership follows a rename. Recording it here would freeze it.
+      authorId: undefined
+    };
+  }
+
+  /**
+   * Resolves each note's `isOwn` here rather than in the pane, because only the
+   * backend knows how its identities compare. Falls back to the display name
+   * for notes with no recorded id.
+   */
+  async markOwnNotes(notes) {
+    return markOwnNotes(notes, await this.noteAuthorIdentity());
+  }
+
   // Notes implementation using GitHub Issues
   async getNotes(collection, slug) {
     try {
       const notes = await this.api.getEntryNotes(collection, slug);
-      return notes.map(note => ({
+      return this.markOwnNotes(notes.map(note => ({
         ...note,
         entrySlug: slug
-      }));
+      })));
     } catch (error) {
       console.error('Failed to get notes:', error);
       return [];
     }
   }
-  async addNote(collection, slug, noteData) {
+  async addNote(collection, slug, noteData, entryTitle) {
     const currentUser = await this.currentUser({
       token: this.token
     });
+    const identity = await this.noteAuthorIdentity();
     const note = {
       ...noteData,
       id: 'temp-' + Date.now(),
-      author: currentUser.login || currentUser.name || '',
+      author: identity.author,
+      authorId: identity.authorId,
+      isOwn: true,
       avatarUrl: currentUser.avatar_url,
       entrySlug: slug,
       timestamp: noteData.timestamp || new Date().toISOString(),
       resolved: noteData.resolved || false,
       issueUrl: undefined
     };
-
-    // Get entry title for better issue naming
-    let entryTitle;
-    try {
-      const entryData = await this.getEntry(`${collection}/${slug}.md`);
-      const titleMatch = entryData.data.match(/^title:\s*["']?([^"'\n]+)["']?/m);
-      entryTitle = titleMatch ? titleMatch[1] : undefined;
-    } catch (error) {
-      // Entry not found or error reading, use undefined title
-    }
     const {
       commentId,
       issueUrl
@@ -730,7 +747,14 @@ export default class GitHub {
       this.unwatchFunctions.delete(issueKey);
     }
     try {
-      const unwatchFn = await this.pollingManager.watchIssueWithRetry(collection, slug, callbacks, 5,
+      const unwatchFn = await this.pollingManager.watchIssueWithRetry(collection, slug, {
+        ...callbacks,
+        // The polling manager rebuilds notes straight from the issue's
+        // comments, so they arrive without the ownership flag getNotes adds.
+        // Without this, a poll silently strips Edit/Resolve/Delete off the
+        // editor's own notes ~15s after they appear.
+        prepareNotes: notes => this.markOwnNotes(notes)
+      }, 5,
       // maxRetries - will try up to 5 times
       2000 // retryDelay - 2 seconds between attempts
       );
@@ -754,9 +778,8 @@ export default class GitHub {
     if (unwatchFn) {
       unwatchFn();
       this.unwatchFunctions.delete(issueKey);
-    } else {
-      console.log(`[DecapNotes Polling] No active polling found for ${issueKey}`);
     }
+    this.pollingManager?.stopWatching(collection, slug);
   }
 
   /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "decap-cms-backend-github",
   "description": "GitHub backend for Decap CMS",
-  "version": "3.8.2",
+  "version": "3.8.3",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -35,7 +35,7 @@
     "prop-types": "^15.7.2",
     "react": "^19.1.0",
     "decap-cms-lib-auth": "3.3.2",
-    "decap-cms-lib-util": "3.8.2",
+    "decap-cms-lib-util": "3.8.3",
     "decap-cms-ui-default": "3.9.2"
   },
   "browser": {

package/src/API.ts

@@ -9,6 +9,9 @@ import trim from 'lodash/trim';
 import { oneLine } from 'common-tags';
 import { dirname } from 'path';
 import {
+  formatNoteBody,
+  commentToNote,
+  commentsToNotes,
   getAllResponses,
   APIError,
   EditorialWorkflowError,
@@ -1555,50 +1558,14 @@ export default class API {
   /**
    * Constants for note formatting to aid with PR comment to note conversion
    */
-  private static readonly NOTE_STATUS_RESOLVED = 'RESOLVED';
-  private static readonly NOTE_STATUS_OPEN = 'OPEN';
   private static readonly NOTES_LABEL = 'decap-cms-notes';
   private static readonly NOTE_ISSUE_PREFIX = 'Notes: ';
-  // In Github we hide Decap Notes metadata in a HTML comment, that way we can track status of whether or not a note has been resolved (similar to GDocs)
-  private static readonly NOTE_REGEX =
-    /^<!-- DecapCMS Note - Status: (RESOLVED|OPEN) -->([\s\S]+)$/;
-
-  /**
-   * Format a note for PR comment display
-   */
-  private formatNoteForGithub(note: Note): string {
-    const status = note.resolved ? API.NOTE_STATUS_RESOLVED : API.NOTE_STATUS_OPEN;
-
-    return `<!-- DecapCMS Note - Status: ${status} -->
-${note.content}`;
-  }
 
   /**
    * Parse a GitHub comment into a Note object
    */
-  parseCommentToNote(comment: GitHubIssue): Note {
-    if (!comment || !comment.body || !comment.user) {
-      throw new Error('Invalid comment structure');
-    }
-
-    const structuredMatch = comment.body.match(API.NOTE_REGEX);
-
-    const content = structuredMatch ? structuredMatch[2].trim() : comment.body;
-    const resolved = structuredMatch ? structuredMatch[1] === API.NOTE_STATUS_RESOLVED : false;
-
-    if (!content.trim()) {
-      throw new Error('Empty note content');
-    }
-
-    return {
-      id: comment.id.toString(),
-      author: comment.user.login,
-      avatarUrl: comment.user.avatar_url,
-      timestamp: comment.created_at,
-      content,
-      resolved,
-      entrySlug: '',
-    };
+  parseCommentToNote(comment: CommentData): Note {
+    return commentToNote(comment);
   }
 
   /**
@@ -1657,15 +1624,14 @@ ${note.content}`;
     | { status: 200; data: IssueState; etag: string | null }
   > {
     try {
-      const headers: Record<string, string> = {
-        Authorization: `${this.tokenKeyword} ${this.token}`,
-      };
-
-      if (etag) {
-        headers['If-None-Match'] = etag;
-      }
+      // Raw fetch because `request` parses the body and drops the ETag header.
+      // Still built through urlFor/requestHeaders so subclasses can scope it to
+      // their own proxy; hand-building the URL and auth header breaks them.
+      const headers: Record<string, string> = await this.requestHeaders(
+        etag ? { 'If-None-Match': etag } : {},
+      );
 
-      const response = await fetch(`${this.apiRoot}${this.repoURL}/issues/${issueNumber}`, {
+      const response = await fetch(this.urlFor(`${this.repoURL}/issues/${issueNumber}`, {}), {
         headers,
       });
 
@@ -1677,11 +1643,7 @@ ${note.content}`;
         const issue = await response.json();
         const newETag = response.headers.get('ETag');
 
-        const commentsResponse = await fetch(
-          `${this.apiRoot}${this.repoURL}/issues/${issueNumber}/comments`,
-          { headers },
-        );
-        const commentsRaw: GitHubIssue[] = await commentsResponse.json();
+        const commentsRaw = await this.getIssueComments(issueNumber);
 
         const comments: CommentData[] = commentsRaw.map(comment => ({
           id: comment.id,
@@ -1731,16 +1693,23 @@ ${note.content}`;
   /**
    * Get comments from a GitHub issue
    */
+  /**
+   * Paged, because this endpoint defaults to 30 per page - a thread past that
+   * silently lost its older notes, in the pane and in polling alike.
+   *
+   * Errors propagate deliberately. Returning an empty list on a failed request
+   * is indistinguishable from a thread whose comments were all deleted: the
+   * polling manager would diff against it, emit `comment_deleted` for every
+   * note and blank the pane, then restore them on the next poll. Throwing
+   * leaves the manager's last state alone and lets it retry.
+   */
   private async getIssueComments(issueNumber: number): Promise<GitHubIssue[]> {
-    try {
-      const response: GitHubIssue[] = await this.request(
-        `${this.repoURL}/issues/${issueNumber}/comments`,
-      );
-      return Array.isArray(response) ? response : [];
-    } catch (error) {
-      console.error('Failed to get issue comments:', error);
-      return [];
-    }
+    const response = await this.requestAllPages<GitHubIssue>(
+      `${this.repoURL}/issues/${issueNumber}/comments`,
+      { params: { per_page: 100 } },
+    );
+
+    return Array.isArray(response) ? response : [];
   }
 
   /**
@@ -1753,7 +1722,7 @@ ${note.content}`;
         {
           method: 'POST',
           body: JSON.stringify({
-            body: this.formatNoteForGithub(note),
+            body: formatNoteBody(note),
           }),
         },
       );
@@ -1773,7 +1742,7 @@ ${note.content}`;
       await this.request(`${this.repoURL}/issues/comments/${commentId}`, {
         method: 'PATCH',
         body: JSON.stringify({
-          body: this.formatNoteForGithub(note),
+          body: formatNoteBody(note),
         }),
       });
     } catch (error) {
@@ -1866,11 +1835,8 @@ ${note.content}`;
       const comments = await this.getIssueComments(issue.number);
       const issueUrl = issue.html_url; // Get the issue URL once
 
-      // Add issueUrl to each note
-      return comments.map(comment => ({
-        ...this.parseCommentToNote(comment),
-        issueUrl, // Add the issue URL to each note (this info is picked up by the UI to direct users to the source of the Notes in Github)
-      }));
+      // Add issueUrl to each note (this info is picked up by the UI to direct users to the source of the Notes in Github)
+      return commentsToNotes(comments, issueUrl, comment => this.parseCommentToNote(comment));
     } catch (error) {
       console.error('Failed to get entry notes:', error);
       return [];

package/src/__tests__/API.spec.js

@@ -1,4 +1,5 @@
 import { Base64 } from 'js-base64';
+import { formatNoteBody } from 'decap-cms-lib-util';
 
 import API from '../API';
 
@@ -842,4 +843,76 @@ describe('github API', () => {
     expect(api.request).toHaveBeenCalledTimes(1);
     expect(api.request).toHaveBeenCalledWith(`/repos/repo/commits/${sha}/status`);
   });
+
+  describe('parseCommentToNote', () => {
+    // The body encoding itself is lib-util's (see notesFormat.spec); what is
+    // GitHub's is how a comment maps onto a note when the marker is silent.
+    function api() {
+      return new API({ repo: 'owner/repo' });
+    }
+
+    function asComment(body) {
+      return {
+        id: 7,
+        body,
+        user: { login: 'decap-turbo[bot]', avatar_url: 'https://avatar' },
+        created_at: '2026-01-01T00:00:00Z',
+      };
+    }
+
+    it('falls back to the comment account when the note records no author', () => {
+      const note = api().parseCommentToNote(asComment('just a comment'));
+
+      expect(note.author).toBe('decap-turbo[bot]');
+      expect(note.authorId).toBeUndefined();
+      expect(note.avatarUrl).toBe('https://avatar');
+      expect(note.content).toBe('just a comment');
+    });
+
+    it('prefers the recorded author, and drops the poster avatar with it', () => {
+      // A recorded author means the account that posted is not the person, so
+      // its avatar would mislabel the note. The pane shows initials instead.
+      const body = formatNoteBody({
+        content: 'hello',
+        resolved: false,
+        author: 'Decap Tester',
+        authorId: 'u-1',
+      });
+
+      const note = api().parseCommentToNote(asComment(body));
+
+      expect(note.author).toBe('Decap Tester');
+      expect(note.authorId).toBe('u-1');
+      expect(note.avatarUrl).toBeUndefined();
+    });
+
+    it('rejects a note whose body is only the marker', () => {
+      expect(() =>
+        api().parseCommentToNote(asComment('<!-- DecapCMS Note {"resolved":false} -->\n   ')),
+      ).toThrow('Empty note content');
+    });
+
+    it('rejects a malformed comment', () => {
+      expect(() => api().parseCommentToNote({ id: 1 })).toThrow('Invalid comment structure');
+    });
+  });
+
+  describe('getEntryNotes', () => {
+    it('skips a marker-only comment instead of blanking the whole thread', async () => {
+      const api = new API({ repo: 'owner/repo' });
+      const user = { login: 'ada', avatar_url: 'https://avatar' };
+
+      api.findEntryIssue = jest.fn().mockResolvedValue({ number: 3, html_url: 'https://issue' });
+      api.requestAllPages = jest.fn().mockResolvedValue([
+        { id: 1, body: 'first', user, created_at: '2026-01-01T00:00:00Z' },
+        { id: 2, body: '<!-- DecapCMS Note {"resolved":false} -->\n', user, created_at: '' },
+        { id: 3, body: 'third', user, created_at: '2026-01-03T00:00:00Z' },
+      ]);
+
+      const notes = await api.getEntryNotes('posts', 'my-post');
+
+      expect(notes.map(note => note.id)).toEqual(['1', '3']);
+      expect(notes[0].issueUrl).toBe('https://issue');
+    });
+  });
 });

package/src/__tests__/implementation.spec.js

@@ -392,6 +392,9 @@ describe('github backend implementation', () => {
         const gitHubImplementation = new GitHubImplementation(configWithNotes);
         gitHubImplementation.api = mockAPI;
 
+        gitHubImplementation.token = 'test-token';
+        gitHubImplementation.currentUser = jest.fn().mockResolvedValue({ login: 'user1' });
+
         const mockNotes = [
           {
             id: '1',
@@ -411,6 +414,7 @@ describe('github backend implementation', () => {
           {
             ...mockNotes[0],
             entrySlug: 'my-post',
+            isOwn: true,
           },
         ]);
         expect(mockAPI.getEntryNotes).toHaveBeenCalledWith('posts', 'my-post');
@@ -450,9 +454,13 @@ describe('github backend implementation', () => {
           commentId: 'comment-123',
           issueUrl: 'https://github.com/owner/repo/issues/1',
         });
-        mockAPI.readFile.mockResolvedValue('title: My Post Title\n\nContent');
 
-        const result = await gitHubImplementation.addNote('posts', 'my-post', noteData);
+        const result = await gitHubImplementation.addNote(
+          'posts',
+          'my-post',
+          noteData,
+          'My Post Title',
+        );
 
         expect(result).toMatchObject({
           text: 'New note',
@@ -471,9 +479,15 @@ describe('github backend implementation', () => {
           }),
           'My Post Title',
         );
+        // The title arrives from the caller; nothing is read back from the repo.
+        expect(mockAPI.readFile).not.toHaveBeenCalled();
       });
 
-      it('should handle missing entry title gracefully', async () => {
+      // The caller cannot always name the entry — a note added from outside the
+      // open editor has no draft to read a title off — so the thread falls back
+      // to `collection/slug`, which is what it always did when the (broken)
+      // lookup failed.
+      it('passes no title through when the caller has none', async () => {
         const gitHubImplementation = new GitHubImplementation(config);
         gitHubImplementation.api = mockAPI;
         gitHubImplementation.token = 'test-token';
@@ -491,7 +505,6 @@ describe('github backend implementation', () => {
           commentId: 'comment-123',
           issueUrl: 'https://github.com/owner/repo/issues/1',
         });
-        mockAPI.readFile.mockRejectedValue(new Error('Not found'));
 
         const result = await gitHubImplementation.addNote('posts', 'my-post', noteData);
 
@@ -509,6 +522,8 @@ describe('github backend implementation', () => {
       it('should update an existing note', async () => {
         const gitHubImplementation = new GitHubImplementation(config);
         gitHubImplementation.api = mockAPI;
+        gitHubImplementation.token = 'test-token';
+        gitHubImplementation.currentUser = jest.fn().mockResolvedValue({ login: 'user1' });
 
         const existingNotes = [
           {
@@ -532,6 +547,7 @@ describe('github backend implementation', () => {
           ...existingNotes[0],
           text: 'Updated text',
           resolved: true,
+          isOwn: true,
         });
         expect(mockAPI.updateEntryNote).toHaveBeenCalledWith('note-1', result);
       });
@@ -714,15 +730,37 @@ describe('github backend implementation', () => {
           onChange: jest.fn(),
         };
 
+        gitHubImplementation.token = 'test-token';
+        gitHubImplementation.currentUser = jest.fn().mockResolvedValue({ login: 'user1' });
+
         await gitHubImplementation.startNotesPolling('posts', 'my-post', callbacks);
 
         expect(gitHubImplementation.pollingManager.watchIssueWithRetry).toHaveBeenCalledWith(
           'posts',
           'my-post',
-          callbacks,
+          expect.objectContaining({
+            onUpdate: callbacks.onUpdate,
+            onChange: callbacks.onChange,
+            prepareNotes: expect.any(Function),
+          }),
           5,
           2000,
         );
+
+        // The polling manager rebuilds notes from the issue's comments, so they
+        // arrive with no ownership flag. Without prepareNotes a poll would strip
+        // Edit/Resolve/Delete off the editor's own notes ~15s after they show.
+        const [, , passedCallbacks] =
+          gitHubImplementation.pollingManager.watchIssueWithRetry.mock.calls[0];
+        const prepared = await passedCallbacks.prepareNotes([
+          { id: '1', author: 'user1', content: 'mine', resolved: false },
+          { id: '2', author: 'someone-else', content: 'theirs', resolved: false },
+        ]);
+
+        expect(prepared).toEqual([
+          expect.objectContaining({ id: '1', isOwn: true }),
+          expect.objectContaining({ id: '2', isOwn: false }),
+        ]);
       });
 
       it('should not start polling if already watching same entry', async () => {
@@ -796,10 +834,16 @@ describe('github backend implementation', () => {
 
         await gitHubImplementation.startNotesPolling('posts', 'my-post', callbacks);
 
+        // The callbacks are passed straight through; prepareNotes is added so
+        // polled notes get the same ownership flag getNotes applies.
         expect(gitHubImplementation.pollingManager.watchIssueWithRetry).toHaveBeenCalledWith(
           'posts',
           'my-post',
-          callbacks,
+          expect.objectContaining({
+            onUpdate: callbacks.onUpdate,
+            onChange: callbacks.onChange,
+            prepareNotes: expect.any(Function),
+          }),
           5,
           2000,
         );