From 67187bb6a3ab2085f0f71ce5b272f4c0c58afa58 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Sat, 26 Jul 2025 17:35:55 +0100
Subject: [PATCH 01/40] feat: added interface for EditorNotesPane

---
 .../src/components/Editor/EditorInterface.js  |  89 +++++-
 .../Editor/EditorNotesPane/AddNoteForm.js     | 162 +++++++++++
 .../Editor/EditorNotesPane/EditorNotesPane.js | 164 ++++++++++++
 .../Editor/EditorNotesPane/NoteItem.js        | 253 ++++++++++++++++++
 .../Editor/EditorNotesPane/NotesList.js       |  50 ++++
 packages/decap-cms-locales/src/en/index.js    |  15 ++
 6 files changed, 730 insertions(+), 3 deletions(-)
 create mode 100644 packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js
 create mode 100644 packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js
 create mode 100644 packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js
 create mode 100644 packages/decap-cms-core/src/components/Editor/EditorNotesPane/NotesList.js

diff --git a/packages/decap-cms-core/src/components/Editor/EditorInterface.js b/packages/decap-cms-core/src/components/Editor/EditorInterface.js
index cad473866aa2..02f5b2f961f2 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorInterface.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorInterface.js
@@ -16,12 +16,14 @@ import { ScrollSync, ScrollSyncPane } from 'react-scroll-sync';
 
 import EditorControlPane from './EditorControlPane/EditorControlPane';
 import EditorPreviewPane from './EditorPreviewPane/EditorPreviewPane';
+import EditorNotesPane from './EditorNotesPane/EditorNotesPane';
 import EditorToolbar from './EditorToolbar';
 import { hasI18n, getI18nInfo, getPreviewEntry } from '../../lib/i18n';
 import { FILES } from '../../constants/collectionTypes';
 import { getFileFromSlug } from '../../reducers/collections';
 
 const PREVIEW_VISIBLE = 'cms.preview-visible';
+const NOTES_VISIBLE = 'cms.notes-visible';
 const SCROLL_SYNC_ENABLED = 'cms.scroll-sync-enabled';
 const SPLIT_PANE_POSITION = 'cms.split-pane-position';
 const I18N_VISIBLE = 'cms.i18n-visible';
@@ -122,6 +124,12 @@ const ControlPaneContainer = styled(PreviewPaneContainer)`
   overflow-x: hidden;
 `;
 
+const NotesPaneContainer = styled.div`
+  height: 100%;
+  pointer-events: ${props => (props.blockEntry ? 'none' : 'auto')};
+  overflow: hidden;
+`;
+
 const ViewControls = styled.div`
   position: absolute;
   top: 10px;
@@ -132,12 +140,16 @@ const ViewControls = styled.div`
 function EditorContent({
   i18nVisible,
   previewVisible,
+  notesVisible,
   editor,
   editorWithEditor,
   editorWithPreview,
+  editorWithNotes,
 }) {
   if (i18nVisible) {
     return editorWithEditor;
+  } else if (notesVisible) {
+    return editorWithNotes;
   } else if (previewVisible) {
     return editorWithPreview;
   } else {
@@ -154,10 +166,20 @@ function isPreviewEnabled(collection, entry) {
   return collection.getIn(['editor', 'preview'], true);
 }
 
+function isNotesEnabled(collection, entry) {
+  if (collection.get('type') === FILES) {
+    const file = getFileFromSlug(collection, entry.get('slug'));
+    const notesEnabled = file?.getIn(['editor', 'notes']);
+    if (notesEnabled != null) return notesEnabled;
+  }
+  return collection.getIn(['editor', 'notes'], true);
+}
+
 class EditorInterface extends Component {
   state = {
     showEventBlocker: false,
     previewVisible: localStorage.getItem(PREVIEW_VISIBLE) !== 'false',
+    notesVisible: localStorage.getItem(NOTES_VISIBLE) === 'false',
     scrollSyncEnabled: localStorage.getItem(SCROLL_SYNC_ENABLED) !== 'false',
     i18nVisible: localStorage.getItem(I18N_VISIBLE) !== 'false',
   };
@@ -190,8 +212,27 @@ class EditorInterface extends Component {
 
   handleTogglePreview = () => {
     const newPreviewVisible = !this.state.previewVisible;
-    this.setState({ previewVisible: newPreviewVisible });
+    this.setState({ 
+      previewVisible: newPreviewVisible,
+      notesVisible: false, // Hide notes when showing preview
+    });
     localStorage.setItem(PREVIEW_VISIBLE, newPreviewVisible);
+    localStorage.setItem(NOTES_VISIBLE, 'false');
+  };
+
+  handleToggleNotes = () => {
+    const newNotesVisible = !this.state.notesVisible;
+    this.setState({ 
+      notesVisible: newNotesVisible,
+      previewVisible: false, // Hide preview when showing notes
+    });
+    localStorage.setItem(NOTES_VISIBLE, newNotesVisible);
+    localStorage.setItem(PREVIEW_VISIBLE, 'false');
+  };
+
+  handleNotesChange = (action, payload) => {
+    console.log('Notes change:', action, payload);
+    // TODO: Implement with Redux actions
   };
 
   handleToggleScrollSync = () => {
@@ -246,6 +287,7 @@ class EditorInterface extends Component {
     const { scrollSyncEnabled, showEventBlocker } = this.state;
 
     const previewEnabled = isPreviewEnabled(collection, entry);
+    const notesEnabled = isNotesEnabled(collection, entry);
 
     const { locales, defaultLocale } = getI18nInfo(this.props.collection);
     const collectionI18nEnabled = hasI18n(collection) && locales.length > 1;
@@ -310,6 +352,33 @@ class EditorInterface extends Component {
       </ScrollSync>
     );
 
+    const editorWithNotes = (
+      <ScrollSync enabled={this.state.scrollSyncEnabled}>
+        <div>
+          <ReactSplitPaneGlobalStyles />
+          <StyledSplitPane
+            maxSize={-100}
+            minSize={400}
+            defaultSize={parseInt(localStorage.getItem(SPLIT_PANE_POSITION), 10) || '50%'}
+            onChange={size => localStorage.setItem(SPLIT_PANE_POSITION, size)}
+            onDragStarted={this.handleSplitPaneDragStart}
+            onDragFinished={this.handleSplitPaneDragFinished}
+          >
+            <ScrollSyncPane>{editor}</ScrollSyncPane>
+            <NotesPaneContainer blockEntry={showEventBlocker}>
+              <EditorNotesPane
+                notes={this.props.notes}
+                onChange={this.handleNotesChange}
+                entry={entry}
+                collection={collection}
+                t={t}
+              />
+            </NotesPaneContainer>
+          </StyledSplitPane>
+        </div>
+      </ScrollSync>
+    );
+
     const editorWithEditor = (
       <ScrollSync enabled={this.state.scrollSyncEnabled}>
         <div>
@@ -329,7 +398,8 @@ class EditorInterface extends Component {
 
     const i18nVisible = collectionI18nEnabled && this.state.i18nVisible;
     const previewVisible = previewEnabled && this.state.previewVisible;
-    const scrollSyncVisible = i18nVisible || previewVisible;
+    const notesVisible = notesEnabled && this.state.notesVisible;
+    const scrollSyncVisible = i18nVisible || previewVisible || notesVisible;
 
     return (
       <EditorContainer>
@@ -386,6 +456,15 @@ class EditorInterface extends Component {
                 title={t('editor.editorInterface.togglePreview')}
               />
             )}
+            {notesEnabled && (
+              <EditorToggle
+                isActive={notesVisible}
+                onClick={this.handleToggleNotes}
+                size="large"
+                type="page"
+                title={t('editor.editorInterface.toggleNotes')}
+              />
+            )}
             {scrollSyncVisible && !collection.getIn(['editor', 'visualEditing']) && (
               <EditorToggle
                 isActive={scrollSyncEnabled}
@@ -399,9 +478,11 @@ class EditorInterface extends Component {
           <EditorContent
             i18nVisible={i18nVisible}
             previewVisible={previewVisible}
+            notesVisible={notesVisible}
             editor={editor}
             editorWithEditor={editorWithEditor}
             editorWithPreview={editorWithPreview}
+            editorWithNotes={editorWithNotes}
           />
         </Editor>
       </EditorContainer>
@@ -439,6 +520,8 @@ EditorInterface.propTypes = {
   loadDeployPreview: PropTypes.func.isRequired,
   draftKey: PropTypes.string.isRequired,
   t: PropTypes.func.isRequired,
+  notes: ImmutablePropTypes.list,
+  onNotesChange: PropTypes.func,
 };
 
-export default EditorInterface;
+export default EditorInterface;
\ No newline at end of file
diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js
new file mode 100644
index 000000000000..8e872f1e955e
--- /dev/null
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js
@@ -0,0 +1,162 @@
+import PropTypes from 'prop-types';
+import React, { Component } from 'react';
+import styled from '@emotion/styled';
+import { colors, transitions } from 'decap-cms-ui-default';
+
+const FormContainer = styled.div`
+  padding: 16px;
+  border-top: 1px solid ${colors.textFieldBorder};
+  background-color: ${colors.inputBackground};
+`;
+
+const TextArea = styled.textarea`
+  width: 100%;
+  min-height: 80px;
+  padding: 12px;
+  border: 1px solid ${colors.textFieldBorder};
+  border-radius: 4px;
+  font-size: 14px;
+  font-family: inherit;
+  line-height: 1.4;
+  resize: vertical;
+  outline: none;
+  transition: border-color ${transitions.main};
+
+  &:focus {
+    border-color: ${colors.active};
+    box-shadow: 0 0 0 2px rgba(70, 151, 218, 0.1);
+  }
+
+  &::placeholder {
+    color: ${colors.controlLabel};
+  }
+`;
+
+const FormActions = styled.div`
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-top: 8px;
+`;
+
+const AddButton = styled.button`
+  background-color: ${colors.active};
+  color: white;
+  border: none;
+  padding: 8px 16px;
+  border-radius: 4px;
+  font-size: 14px;
+  font-weight: 500;
+  cursor: pointer;
+  transition: all ${transitions.main};
+
+  &:hover:not(:disabled) {
+    background-color: ${colors.activeAccent};
+  }
+
+  &:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+  }
+`;
+
+const CharCount = styled.span`
+  font-size: 12px;
+  color: ${props => props.warn ? colors.errorText : colors.controlLabel};
+`;
+
+const Hint = styled.p`
+  font-size: 12px;
+  color: ${colors.controlLabel};
+  margin: 4px 0 0 0;
+  font-style: italic;
+`;
+
+class AddNoteForm extends Component {
+  static propTypes = {
+    onAdd: PropTypes.func.isRequired,
+    t: PropTypes.func.isRequired,
+  };
+
+  state = {
+    content: '',
+    isFocused: false,
+  };
+
+  maxLength = 1000;
+
+  handleContentChange = (e) => {
+    const content = e.target.value;
+    if (content.length <= this.maxLength) {
+      this.setState({ content });
+    }
+  };
+
+  handleSubmit = (e) => {
+    e.preventDefault();
+    const { content } = this.state;
+    const trimmedContent = content.trim();
+
+    if (trimmedContent) {
+      this.props.onAdd(trimmedContent);
+      this.setState({ content: '', isFocused: false });
+    }
+  };
+
+  handleKeyDown = (e) => {
+    if (e.key === 'Enter' && (e.ctrlKey || e.metaKey)) {
+      e.preventDefault();
+      this.handleSubmit(e);
+    }
+  };
+
+  handleFocus = () => {
+    this.setState({ isFocused: true });
+  };
+
+  handleBlur = () => {
+    // Delay to allow button click to register
+    setTimeout(() => {
+      if (!this.state.content.trim()) {
+        this.setState({ isFocused: false });
+      }
+    }, 150);
+  };
+
+  render() {
+    const { t } = this.props;
+    const { content } = this.state;
+    const charCount = content.length;
+    const canSubmit = content.trim().length > 0;
+    const isNearLimit = charCount > this.maxLength * 0.8;
+
+    return (
+      <FormContainer>
+        <form onSubmit={this.handleSubmit}>
+          <TextArea
+            value={content}
+            onChange={this.handleContentChange}
+            onKeyDown={this.handleKeyDown}
+            onFocus={this.handleFocus}
+            onBlur={this.handleBlur}
+            placeholder={t('editor.editorNotesPane.addPlaceholder')}
+            rows='4'
+          />
+              <FormActions>
+                <CharCount warn={isNearLimit}>
+                  {charCount}/{this.maxLength}
+                </CharCount>
+                <AddButton type="submit" disabled={!canSubmit}>
+                  {t('editor.editorNotesPane.addNote')}
+                </AddButton>
+              </FormActions>
+              <Hint>
+                {t('editor.editorNotesPane.shortcut')}
+              </Hint>
+        </form>
+      </FormContainer>
+    );
+  }
+}
+
+export default AddNoteForm;
\ No newline at end of file
diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js
new file mode 100644
index 000000000000..c7818dba46d7
--- /dev/null
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js
@@ -0,0 +1,164 @@
+import PropTypes from 'prop-types';
+import React, { Component } from 'react';
+import ImmutablePropTypes from 'react-immutable-proptypes';
+import styled from '@emotion/styled';
+import { List } from 'immutable';
+import { colors } from 'decap-cms-ui-default';
+
+import NotesList from './NotesList';
+import AddNoteForm from './AddNoteForm';
+
+const NotesContainer = styled.div`
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+  background-color: ${colors.background};
+  border-left: 1px solid ${colors.textFieldBorder};
+`;
+
+const NotesHeader = styled.div`
+  padding: 16px;
+  border-bottom: 1px solid ${colors.textFieldBorder};
+  background-color: ${colors.inputBackground};
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  min-height: 60px;
+`;
+
+const NotesTitle = styled.h3`
+  margin: 0;
+  font-size: 16px;
+  font-weight: 600;
+  color: ${colors.text};
+`;
+
+const NotesCount = styled.span`
+  background-color: ${colors.controlLabel};
+  color: white;
+  border-radius: 12px;
+  padding: 2px 8px;
+  font-size: 12px;
+  font-weight: 500;
+`;
+
+const NotesContent = styled.div`
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+`;
+
+const EmptyState = styled.div`
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  padding: 40px 20px;
+  color: ${colors.controlLabel};
+  text-align: center;
+`;
+
+const EmptyStateIcon = styled.div`
+  font-size: 48px;
+  margin-bottom: 16px;
+  opacity: 0.5;
+`;
+
+const EmptyStateText = styled.p`
+  font-size: 14px;
+  margin: 0;
+  line-height: 1.4;
+`;
+
+class EditorNotesPane extends Component {
+  static propTypes = {
+    notes: ImmutablePropTypes.list,
+    onChange: PropTypes.func.isRequired,
+    entry: ImmutablePropTypes.map.isRequired,
+    collection: ImmutablePropTypes.map.isRequired,
+    t: PropTypes.func,
+  };
+
+  static defaultProps = {
+    notes: List(),
+    t: key => key, // Fallback translation function
+  };
+
+  handleAddNote = (content) => {
+    const { onChange, entry } = this.props;
+    const newNote = {
+      id: `note_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`,
+      content: content.trim(),
+      timestamp: new Date().toISOString(),
+      author: 'current-user', // TODO: Get from auth state
+      entrySlug: entry.get('slug'),
+      resolved: false,
+    };
+
+    onChange('ADD_NOTE', newNote);
+  };
+
+  handleUpdateNote = (noteId, updates) => {
+    const { onChange } = this.props;
+    onChange('UPDATE_NOTE', { id: noteId, updates });
+  };
+
+  handleDeleteNote = (noteId) => {
+    const { onChange } = this.props;
+    onChange('DELETE_NOTE', { id: noteId });
+  };
+
+  handleResolveNote = (noteId) => {
+    this.handleUpdateNote(noteId, { resolved: true });
+  };
+
+  render() {
+    const { notes, t } = this.props;
+    const notesList = notes || List();
+    const notesCount = notesList.size;
+    const unresolvedCount = notesList.filter(note => !note.get('resolved')).size;
+
+    return (
+      <NotesContainer>
+        <NotesHeader>
+          <NotesTitle>
+            {t('editor.editorNotesPane.title')}
+          </NotesTitle>
+          {notesCount > 0 && (
+            <NotesCount>
+              {unresolvedCount > 0 ? unresolvedCount : notesCount}
+            </NotesCount>
+          )}
+        </NotesHeader>
+
+        <NotesContent>
+          {notesCount === 0 ? (
+            <EmptyState>
+              <EmptyStateIcon>📝</EmptyStateIcon>
+              <EmptyStateText>
+                {t('editor.editorNotesPane.emptyState')}
+              </EmptyStateText>
+            </EmptyState>
+          ) : (
+            <NotesList
+              notes={notesList}
+              onUpdate={this.handleUpdateNote}
+              onDelete={this.handleDeleteNote}
+              onResolve={this.handleResolveNote}
+              t={t}
+            />
+          )}
+
+          <AddNoteForm
+            onAdd={this.handleAddNote}
+            t={t}
+          />
+        </NotesContent>
+      </NotesContainer>
+    );
+  }
+}
+
+export default EditorNotesPane;
\ No newline at end of file
diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js
new file mode 100644
index 000000000000..5c14480f0975
--- /dev/null
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js
@@ -0,0 +1,253 @@
+import PropTypes from 'prop-types';
+import React, { Component } from 'react';
+import ImmutablePropTypes from 'react-immutable-proptypes';
+import styled from '@emotion/styled';
+import { colors, transitions } from 'decap-cms-ui-default';
+
+const NoteCard = styled.div`
+  background-color: ${props => props.resolved ? colors.inputBackground : 'white'};
+  border: 1px solid ${props => props.resolved ? colors.textFieldBorder : colors.textFieldBorder};
+  border-radius: 4px;
+  margin-bottom: 8px;
+  padding: 12px;
+  transition: all ${transitions.main};
+  opacity: ${props => props.resolved ? 0.7 : 1};
+
+  &:hover {
+    border-color: ${colors.active};
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+  }
+`;
+
+const NoteHeader = styled.div`
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 8px;
+`;
+
+const NoteAuthor = styled.span`
+  font-size: 12px;
+  color: ${colors.controlLabel};
+  font-weight: 500;
+`;
+
+const NoteTimestamp = styled.span`
+  font-size: 11px;
+  color: ${colors.controlLabel};
+`;
+
+const NoteContent = styled.div`
+  margin-bottom: 8px;
+`;
+
+const NoteText = styled.p`
+  margin: 0;
+  font-size: 14px;
+  line-height: 1.4;
+  color: ${colors.text};
+  white-space: pre-wrap;
+  word-wrap: break-word;
+`;
+
+const EditableText = styled.textarea`
+  width: 100%;
+  min-height: 60px;
+  padding: 8px;
+  border: 1px solid ${colors.active};
+  border-radius: 3px;
+  font-size: 14px;
+  font-family: inherit;
+  line-height: 1.4;
+  resize: vertical;
+  outline: none;
+
+  &:focus {
+    border-color: ${colors.active};
+    box-shadow: 0 0 0 2px rgba(70, 151, 218, 0.1);
+  }
+`;
+
+const NoteActions = styled.div`
+  display: flex;
+  gap: 8px;
+  align-items: center;
+`;
+
+const ActionButton = styled.button`
+  background: none;
+  border: none;
+  color: ${colors.controlLabel};
+  font-size: 12px;
+  cursor: pointer;
+  padding: 4px 8px;
+  border-radius: 3px;
+  transition: all ${transitions.main};
+
+  &:hover {
+    background-color: ${colors.inputBackground};
+    color: ${props => props.danger ? colors.errorText : colors.active};
+  }
+
+  &:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+  }
+`;
+
+const ResolvedBadge = styled.span`
+  background-color: ${colors.successText};
+  color: white;
+  font-size: 10px;
+  padding: 2px 6px;
+  border-radius: 10px;
+  font-weight: 500;
+  text-transform: uppercase;
+`;
+
+class NoteItem extends Component {
+  static propTypes = {
+    note: ImmutablePropTypes.map.isRequired,
+    onUpdate: PropTypes.func.isRequired,
+    onDelete: PropTypes.func.isRequired,
+    onResolve: PropTypes.func.isRequired,
+    t: PropTypes.func.isRequired,
+  };
+
+  state = {
+    isEditing: false,
+    editContent: '',
+  };
+
+  formatTimestamp = (timestamp) => {
+    const date = new Date(timestamp);
+    const now = new Date();
+    const diffMs = now - date;
+    const diffMins = Math.floor(diffMs / 60000);
+    const diffHours = Math.floor(diffMs / 3600000);
+    const diffDays = Math.floor(diffMs / 86400000);
+
+    if (diffMins < 1) return 'just now';
+    if (diffMins < 60) return `${diffMins}m ago`;
+    if (diffHours < 24) return `${diffHours}h ago`;
+    if (diffDays < 7) return `${diffDays}d ago`;
+    
+    return date.toLocaleDateString();
+  };
+
+  handleEditStart = () => {
+    this.setState({
+      isEditing: true,
+      editContent: this.props.note.get('content'),
+    });
+  };
+
+  handleEditCancel = () => {
+    this.setState({
+      isEditing: false,
+      editContent: '',
+    });
+  };
+
+  handleEditSave = () => {
+    const { note, onUpdate } = this.props;
+    const { editContent } = this.state;
+    const trimmedContent = editContent.trim();
+
+    if (trimmedContent && trimmedContent !== note.get('content')) {
+      onUpdate(note.get('id'), { content: trimmedContent });
+    }
+
+    this.setState({
+      isEditing: false,
+      editContent: '',
+    });
+  };
+
+  handleEditKeyDown = (e) => {
+    if (e.key === 'Enter' && (e.ctrlKey || e.metaKey)) {
+      e.preventDefault();
+      this.handleEditSave();
+    } else if (e.key === 'Escape') {
+      e.preventDefault();
+      this.handleEditCancel();
+    }
+  };
+
+  handleDelete = () => {
+    const { note, onDelete, t } = this.props;
+    if (window.confirm(t('editor.editorNotesPane.confirmDelete'))) {
+      onDelete(note.get('id'));
+    }
+  };
+
+  handleResolve = () => {
+    const { note, onResolve } = this.props;
+    onResolve(note.get('id'));
+  };
+
+  render() {
+    const { note, t } = this.props;
+    const { isEditing, editContent } = this.state;
+    const resolved = note.get('resolved');
+
+    return (
+      <NoteCard resolved={resolved}>
+        <NoteHeader>
+          <NoteAuthor>{note.get('author')}</NoteAuthor>
+          <div style={{ display: 'flex', alignItems: 'center', gap: '8px' }}>
+            {resolved && <ResolvedBadge>resolved</ResolvedBadge>}
+            <NoteTimestamp>
+              {this.formatTimestamp(note.get('timestamp'))}
+            </NoteTimestamp>
+          </div>
+        </NoteHeader>
+
+        <NoteContent>
+          {isEditing ? (
+            <EditableText
+              value={editContent}
+              onChange={(e) => this.setState({ editContent: e.target.value })}
+              onKeyDown={this.handleEditKeyDown}
+              placeholder={t('editor.editorNotesPane.editPlaceholder')}
+              autoFocus
+            />
+          ) : (
+            <NoteText>{note.get('content')}</NoteText>
+          )}
+        </NoteContent>
+
+        <NoteActions>
+          {isEditing ? (
+            <>
+              <ActionButton onClick={this.handleEditSave}>
+                {t('editor.editorNotesPane.save')}
+              </ActionButton>
+              <ActionButton onClick={this.handleEditCancel}>
+                {t('editor.editorNotesPane.cancel')}
+              </ActionButton>
+            </>
+          ) : (
+            <>
+              {!resolved && (
+                <>
+                  <ActionButton onClick={this.handleEditStart}>
+                    {t('editor.editorNotesPane.edit')}
+                  </ActionButton>
+                  <ActionButton onClick={this.handleResolve}>
+                    {t('editor.editorNotesPane.resolve')}
+                  </ActionButton>
+                </>
+              )}
+              <ActionButton onClick={this.handleDelete} danger>
+                {t('editor.editorNotesPane.delete')}
+              </ActionButton>
+            </>
+          )}
+        </NoteActions>
+      </NoteCard>
+    );
+  }
+}
+
+export default NoteItem;
\ No newline at end of file
diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NotesList.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NotesList.js
new file mode 100644
index 000000000000..b14e4a0d1bf4
--- /dev/null
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NotesList.js
@@ -0,0 +1,50 @@
+import PropTypes from 'prop-types';
+import React from 'react';
+import ImmutablePropTypes from 'react-immutable-proptypes';
+import styled from '@emotion/styled';
+
+import NoteItem from './NoteItem';
+
+const ListContainer = styled.div`
+  flex: 1;
+  overflow-y: auto;
+  padding: 8px;
+`;
+
+function NotesList ({ notes, onUpdate, onDelete, onResolve, t }) {
+  // Sort notes: unresolved first, then by newest
+  const sortedNotes = notes
+    .sort((a, b) => {
+      // First sort by resolved status (unresolved first)
+      if (a.get('resolved') !== b.get('resolved')) {
+        return a.get('resolved') ? 1 : -1;
+      }
+      // Then sort by timestamp (newest first)
+      return new Date(b.get('timestamp')) - new Date(a.get('timestamp'));
+    });
+
+  return (
+    <ListContainer>
+      {sortedNotes.map(note => (
+        <NoteItem
+          key={note.get('id')}
+          note={note}
+          onUpdate={onUpdate}
+          onDelete={onDelete}
+          onResolve={onResolve}
+          t={t}
+        />
+      ))}
+    </ListContainer>
+  );
+};
+
+NotesList.propTypes = {
+  notes: ImmutablePropTypes.list.isRequired,
+  onUpdate: PropTypes.func.isRequired,
+  onDelete: PropTypes.func.isRequired,
+  onResolve: PropTypes.func.isRequired,
+  t: PropTypes.func.isRequired,
+};
+
+export default NotesList;
\ No newline at end of file
diff --git a/packages/decap-cms-locales/src/en/index.js b/packages/decap-cms-locales/src/en/index.js
index 5cba0d853d43..81e0f763927d 100644
--- a/packages/decap-cms-locales/src/en/index.js
+++ b/packages/decap-cms-locales/src/en/index.js
@@ -119,6 +119,21 @@ const en = {
       toggleI18n: 'Toggle i18n',
       togglePreview: 'Toggle preview',
       toggleScrollSync: 'Sync scrolling',
+      toggleNotes: 'Toggle notes',
+    },
+    editorNotesPane: {
+      title: 'Notes',
+      emptyState: 'No notes yet. Add your first note below to start collaborating.',
+      addNote: 'Add Note',
+      addPlaceholder: 'Add a note...',
+      editPlaceholder: 'Edit your note...',
+      save: 'Save',
+      cancel: 'Cancel',
+      edit: 'Edit',
+      delete: 'Delete',
+      resolve: 'Resolve',
+      confirmDelete: 'Are you sure you want to delete this note?',
+      shortcut: 'Tip: Press Ctrl+Enter to add note quickly',
     },
     editorToolbar: {
       publishing: 'Publishing...',

From 1aeff96ee04373002a02b6df80ebf1a05e8dff79 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Sat, 26 Jul 2025 20:28:48 +0100
Subject: [PATCH 02/40] feat: crud with Redux complete for EditorNotesPane

---
 .../decap-cms-core/src/actions/entries.ts     | 22 +++++++++++++
 .../src/components/Editor/Editor.js           | 26 ++++++++++++++++
 .../src/components/Editor/EditorInterface.js  |  2 +-
 .../decap-cms-core/src/reducers/entryDraft.js | 29 +++++++++++++++++
 packages/decap-cms-core/src/types/redux.ts    | 31 +++++++++++++++++++
 5 files changed, 109 insertions(+), 1 deletion(-)

diff --git a/packages/decap-cms-core/src/actions/entries.ts b/packages/decap-cms-core/src/actions/entries.ts
index ffeeb26836fb..2f87c0af02a5 100644
--- a/packages/decap-cms-core/src/actions/entries.ts
+++ b/packages/decap-cms-core/src/actions/entries.ts
@@ -34,6 +34,7 @@ import type {
   ViewFilter,
   ViewGroup,
   Entry,
+  Note,
 } from '../types/redux';
 import type { EntryValue } from '../valueObjects/Entry';
 import type { Backend } from '../backend';
@@ -86,6 +87,11 @@ export const REMOVE_DRAFT_ENTRY_MEDIA_FILE = 'REMOVE_DRAFT_ENTRY_MEDIA_FILE';
 
 export const CHANGE_VIEW_STYLE = 'CHANGE_VIEW_STYLE';
 
+export const DRAFT_NOTES_LOAD = 'DRAFT_NOTES_LOAD';
+export const DRAFT_NOTE_ADD = 'DRAFT_NOTE_ADD';
+export const DRAFT_NOTE_UPDATE = 'DRAFT_NOTE_UPDATE';
+export const DRAFT_NOTE_DELETE = 'DRAFT_NOTE_DELETE';
+
 /*
  * Simple Action Creators (Internal)
  * We still need to export them for tests
@@ -460,6 +466,22 @@ export function removeDraftEntryMediaFile({ id }: { id: string }) {
   return { type: REMOVE_DRAFT_ENTRY_MEDIA_FILE, payload: { id } };
 }
 
+export function loadNotesForEntry(notes: Note[]) {
+  return { type: DRAFT_NOTES_LOAD, payload: {notes}};
+}
+
+export function addNote(note: Note) { 
+  return { type: DRAFT_NOTE_ADD, payload: { note } };
+}
+
+export function updateNote(noteId: string, updates: Partial<Note>) {
+  return { type: DRAFT_NOTE_UPDATE, payload: { id: noteId, updates } };
+}
+
+export function deleteNote(noteId: string) {
+  return { type: DRAFT_NOTE_DELETE, payload: { id: noteId } };
+}
+
 export function persistLocalBackup(entry: EntryMap, collection: Collection) {
   return (_dispatch: ThunkDispatch<State, {}, AnyAction>, getState: () => State) => {
     const state = getState();
diff --git a/packages/decap-cms-core/src/components/Editor/Editor.js b/packages/decap-cms-core/src/components/Editor/Editor.js
index ac2a4f84fd78..330a6a576d2b 100644
--- a/packages/decap-cms-core/src/components/Editor/Editor.js
+++ b/packages/decap-cms-core/src/components/Editor/Editor.js
@@ -22,6 +22,10 @@ import {
   loadLocalBackup,
   retrieveLocalBackup,
   deleteLocalBackup,
+  loadNotesForEntry,
+  addNote,
+  updateNote,
+  deleteNote,
 } from '../../actions/entries';
 import {
   updateUnpublishedEntryStatus,
@@ -336,6 +340,22 @@ export class Editor extends React.Component {
     }
   };
 
+  handleNotesChange = (action, payload) => {
+    switch(action) {
+      case 'ADD_NOTE':
+        this.props.addNote(payload);
+        break;
+      case 'UPDATE_NOTE':
+        this.props.updateNote(payload.id, payload.updates);
+        break;
+      case 'DELETE_NOTE':
+        this.props.deleteNote(payload.id);
+        break;
+      default:
+        console.log('Unknown notes action:', action, payload)
+    }
+  }
+
   render() {
     const {
       entry,
@@ -385,7 +405,9 @@ export class Editor extends React.Component {
         fields={fields}
         fieldsMetaData={entryDraft.get('fieldsMetaData')}
         fieldsErrors={entryDraft.get('fieldsErrors')}
+        notes={entryDraft.get('notes')}
         onChange={this.handleChangeDraftField}
+        onNotesChange={this.handleNotesChange}
         onValidate={changeDraftFieldValidation}
         onPersist={this.handlePersistEntry}
         onDelete={this.handleDeleteEntry}
@@ -492,6 +514,10 @@ const mapDispatchToProps = {
   unpublishPublishedEntry,
   deleteUnpublishedEntry,
   logoutUser,
+  loadNotesForEntry,
+  addNote,
+  updateNote,
+  deleteNote,
 };
 
 export default connect(mapStateToProps, mapDispatchToProps)(withWorkflow(translate()(Editor)));
diff --git a/packages/decap-cms-core/src/components/Editor/EditorInterface.js b/packages/decap-cms-core/src/components/Editor/EditorInterface.js
index 02f5b2f961f2..6553dfa5efd0 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorInterface.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorInterface.js
@@ -232,7 +232,7 @@ class EditorInterface extends Component {
 
   handleNotesChange = (action, payload) => {
     console.log('Notes change:', action, payload);
-    // TODO: Implement with Redux actions
+    this.props.onNotesChange(action, payload)
   };
 
   handleToggleScrollSync = () => {
diff --git a/packages/decap-cms-core/src/reducers/entryDraft.js b/packages/decap-cms-core/src/reducers/entryDraft.js
index e3d2dec29f04..4e1f594523ea 100644
--- a/packages/decap-cms-core/src/reducers/entryDraft.js
+++ b/packages/decap-cms-core/src/reducers/entryDraft.js
@@ -19,6 +19,10 @@ import {
   ENTRY_DELETE_SUCCESS,
   ADD_DRAFT_ENTRY_MEDIA_FILE,
   REMOVE_DRAFT_ENTRY_MEDIA_FILE,
+  DRAFT_NOTES_LOAD,
+  DRAFT_NOTE_ADD,
+  DRAFT_NOTE_UPDATE,
+  DRAFT_NOTE_DELETE,
 } from '../actions/entries';
 import {
   UNPUBLISHED_ENTRY_PERSIST_REQUEST,
@@ -38,6 +42,7 @@ const initialState = Map({
   entry: Map(),
   fieldsMetaData: Map(),
   fieldsErrors: Map(),
+  notes: List(),
   hasChanged: false,
   key: '',
 });
@@ -51,6 +56,7 @@ function entryDraftReducer(state = Map(), action) {
         state.setIn(['entry', 'newRecord'], false);
         state.set('fieldsMetaData', Map());
         state.set('fieldsErrors', Map());
+        state.set('notes', List());
         state.set('hasChanged', false);
         state.set('key', uuid());
       });
@@ -61,6 +67,7 @@ function entryDraftReducer(state = Map(), action) {
         state.setIn(['entry', 'newRecord'], true);
         state.set('fieldsMetaData', Map());
         state.set('fieldsErrors', Map());
+        state.set('notes', List());
         state.set('hasChanged', false);
         state.set('key', uuid());
       });
@@ -74,6 +81,7 @@ function entryDraftReducer(state = Map(), action) {
         state.setIn(['entry', 'newRecord'], !backupEntry.get('path'));
         state.set('fieldsMetaData', Map());
         state.set('fieldsErrors', Map());
+        state.set('notes', List());
         state.set('hasChanged', true);
         state.set('key', uuid());
       });
@@ -84,6 +92,7 @@ function entryDraftReducer(state = Map(), action) {
         state.setIn(['entry', 'newRecord'], true);
         state.set('mediaFiles', List());
         state.set('fieldsMetaData', Map());
+        state.set('notes', List());
         state.set('fieldsErrors', Map());
         state.set('hasChanged', true);
       });
@@ -199,6 +208,26 @@ function entryDraftReducer(state = Map(), action) {
       });
     }
 
+    case DRAFT_NOTES_LOAD:
+      return state.set('notes', fromJS(action.payload.notes));
+    
+    case DRAFT_NOTE_ADD:
+      return state.update('notes', notes => notes.push(fromJS(action.payload.note)));
+    
+    case DRAFT_NOTE_UPDATE:
+      return state.update('notes', notes => 
+        notes.map(note =>
+          note.get('id') === action.payload.id
+            ? note.merge(fromJS(action.payload.updates))
+            : note
+        )
+      )
+    
+    case DRAFT_NOTE_DELETE:
+      return state.update('notes', notes => 
+        notes.filterNot(note => note.get('id') === action.payload.id)
+      );
+
     default:
       return state;
   }
diff --git a/packages/decap-cms-core/src/types/redux.ts b/packages/decap-cms-core/src/types/redux.ts
index c41bbdd18bb6..bf616a98f202 100644
--- a/packages/decap-cms-core/src/types/redux.ts
+++ b/packages/decap-cms-core/src/types/redux.ts
@@ -293,6 +293,36 @@ export interface CmsCollectionFile {
   public_folder?: string;
 }
 
+export interface Note {
+  id: string;
+  content: string;
+  timestamp: string;
+  author: string;
+  entrySlug: string;
+  resolved: boolean;
+}
+
+export type NoteMap = StaticallyTypedRecord<Note>
+
+export type Notes = List<NoteMap>
+
+export interface LoadNotesPayload {
+  notes: Note[]
+}
+
+export interface AddNotePayload {
+  note: Note;
+}
+
+export interface UpdateNotePayload {
+  id: string;
+  updates: Partial<Note>
+}
+
+export interface DeleteNotePayload {
+  id: string;
+}
+
 export interface ViewFilter {
   label: string;
   field: string;
@@ -554,6 +584,7 @@ export type EntryDraft = StaticallyTypedRecord<{
   entry: Entry;
   fieldsErrors: FieldsErrors;
   fieldsMetaData?: Map<string, Map<string, string>>;
+  notes: Notes;
 }>;
 
 export type EntryField = StaticallyTypedRecord<{

From 6c9e47573d9b8c32ff9032b8e1bc48726640a327 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Sat, 26 Jul 2025 23:23:30 +0100
Subject: [PATCH 03/40] feat: notes functionality connected to Test Backend

---
 .../src/__tests__/implementation.spec.js      | 241 ++++++++++++++++++
 .../src/implementation.ts                     |  27 ++
 .../decap-cms-core/src/actions/entries.ts     |  30 ++-
 packages/decap-cms-core/src/backend.ts        |  22 ++
 .../src/components/Editor/EditorInterface.js  |   1 -
 .../Editor/EditorNotesPane/AddNoteForm.js     |   2 +-
 packages/decap-cms-core/src/types/redux.ts    |  10 +-
 .../decap-cms-lib-util/src/implementation.ts  |  12 +
 packages/decap-cms-lib-util/src/index.ts      |   2 +
 9 files changed, 334 insertions(+), 13 deletions(-)

diff --git a/packages/decap-cms-backend-test/src/__tests__/implementation.spec.js b/packages/decap-cms-backend-test/src/__tests__/implementation.spec.js
index b4b1a5920510..d1b207447648 100644
--- a/packages/decap-cms-backend-test/src/__tests__/implementation.spec.js
+++ b/packages/decap-cms-backend-test/src/__tests__/implementation.spec.js
@@ -263,4 +263,245 @@ describe('test backend implementation', () => {
       ]);
     });
   });
+
+  describe('Notes functionality', () => {
+    let backend;
+
+    beforeEach(() => {
+      window.repoFiles = {};
+      backend = new TestBackend({ media_folder: 'uploads' });
+    });
+
+    describe('saveNotesFile', () => {
+      it('should save notes to the correct path', async () => {
+        const notes = [
+          {
+            id: 'note-1',
+            content: 'This is my first note',
+            timestamp: '2024-01-15T10:30:00Z',
+            author: 'John Doe',
+            entrySlug: 'my-first-post',
+            resolved: false
+          },
+          {
+            id: 'note-2', 
+            content: 'This is a resolved note',
+            timestamp: '2024-01-15T11:45:00Z',
+            author: 'Jane Smith',
+            entrySlug: 'my-first-post',
+            resolved: true
+          }
+        ];
+
+        await backend.saveNotesFile('.notes/blog/my-first-post.json', notes);
+
+        expect(window.repoFiles).toEqual({
+          '.notes': {
+            blog: {
+              'my-first-post.json': {
+                path: '.notes/blog/my-first-post.json',
+                content: JSON.stringify(notes, null, 2)
+              }
+            }
+          }
+        });
+      });
+
+      it('should save notes for nested collections', async () => {
+        const notes = [
+          {
+            id: 'note-1',
+            content: 'Note for nested entry',
+            timestamp: '2024-01-15T10:30:00Z',
+            author: 'John Doe',
+            entrySlug: 'nested-entry',
+            resolved: false
+          }
+        ];
+
+        await backend.saveNotesFile('.notes/projects/web-development/nested-entry.json', notes);
+
+        expect(window.repoFiles).toEqual({
+          '.notes': {
+            projects: {
+              'web-development': {
+                'nested-entry.json': {
+                  path: '.notes/projects/web-development/nested-entry.json',
+                  content: JSON.stringify(notes, null, 2)
+                }
+              }
+            }
+          }
+        });
+      });
+
+      it('should save empty notes array', async () => {
+        await backend.saveNotesFile('.notes/blog/empty-post.json', []);
+
+        expect(window.repoFiles['.notes']['blog']['empty-post.json'].content).toBe('[]');
+      });
+
+      it('should preserve other files when saving notes', async () => {
+        // Setup existing content
+        window.repoFiles = {
+          posts: {
+            'existing-post.md': {
+              content: 'existing content',
+              path: 'posts/existing-post.md'
+            }
+          },
+          '.notes': {
+            blog: {
+              'other-post.json': {
+                content: '[]',
+                path: '.notes/blog/other-post.json'
+              }
+            }
+          }
+        };
+
+        const notes = [{ id: 'note-1', content: 'New note', timestamp: '2024-01-15T10:30:00Z', author: 'John', entrySlug: 'new-post', resolved: false }];
+        await backend.saveNotesFile('.notes/blog/new-post.json', notes);
+
+        // Should preserve existing content
+        expect(window.repoFiles.posts['existing-post.md']).toBeDefined();
+        expect(window.repoFiles['.notes'].blog['other-post.json']).toBeDefined();
+        expect(window.repoFiles['.notes'].blog['new-post.json']).toBeDefined();
+      });
+    });
+
+    describe('getNotesFile', () => {
+      it('should load existing notes', async () => {
+        const notes = [
+          {
+            id: 'note-1',
+            content: 'Test note content',
+            timestamp: '2024-01-15T10:30:00Z',
+            author: 'John Doe',
+            entrySlug: 'test-post',
+            resolved: false
+          }
+        ];
+
+        // Setup notes in window.repoFiles
+        window.repoFiles = {
+          '.notes': {
+            blog: {
+              'test-post.json': {
+                path: '.notes/blog/test-post.json',
+                content: JSON.stringify(notes)
+              }
+            }
+          }
+        };
+
+        const loadedNotes = await backend.getNotesFile('.notes/blog/test-post.json');
+        expect(loadedNotes).toEqual(notes);
+      });
+
+      it('should return empty array for non-existent notes file', async () => {
+        const loadedNotes = await backend.getNotesFile('.notes/blog/non-existent.json');
+        expect(loadedNotes).toEqual([]);
+      });
+
+      it('should return empty array for empty notes file', async () => {
+        window.repoFiles = {
+          '.notes': {
+            blog: {
+              'empty.json': {
+                path: '.notes/blog/empty.json',
+                content: '[]'
+              }
+            }
+          }
+        };
+
+        const loadedNotes = await backend.getNotesFile('.notes/blog/empty.json');
+        expect(loadedNotes).toEqual([]);
+      });
+
+      it('should handle malformed JSON gracefully', async () => {
+        window.repoFiles = {
+          '.notes': {
+            blog: {
+              'corrupted.json': {
+                path: '.notes/blog/corrupted.json',
+                content: '{ invalid json'
+              }
+            }
+          }
+        };
+
+        const loadedNotes = await backend.getNotesFile('.notes/blog/corrupted.json');
+        expect(loadedNotes).toEqual([]);
+      });
+    });
+
+    describe('notes save and load cycle', () => {
+      it('should save and then load the same notes', async () => {
+        const originalNotes = [
+          {
+            id: 'note-1',
+            content: 'First note',
+            timestamp: '2024-01-15T10:30:00Z',
+            author: 'John Doe',
+            entrySlug: 'test-entry',
+            resolved: false
+          },
+          {
+            id: 'note-2',
+            content: 'Second note with special chars: éñ中文',
+            timestamp: '2024-01-15T11:30:00Z',
+            author: 'Jane Smith',
+            entrySlug: 'test-entry',
+            resolved: true
+          }
+        ];
+
+        // Save notes
+        await backend.saveNotesFile('.notes/blog/test-entry.json', originalNotes);
+
+        // Load notes
+        const loadedNotes = await backend.getNotesFile('.notes/blog/test-entry.json');
+
+        expect(loadedNotes).toEqual(originalNotes);
+      });
+
+      it('should handle multiple collections separately', async () => {
+        const blogNotes = [{ id: 'blog-note', content: 'Blog note', timestamp: '2024-01-15T10:30:00Z', author: 'John', entrySlug: 'blog-post', resolved: false }];
+        const pageNotes = [{ id: 'page-note', content: 'Page note', timestamp: '2024-01-15T11:30:00Z', author: 'Jane', entrySlug: 'about-page', resolved: false }];
+
+        // Save to different collections
+        await backend.saveNotesFile('.notes/blog/my-post.json', blogNotes);
+        await backend.saveNotesFile('.notes/pages/about.json', pageNotes);
+
+        // Load from different collections
+        const loadedBlogNotes = await backend.getNotesFile('.notes/blog/my-post.json');
+        const loadedPageNotes = await backend.getNotesFile('.notes/pages/about.json');
+
+        expect(loadedBlogNotes).toEqual(blogNotes);
+        expect(loadedPageNotes).toEqual(pageNotes);
+      });
+    });
+
+    describe('edge cases', () => {
+      it('should handle notes with complex content', async () => {
+        const complexNotes = [
+          {
+            id: 'complex-note',
+            content: 'Note with "quotes", line\nbreaks, and {json: "like"} content',
+            timestamp: '2024-01-15T10:30:00Z',
+            author: 'Test User',
+            entrySlug: 'complex-entry',
+            resolved: false
+          }
+        ];
+
+        await backend.saveNotesFile('.notes/blog/complex.json', complexNotes);
+        const loadedNotes = await backend.getNotesFile('.notes/blog/complex.json');
+
+        expect(loadedNotes).toEqual(complexNotes);
+      });
+    });
+  })
 });
diff --git a/packages/decap-cms-backend-test/src/implementation.ts b/packages/decap-cms-backend-test/src/implementation.ts
index 62548eb42ded..d0b700159fb3 100644
--- a/packages/decap-cms-backend-test/src/implementation.ts
+++ b/packages/decap-cms-backend-test/src/implementation.ts
@@ -16,6 +16,7 @@ import AuthenticationPage from './AuthenticationPage';
 
 import type {
   Implementation,
+  Note,
   Entry,
   ImplementationEntry,
   AssetProxy,
@@ -394,6 +395,32 @@ export default class TestBackend implements Implementation {
     };
   }
 
+    async saveNotesFile(path: string, notes: Note[]) {
+    try {
+      const notesData = JSON.stringify(notes, null, 2);
+      writeFile(path, notesData, window.repoFiles);
+      console.log(`✅ Notes saved to: ${path}`);
+    } catch (error) {
+      console.error('❌ Failed to save notes:', error);
+      throw error;
+    }
+  }
+
+  async getNotesFile(path: string) {
+    try {
+      const file = getFile(path, window.repoFiles);
+      if (file.content) {
+        const notes = JSON.parse(file.content as string);
+        console.log(`✅ Notes loaded from: ${path}`);
+        return notes;
+      }
+      return []; // No notes file exists
+    } catch (error) {
+      console.error('❌ Failed to load notes:', error);
+      return []; // Return empty on error
+    }
+  }
+
   normalizeAsset(assetProxy: AssetProxy) {
     const fileObj = assetProxy.fileObj as File;
     const { name, size } = fileObj;
diff --git a/packages/decap-cms-core/src/actions/entries.ts b/packages/decap-cms-core/src/actions/entries.ts
index 2f87c0af02a5..f47d65d78877 100644
--- a/packages/decap-cms-core/src/actions/entries.ts
+++ b/packages/decap-cms-core/src/actions/entries.ts
@@ -22,7 +22,7 @@ import { getProcessSegment } from '../lib/formatters';
 import { hasI18n, duplicateDefaultI18nFields, serializeI18n, I18N, I18N_FIELD } from '../lib/i18n';
 import { addNotification } from './notifications';
 
-import type { ImplementationMediaFile } from 'decap-cms-lib-util';
+import type { ImplementationMediaFile, Note } from 'decap-cms-lib-util';
 import type { AnyAction } from 'redux';
 import type { ThunkDispatch } from 'redux-thunk';
 import type {
@@ -34,7 +34,6 @@ import type {
   ViewFilter,
   ViewGroup,
   Entry,
-  Note,
 } from '../types/redux';
 import type { EntryValue } from '../valueObjects/Entry';
 import type { Backend } from '../backend';
@@ -558,6 +557,7 @@ export function loadEntry(collection: Collection, slug: string) {
       const loadedEntry = await tryLoadEntry(getState(), collection, slug);
       dispatch(entryLoaded(collection, loadedEntry));
       dispatch(createDraftFromEntry(loadedEntry));
+      loadNotesFromFile(dispatch, getState(), collection, slug, );
     } catch (error) {
       dispatch(
         addNotification({
@@ -963,6 +963,7 @@ export function persistEntry(collection: Collection) {
           await dispatch(loadMedia());
         }
         dispatch(entryPersisted(collection, serializedEntry, newSlug));
+        saveNotesToFile(state, collection, newSlug || entry.get('slug'));
         if (collection.has('nested')) {
           await dispatch(loadEntries(collection));
         }
@@ -1016,6 +1017,31 @@ export function deleteEntry(collection: Collection, slug: string) {
   };
 }
 
+function saveNotesToFile(state: State, collection: Collection, slug: string) {
+  const backend = currentBackend(state.config);
+  const notes = state.entryDraft.get('notes');
+
+  if (typeof backend.saveNotesFile === 'function') {
+    const notesPath = `.notes/${collection.get('name')}/${slug}.json`;
+    return backend.saveNotesFile(notesPath, notes.toJS());
+  }
+
+  console.log('Backend does not support notes persistence yet.')
+}
+
+function loadNotesFromFile(dispatch: ThunkDispatch<State, {}, AnyAction>, state: State, collection: Collection, slug: string) {
+  const backend = currentBackend(state.config);
+  if (typeof backend.getNotesFile === 'function') {
+    const notesPath = `.notes/${collection.get('name')}/${slug}.json`;
+    return backend.getNotesFile(notesPath).then(notes => {
+      dispatch(loadNotesForEntry(notes));
+    });
+  }
+  
+  console.log('Backend does not support notes persistence yet');
+  dispatch(loadNotesForEntry([])); // Start with empty notes
+}
+
 function getPathError(
   path: string | undefined,
   key: string,
diff --git a/packages/decap-cms-core/src/backend.ts b/packages/decap-cms-core/src/backend.ts
index c998d645041d..afa1f707e9a7 100644
--- a/packages/decap-cms-core/src/backend.ts
+++ b/packages/decap-cms-core/src/backend.ts
@@ -81,6 +81,7 @@ import type {
   UnpublishedEntry,
   DataFile,
   UnpublishedEntryDiff,
+  Note,
 } from 'decap-cms-lib-util';
 import type { Map } from 'immutable';
 
@@ -562,6 +563,7 @@ export class Backend {
     } else {
       throw new Error(`Unknown collection type: ${collectionType}`);
     }
+
     const loadedEntries = await listMethod();
     /*
           Wrap cursors so we can tell which collection the cursor is
@@ -581,6 +583,26 @@ export class Backend {
     };
   }
 
+    async saveNotesFile(path: string, notes: Note[]) {
+    if (typeof this.implementation.saveNotesFile === 'function') {
+      return this.implementation.saveNotesFile(path, notes)
+    }
+
+    console.log ('Backend unsupported for notes yet');
+
+    }
+
+  async getNotesFile(path: string) {
+    // Check if the implementation supports notes
+    if (typeof this.implementation.getNotesFile === 'function') {
+      return this.implementation.getNotesFile(path);
+    }
+    
+    // Fallback: return empty notes for backends that don't support notes yet
+    console.log('Backend does not support notes persistence yet');
+    return [];
+  }
+
   // The same as listEntries, except that if a cursor with the "next"
   // action available is returned, it calls "next" on the cursor and
   // repeats the process. Once there is no available "next" action, it
diff --git a/packages/decap-cms-core/src/components/Editor/EditorInterface.js b/packages/decap-cms-core/src/components/Editor/EditorInterface.js
index 6553dfa5efd0..016486227634 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorInterface.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorInterface.js
@@ -231,7 +231,6 @@ class EditorInterface extends Component {
   };
 
   handleNotesChange = (action, payload) => {
-    console.log('Notes change:', action, payload);
     this.props.onNotesChange(action, payload)
   };
 
diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js
index 8e872f1e955e..e59c448e3450 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js
@@ -68,7 +68,7 @@ const CharCount = styled.span`
 const Hint = styled.p`
   font-size: 12px;
   color: ${colors.controlLabel};
-  margin: 4px 0 0 0;
+  margin: 4px 0 0;
   font-style: italic;
 `;
 
diff --git a/packages/decap-cms-core/src/types/redux.ts b/packages/decap-cms-core/src/types/redux.ts
index bf616a98f202..90308709513d 100644
--- a/packages/decap-cms-core/src/types/redux.ts
+++ b/packages/decap-cms-core/src/types/redux.ts
@@ -11,6 +11,7 @@ import type { Search } from '../reducers/search';
 import type { GlobalUI } from '../reducers/globalUI';
 import type { NotificationsState } from '../reducers/notifications';
 import type { formatExtensions } from '../formats/formats';
+import type { Note } from 'decap-cms-lib-util';
 
 export type CmsBackendType =
   | 'azure'
@@ -293,15 +294,6 @@ export interface CmsCollectionFile {
   public_folder?: string;
 }
 
-export interface Note {
-  id: string;
-  content: string;
-  timestamp: string;
-  author: string;
-  entrySlug: string;
-  resolved: boolean;
-}
-
 export type NoteMap = StaticallyTypedRecord<Note>
 
 export type Notes = List<NoteMap>
diff --git a/packages/decap-cms-lib-util/src/implementation.ts b/packages/decap-cms-lib-util/src/implementation.ts
index 52539852bde8..deb521a0035e 100644
--- a/packages/decap-cms-lib-util/src/implementation.ts
+++ b/packages/decap-cms-lib-util/src/implementation.ts
@@ -63,6 +63,15 @@ export type DataFile = {
   newPath?: string;
 };
 
+export interface Note {
+  id: string;
+  content: string;
+  timestamp: string;
+  author: string;
+  entrySlug: string;
+  resolved: boolean;
+}
+
 export type AssetProxy = {
   path: string;
   fileObj?: File;
@@ -159,6 +168,9 @@ export interface Implementation {
   persistMedia: (file: AssetProxy, opts: PersistOptions) => Promise<ImplementationMediaFile>;
   deleteFiles: (paths: string[], commitMessage: string) => Promise<void>;
 
+  saveNotesFile?: (path: string, notes: Note[]) => Promise<void>
+  getNotesFile?: (path: string) => Promise<Note[]>;
+
   unpublishedEntries: () => Promise<string[]>;
   unpublishedEntry: (args: {
     id?: string;
diff --git a/packages/decap-cms-lib-util/src/index.ts b/packages/decap-cms-lib-util/src/index.ts
index 9881366de927..60f248181bc9 100644
--- a/packages/decap-cms-lib-util/src/index.ts
+++ b/packages/decap-cms-lib-util/src/index.ts
@@ -76,6 +76,7 @@ import type {
   Config as C,
   UnpublishedEntryMediaFile as UEMF,
   DataFile as DF,
+  Note as NT
 } from './implementation';
 import type { AsyncLock as AL } from './asyncLock';
 
@@ -99,6 +100,7 @@ export type Config = C;
 export type FetchError = FE;
 export type PointerFile = PF;
 export type DataFile = DF;
+export type Note = NT;
 
 export const DecapCmsLibUtil = {
   APIError,

From cdc52aaf485a1dfe99c2f72b5154ee898a080f68 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Sun, 27 Jul 2025 15:28:44 +0100
Subject: [PATCH 04/40] feat: notespane now immediately saves the note and it
 works with proxy backend

---
 .../src/implementation.ts                     | 28 +++++++
 .../decap-cms-core/src/actions/entries.ts     | 84 ++++++++++++++++++-
 .../src/components/Editor/Editor.js           | 20 +++--
 .../decap-server/src/middlewares/joi/index.ts | 31 +++++++
 .../src/middlewares/localFs/index.ts          | 33 ++++++++
 .../src/middlewares/localGit/index.ts         | 30 +++++++
 6 files changed, 214 insertions(+), 12 deletions(-)

diff --git a/packages/decap-cms-backend-proxy/src/implementation.ts b/packages/decap-cms-backend-proxy/src/implementation.ts
index 710dda44476d..2dc4da760894 100644
--- a/packages/decap-cms-backend-proxy/src/implementation.ts
+++ b/packages/decap-cms-backend-proxy/src/implementation.ts
@@ -16,6 +16,7 @@ import type {
   Implementation,
   ImplementationFile,
   UnpublishedEntry,
+  Note,
 } from 'decap-cms-lib-util';
 
 async function serializeAsset(assetProxy: AssetProxy) {
@@ -247,6 +248,33 @@ export default class ProxyBackend implements Implementation {
     return deserializeMediaFile(file);
   }
 
+  async saveNotesFile(path: string, notes: Note[]) {
+    const response = await this.request({
+      action: 'saveNotesFile',
+      params: { 
+        branch: this.branch, 
+        path, 
+        notes 
+      },
+    });
+    return response;
+  }
+
+  async getNotesFile(path: string): Promise<Note[]> {
+    try {
+      const response = await this.request({
+        action: 'getNotesFile',
+        params: {
+          branch: this.branch,
+          path
+        },
+      });
+      return response.notes || [];
+    } catch (error) {
+      return [];
+    }
+  }
+
   deleteFiles(paths: string[], commitMessage: string) {
     return this.request({
       action: 'deleteFiles',
diff --git a/packages/decap-cms-core/src/actions/entries.ts b/packages/decap-cms-core/src/actions/entries.ts
index f47d65d78877..cf63afebf25a 100644
--- a/packages/decap-cms-core/src/actions/entries.ts
+++ b/packages/decap-cms-core/src/actions/entries.ts
@@ -90,6 +90,9 @@ export const DRAFT_NOTES_LOAD = 'DRAFT_NOTES_LOAD';
 export const DRAFT_NOTE_ADD = 'DRAFT_NOTE_ADD';
 export const DRAFT_NOTE_UPDATE = 'DRAFT_NOTE_UPDATE';
 export const DRAFT_NOTE_DELETE = 'DRAFT_NOTE_DELETE';
+export const SAVE_NOTE_REQUEST = 'SAVE_NOTE_REQUEST';
+export const SAVE_NOTE_SUCCESS = 'SAVE_NOTE_SUCCESS'
+export const SAVE_NOTE_FAILURE = 'SAVE_NOTE_FAILURE';
 
 /*
  * Simple Action Creators (Internal)
@@ -557,7 +560,7 @@ export function loadEntry(collection: Collection, slug: string) {
       const loadedEntry = await tryLoadEntry(getState(), collection, slug);
       dispatch(entryLoaded(collection, loadedEntry));
       dispatch(createDraftFromEntry(loadedEntry));
-      loadNotesFromFile(dispatch, getState(), collection, slug, );
+      loadNotesFromFile(dispatch, getState(), collection, slug);
     } catch (error) {
       dispatch(
         addNotification({
@@ -1017,12 +1020,87 @@ export function deleteEntry(collection: Collection, slug: string) {
   };
 }
 
+export function saveNoteRequest(noteId: string) {
+  return {
+    type: SAVE_NOTE_REQUEST,
+    payload: { noteId }
+  };
+}
+
+export function saveNoteSuccess(noteId: string) {
+  return {
+    type: SAVE_NOTE_SUCCESS,
+    payload: { noteId }
+  };
+}
+
+export function saveNoteFailure(noteId: string, error: Error) {
+  return {
+    type: SAVE_NOTE_FAILURE,
+    payload: { noteId, error: error.toString() }
+  };
+}
+
+// New thunk action for saving a single note
+export function saveNote(collection: Collection, slug: string, note: Note) {
+  return async (dispatch: ThunkDispatch<State, {}, AnyAction>, getState: () => State) => {
+    const state = getState();
+    const backend = currentBackend(state.config);
+    
+    console.log('🔥 saveNote called!', { collection: collection.get('name'), slug, noteId: note.id });
+    
+    dispatch(saveNoteRequest(note.id));
+    
+    try {
+      if (typeof backend.saveNotesFile === 'function') {
+        const allNotes = state.entryDraft.get('notes');
+        const notesPath = `${collection.get('folder')}/${slug}.json`;
+        await backend.saveNotesFile(notesPath, allNotes.toJS());
+        dispatch(saveNoteSuccess(note.id));       
+      } else {
+        throw new Error('Backend does not support notes persistence');
+      }
+    } catch (error) { 
+      dispatch(saveNoteFailure(note.id, error));
+    }
+  };
+}
+
+export function addNoteAndSave(collection: Collection, slug: string, note: Note, saveImmediately = true) {
+  return async (dispatch: ThunkDispatch<State, {}, AnyAction>) => {
+    dispatch(addNote(note));
+    if (saveImmediately) {
+      await dispatch(saveNote(collection, slug, note));
+    }
+  };
+}
+
+export function updateNoteAndSave(collection: Collection, slug: string, noteId: string, updates: Partial<Note>, saveImmediately = true) {
+  return async (dispatch: ThunkDispatch<State, {}, AnyAction>) => {
+    dispatch(updateNote(noteId, updates));
+    if (saveImmediately) {
+      const updatedNote = { id: noteId, ...updates } as Note;
+      await dispatch(saveNote(collection, slug, updatedNote));
+    }
+  };
+}
+
+export function deleteNoteAndSave(collection: Collection, slug: string, noteId: string, saveImmediately = true) {
+  return async (dispatch: ThunkDispatch<State, {}, AnyAction>) => {
+    dispatch(deleteNote(noteId));
+    if (saveImmediately) {
+      const dummyNote = { id: noteId } as Note;
+      await dispatch(saveNote(collection, slug, dummyNote));
+    }
+  };
+}
+
 function saveNotesToFile(state: State, collection: Collection, slug: string) {
   const backend = currentBackend(state.config);
   const notes = state.entryDraft.get('notes');
 
   if (typeof backend.saveNotesFile === 'function') {
-    const notesPath = `.notes/${collection.get('name')}/${slug}.json`;
+    const notesPath = `${collection.get('folder')}/${slug}.json`;
     return backend.saveNotesFile(notesPath, notes.toJS());
   }
 
@@ -1032,7 +1110,7 @@ function saveNotesToFile(state: State, collection: Collection, slug: string) {
 function loadNotesFromFile(dispatch: ThunkDispatch<State, {}, AnyAction>, state: State, collection: Collection, slug: string) {
   const backend = currentBackend(state.config);
   if (typeof backend.getNotesFile === 'function') {
-    const notesPath = `.notes/${collection.get('name')}/${slug}.json`;
+    const notesPath = `${collection.get('folder')}/${slug}.json`;
     return backend.getNotesFile(notesPath).then(notes => {
       dispatch(loadNotesForEntry(notes));
     });
diff --git a/packages/decap-cms-core/src/components/Editor/Editor.js b/packages/decap-cms-core/src/components/Editor/Editor.js
index 330a6a576d2b..a3a891e490f5 100644
--- a/packages/decap-cms-core/src/components/Editor/Editor.js
+++ b/packages/decap-cms-core/src/components/Editor/Editor.js
@@ -23,9 +23,9 @@ import {
   retrieveLocalBackup,
   deleteLocalBackup,
   loadNotesForEntry,
-  addNote,
-  updateNote,
-  deleteNote,
+  addNoteAndSave,
+  updateNoteAndSave,
+  deleteNoteAndSave,
 } from '../../actions/entries';
 import {
   updateUnpublishedEntryStatus,
@@ -341,15 +341,17 @@ export class Editor extends React.Component {
   };
 
   handleNotesChange = (action, payload) => {
+    const { collection, slug } = this.props;
+    
     switch(action) {
       case 'ADD_NOTE':
-        this.props.addNote(payload);
+        this.props.addNoteAndSave(collection, slug, payload);
         break;
       case 'UPDATE_NOTE':
-        this.props.updateNote(payload.id, payload.updates);
+        this.props.updateNoteAndSave(collection, slug, payload.id, payload.updates);
         break;
       case 'DELETE_NOTE':
-        this.props.deleteNote(payload.id);
+        this.props.deleteNoteAndSave(collection, slug, payload.id);
         break;
       default:
         console.log('Unknown notes action:', action, payload)
@@ -515,9 +517,9 @@ const mapDispatchToProps = {
   deleteUnpublishedEntry,
   logoutUser,
   loadNotesForEntry,
-  addNote,
-  updateNote,
-  deleteNote,
+  addNoteAndSave,
+  updateNoteAndSave,
+  deleteNoteAndSave
 };
 
 export default connect(mapStateToProps, mapDispatchToProps)(withWorkflow(translate()(Editor)));
diff --git a/packages/decap-server/src/middlewares/joi/index.ts b/packages/decap-server/src/middlewares/joi/index.ts
index 430816bc02b9..1b99cfb68faa 100644
--- a/packages/decap-server/src/middlewares/joi/index.ts
+++ b/packages/decap-server/src/middlewares/joi/index.ts
@@ -21,6 +21,8 @@ const allowedActions = [
   'deleteFile',
   'deleteFiles',
   'getDeployPreview',
+  'saveNotesFile',
+  'getNotesFile',
 ];
 
 const requiredString = Joi.string().required();
@@ -222,6 +224,35 @@ export function defaultSchema({ path = requiredString } = {}) {
           })
           .required(),
       },
+      {
+        is: 'saveNotesFile',
+        then: defaultParams
+          .keys({
+            path,
+            notes: Joi.array()
+              .items(
+                Joi.object({
+                  id: requiredString,
+                  content: requiredString,
+                  timestamp: requiredString,
+                  author: requiredString,
+                  entrySlug: requiredString,
+                  resolved: requiredBool,
+                })
+              )
+              .required(),
+          })
+          .required(),
+      },
+
+      {
+        is: 'getNotesFile',
+        then: defaultParams
+          .keys({
+            path,
+          })
+          .required(),
+      },
     ],
     otherwise: Joi.forbidden(),
   });
diff --git a/packages/decap-server/src/middlewares/localFs/index.ts b/packages/decap-server/src/middlewares/localFs/index.ts
index e1c265763d10..4233999f6db8 100644
--- a/packages/decap-server/src/middlewares/localFs/index.ts
+++ b/packages/decap-server/src/middlewares/localFs/index.ts
@@ -128,6 +128,39 @@ export function localFsMiddleware({ repoPath, logger }: FsOptions) {
           res.json(null);
           break;
         }
+        case 'getNotesFile': {
+          const { path: notesPath } = body.params;
+          try {
+            const { promises: fs } = await import('fs');
+            const fullPath = path.join(repoPath, notesPath);
+            const data = await fs.readFile(fullPath, 'utf8');
+            const notes = JSON.parse(data);
+            res.json({ notes });
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            res.status(404).json({ error: errorMessage });
+          }
+          break;
+        }
+
+        case 'saveNotesFile': {
+          const { path: notesPath, notes } = body.params;
+          try {
+            const { promises: fs } = await import('fs');
+            const fullPath = path.join(repoPath, notesPath);
+            const dir = path.dirname(fullPath);
+            
+            await fs.mkdir(dir, { recursive: true });
+            
+            await fs.writeFile(fullPath, JSON.stringify(notes, null, 2));
+
+            res.json({ success: true });
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            res.status(500).json({ error: errorMessage });
+          }
+          break;
+        }
         default: {
           const message = `Unknown action ${body.action}`;
           res.status(422).json({ error: message });
diff --git a/packages/decap-server/src/middlewares/localGit/index.ts b/packages/decap-server/src/middlewares/localGit/index.ts
index a8765223ef1a..24e2240d69b3 100644
--- a/packages/decap-server/src/middlewares/localGit/index.ts
+++ b/packages/decap-server/src/middlewares/localGit/index.ts
@@ -430,6 +430,36 @@ export function localGitMiddleware({ repoPath, logger }: GitOptions) {
           res.json(null);
           break;
         }
+        case 'getNotesFile': {
+          const { path: notesPath } = body.params;
+          try {
+            const fullPath = path.join(repoPath, notesPath);
+            const data = await fs.readFile(fullPath, 'utf8');
+            const notes = JSON.parse(data);
+            res.json({ notes });
+          } catch (error) {
+            res.json({ notes: [] });
+          }
+          break;
+        }
+
+        case 'saveNotesFile': {
+          const { path: notesPath, notes } = body.params;
+          try {
+            const fullPath = path.join(repoPath, notesPath);
+            const dir = path.dirname(fullPath);
+
+            await fs.mkdir(dir, { recursive: true });
+
+            await fs.writeFile(fullPath, JSON.stringify(notes, null, 2));
+            
+            res.json({ success: true });
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            res.status(500).json({ error: errorMessage });
+          }
+          break;
+        }
         default: {
           const message = `Unknown action ${body.action}`;
           res.status(422).json({ error: message });

From e04f2f01ecceb5a6c19eaf6107b24f4845f37526 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Mon, 28 Jul 2025 12:33:14 +0100
Subject: [PATCH 05/40] feat: notespane now integrated with Github backend

---
 packages/decap-cms-backend-github/src/API.ts  | 119 ++++++-
 .../src/implementation.tsx                    | 120 +++++++
 .../src/types/githubPullRequests.ts           |  18 ++
 .../decap-cms-core/src/actions/entries.ts     | 295 +++++++++++++-----
 packages/decap-cms-core/src/backend.ts        |  54 ++++
 .../src/components/Editor/Editor.js           |  40 ++-
 .../src/components/Editor/EditorInterface.js  |  14 +-
 .../Editor/EditorNotesPane/EditorNotesPane.js |   9 +-
 .../decap-cms-lib-util/src/implementation.ts  |  14 +
 9 files changed, 592 insertions(+), 91 deletions(-)
 create mode 100644 packages/decap-cms-backend-github/src/types/githubPullRequests.ts

diff --git a/packages/decap-cms-backend-github/src/API.ts b/packages/decap-cms-backend-github/src/API.ts
index 8a05ac4cf308..a618cfc1f9fb 100644
--- a/packages/decap-cms-backend-github/src/API.ts
+++ b/packages/decap-cms-backend-github/src/API.ts
@@ -37,9 +37,11 @@ import type {
   PersistOptions,
   FetchError,
   ApiRequest,
+  Note,
 } from 'decap-cms-lib-util';
 import type { Semaphore } from 'semaphore';
 import type { Octokit } from '@octokit/rest';
+import type { GitHubIssueComment } from './types/githubPullRequests';
 
 type GitHubUser = Octokit.UsersGetAuthenticatedResponse;
 type GitCreateTreeParamsTree = Octokit.GitCreateTreeParamsTree;
@@ -1474,4 +1476,119 @@ export default class API {
     const pullRequest = await this.getBranchPullRequest(branch);
     return pullRequest.head.sha;
   }
-}
+
+  /**
+   * 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';
+  // 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]+)$/;
+
+  private async getPRComments(prNumber: string | number): Promise<GitHubIssueComment[]> {
+    try {
+      const response: GitHubIssueComment[] = await this.request(
+        `${this.originRepoURL}/issues/${prNumber}/comments`
+      );
+      return Array.isArray(response) ? response : [];
+    } catch (error) {
+      console.error('Failed to get PR comments:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Format a note for PR comment display
+   */
+  private formatNoteForPR(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
+   */
+  private parseCommentToNote(comment: GitHubIssueComment): Note {
+    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;
+    
+    return {
+      id: comment.id.toString(),
+      author: comment.user.login,
+      timestamp: comment.created_at,
+      content,
+      resolved,
+      entrySlug: ''
+    };
+  }
+
+  async getNotesFromPR(prNumber: string | number): Promise<Note[]> {
+    const comments = await this.getPRComments(prNumber);
+    return comments.map(comment => this.parseCommentToNote(comment));
+  }
+
+  async createPRComment(prNumber: string | number, note: Note): Promise<string> {
+    const response: GitHubIssueComment = await this.request(
+      `${this.originRepoURL}/issues/${prNumber}/comments`,
+      {
+        method: 'POST',
+        body: JSON.stringify({
+          body: this.formatNoteForPR(note)
+        })
+      }
+    );
+    
+    return response.id.toString();
+  }
+
+  async updatePRComment(commentId: string | number, note: Note): Promise<void> {
+    await this.request(`${this.originRepoURL}/issues/comments/${commentId}`, {
+      method: 'PATCH',
+      body: JSON.stringify({
+        body: this.formatNoteForPR(note)
+      })
+    });
+  }
+
+  async deletePRComment(commentId: string | number): Promise<void> {
+    await this.request(`${this.originRepoURL}/issues/comments/${commentId}`, {
+      method: 'DELETE'
+    });
+  }
+
+  /**
+   * Get PR metadata from branch name
+   */
+  async getPRMetadataFromBranch(branchName: string): Promise<{
+    id: string;
+    url: string;
+    author: string;
+    createdAt: string;
+  } | null> {
+    try {
+      const response: GitHubPull[] = await this.request(`${this.originRepoURL}/pulls`, {
+        params: {
+          head: await this.getHeadReference(branchName),
+          state: 'open'
+        }
+      });
+      
+      const pr = response[0];
+      if (!pr) return null;
+      
+      return {
+        id: pr.number.toString(),
+        url: pr.html_url,
+        author: pr.user?.login || 'unknown',
+        createdAt: pr.created_at
+      };
+    } catch (error) {
+      console.error('Failed to get PR metadata:', error);
+      return null;
+    }
+  }
+}
\ No newline at end of file
diff --git a/packages/decap-cms-backend-github/src/implementation.tsx b/packages/decap-cms-backend-github/src/implementation.tsx
index 31149d8e9f26..e71b8e9e793b 100644
--- a/packages/decap-cms-backend-github/src/implementation.tsx
+++ b/packages/decap-cms-backend-github/src/implementation.tsx
@@ -39,6 +39,7 @@ import type {
   ImplementationFile,
   UnpublishedEntryMediaFile,
   Entry,
+  Note,
 } from 'decap-cms-lib-util';
 import type { Semaphore } from 'semaphore';
 
@@ -716,4 +717,123 @@ export default class GitHub implements Implementation {
       'Failed to acquire publish entry lock',
     );
   }
+
+    // Notes implementation, which is an abstraction to Github's PR issue comments.
+
+  /**
+   * Helper method to get PR info for an entry
+   */
+  private async getPRInfo(collection: string, slug: string) {
+    const contentKey = this.api!.generateContentKey(collection, slug);
+    const branch = branchFromContentKey(contentKey);
+    const pullRequest = await this.api!.getBranchPullRequest(branch);
+    
+    return {
+      branch,
+      pullRequest,
+      hasPR: pullRequest.number !== -1
+    };
+  }
+
+  async getNotes(collection: string, slug: string): Promise<Note[]> {
+    
+    if(!this.options.useWorkflow) {
+      return []
+    }
+    try {
+      const { pullRequest, hasPR } = await this.getPRInfo(collection, slug);
+      
+      if (!hasPR) {
+        return [];
+      }
+      
+      const notes = await this.api!.getNotesFromPR(pullRequest.number);
+      return notes.map(note => ({ ...note, entrySlug: slug }));
+    } catch (error) {
+      console.error('Failed to get notes:', error);
+      return [];
+    }
+  }
+
+  async addNote(collection: string, slug: string, noteData: Omit<Note, 'id'>): Promise<Note> {
+    
+    if(!this.options.useWorkflow) {
+      throw new Error('Notes are only available when workflow is enabled.')
+    }
+
+    const { pullRequest, hasPR } = await this.getPRInfo(collection, slug);
+    
+    if (!hasPR) {
+      throw new Error('Cannot add notes to draft entries. Please submit for review first.');
+    }
+    
+    const note: Note = {
+      ...noteData,
+      id: 'temp-' + Date.now(),
+      entrySlug: slug,
+      timestamp: noteData.timestamp || new Date().toISOString(),
+      resolved: noteData.resolved || false
+    };
+    
+    const commentId = await this.api!.createPRComment(pullRequest.number, note);
+    return { ...note, id: commentId };
+  }
+
+  async updateNote(collection: string, slug: string, noteId: string, updates: Partial<Note>): Promise<Note> {
+
+    if(!this.options.useWorkflow) {
+      throw new Error('Notes are only available when workflow is enabled.')
+    }
+
+    const currentNotes = await this.getNotes(collection, slug);
+    const existingNote = currentNotes.find(note => note.id === noteId);
+    
+    if (!existingNote) {
+      throw new Error(`Note with ID ${noteId} not found`);
+    }
+    
+    const updatedNote: Note = {
+      ...existingNote,
+      ...updates,
+      id: noteId,
+      entrySlug: slug
+    };
+    
+    await this.api!.updatePRComment(noteId, updatedNote);
+    return updatedNote;
+  }
+
+  async deleteNote(collection: string, slug: string, noteId: string): Promise<void> {
+
+    if(!this.options.useWorkflow) {
+      throw new Error('Notes are only available when workflow is enabled.')
+    }
+
+    const currentNotes = await this.getNotes(collection, slug);
+    const noteExists = currentNotes.some(note => note.id === noteId);
+    
+    if (!noteExists) {
+      throw new Error(`Note with ID ${noteId} not found`);
+    }
+    
+    await this.api!.deletePRComment(noteId);
+  }
+
+  async toggleNoteResolution(collection: string, slug: string, noteId: string): Promise<Note> {
+
+    if(!this.options.useWorkflow) {
+      throw new Error('Notes are only available when workflow is enabled.')
+    }
+
+    const currentNotes = await this.getNotes(collection, slug);
+    const note = currentNotes.find(n => n.id === noteId);
+    
+    if (!note) {
+      throw new Error(`Note with ID ${noteId} not found`);
+    }
+    
+    return this.updateNote(collection, slug, noteId, {
+      resolved: !note.resolved
+    });
+  }
 }
diff --git a/packages/decap-cms-backend-github/src/types/githubPullRequests.ts b/packages/decap-cms-backend-github/src/types/githubPullRequests.ts
new file mode 100644
index 000000000000..e36fe877931c
--- /dev/null
+++ b/packages/decap-cms-backend-github/src/types/githubPullRequests.ts
@@ -0,0 +1,18 @@
+type GitHubIssueComment = {
+  id: number;
+  node_id: string;
+  url: string;
+  html_url: string;
+  body: string;
+  user: {
+    login: string;
+    id: number;
+    avatar_url: string;
+    html_url: string;
+  };
+  created_at: string;
+  updated_at: string;
+  author_association: string;
+};
+
+export type { GitHubIssueComment }
\ No newline at end of file
diff --git a/packages/decap-cms-core/src/actions/entries.ts b/packages/decap-cms-core/src/actions/entries.ts
index cf63afebf25a..57dcd10d78d5 100644
--- a/packages/decap-cms-core/src/actions/entries.ts
+++ b/packages/decap-cms-core/src/actions/entries.ts
@@ -90,9 +90,16 @@ export const DRAFT_NOTES_LOAD = 'DRAFT_NOTES_LOAD';
 export const DRAFT_NOTE_ADD = 'DRAFT_NOTE_ADD';
 export const DRAFT_NOTE_UPDATE = 'DRAFT_NOTE_UPDATE';
 export const DRAFT_NOTE_DELETE = 'DRAFT_NOTE_DELETE';
-export const SAVE_NOTE_REQUEST = 'SAVE_NOTE_REQUEST';
-export const SAVE_NOTE_SUCCESS = 'SAVE_NOTE_SUCCESS'
-export const SAVE_NOTE_FAILURE = 'SAVE_NOTE_FAILURE';
+export const NOTES_REQUEST = 'NOTES_REQUEST';
+export const NOTES_SUCCESS = 'NOTES_SUCCESS';
+export const NOTES_FAILURE = 'NOTES_FAILURE';
+export const NOTE_PERSIST_REQUEST = 'NOTE_PERSIST_REQUEST';
+export const NOTE_PERSIST_SUCCESS = 'NOTE_PERSIST_SUCCESS';
+export const NOTE_PERSIST_FAILURE = 'NOTE_PERSIST_FAILURE';
+export const NOTE_DELETE_REQUEST = 'NOTE_DELETE_REQUEST';
+export const NOTE_DELETE_SUCCESS = 'NOTE_DELETE_SUCCESS';
+export const NOTE_DELETE_FAILURE = 'NOTE_DELETE_FAILURE';
+
 
 /*
  * Simple Action Creators (Internal)
@@ -560,7 +567,7 @@ export function loadEntry(collection: Collection, slug: string) {
       const loadedEntry = await tryLoadEntry(getState(), collection, slug);
       dispatch(entryLoaded(collection, loadedEntry));
       dispatch(createDraftFromEntry(loadedEntry));
-      loadNotesFromFile(dispatch, getState(), collection, slug);
+      dispatch(loadNotes(collection, slug));
     } catch (error) {
       dispatch(
         addNotification({
@@ -966,7 +973,6 @@ export function persistEntry(collection: Collection) {
           await dispatch(loadMedia());
         }
         dispatch(entryPersisted(collection, serializedEntry, newSlug));
-        saveNotesToFile(state, collection, newSlug || entry.get('slug'));
         if (collection.has('nested')) {
           await dispatch(loadEntries(collection));
         }
@@ -1019,105 +1025,248 @@ export function deleteEntry(collection: Collection, slug: string) {
       });
   };
 }
+  export function notesLoading(collection: Collection, slug: string) {
+  return {
+    type: NOTES_REQUEST,
+    payload: {
+      collection: collection.get('name'),
+      slug,
+    },
+  };
+}
+
+export function notesLoaded(collection: Collection, slug: string, notes: Note[]) {
+  return {
+    type: NOTES_SUCCESS,
+    payload: {
+      collection: collection.get('name'),
+      slug,
+      notes,
+    },
+  };
+}
+
+export function notesLoadError(error: Error, collection: Collection, slug: string) {
+  return {
+    type: NOTES_FAILURE,
+    payload: {
+      error,
+      collection: collection.get('name'),
+      slug,
+    },
+  };
+}
+
+export function notePersisting(collection: Collection, slug: string, note: Note) {
+  return {
+    type: NOTE_PERSIST_REQUEST,
+    payload: {
+      collection: collection.get('name'),
+      slug,
+      noteId: note.id,
+    },
+  };
+}
+
+export function notePersisted(collection: Collection, slug: string, note: Note) {
+  return {
+    type: NOTE_PERSIST_SUCCESS,
+    payload: {
+      collection: collection.get('name'),
+      slug,
+      note,
+    },
+  };
+}
+
+export function notePersistFail(collection: Collection, slug: string, note: Note, error: Error) {
+  return {
+    type: NOTE_PERSIST_FAILURE,
+    error: 'Failed to persist note',
+    payload: {
+      collection: collection.get('name'),
+      slug,
+      noteId: note.id,
+      error: error.toString(),
+    },
+  };
+}
 
-export function saveNoteRequest(noteId: string) {
+export function noteDeleting(collection: Collection, slug: string, noteId: string) {
   return {
-    type: SAVE_NOTE_REQUEST,
-    payload: { noteId }
+    type: NOTE_DELETE_REQUEST,
+    payload: {
+      collection: collection.get('name'),
+      slug,
+      noteId,
+    },
   };
 }
 
-export function saveNoteSuccess(noteId: string) {
+export function noteDeleted(collection: Collection, slug: string, noteId: string) {
   return {
-    type: SAVE_NOTE_SUCCESS,
-    payload: { noteId }
+    type: NOTE_DELETE_SUCCESS,
+    payload: {
+      collection: collection.get('name'),
+      slug,
+      noteId,
+    },
   };
 }
 
-export function saveNoteFailure(noteId: string, error: Error) {
+export function noteDeleteFail(collection: Collection, slug: string, noteId: string, error: Error) {
   return {
-    type: SAVE_NOTE_FAILURE,
-    payload: { noteId, error: error.toString() }
+    type: NOTE_DELETE_FAILURE,
+    payload: {
+      collection: collection.get('name'),
+      slug,
+      noteId,
+      error: error.toString(),
+    },
   };
 }
 
-// New thunk action for saving a single note
-export function saveNote(collection: Collection, slug: string, note: Note) {
+export function loadNotes(collection: Collection, slug: string) {
   return async (dispatch: ThunkDispatch<State, {}, AnyAction>, getState: () => State) => {
-    const state = getState();
-    const backend = currentBackend(state.config);
-    
-    console.log('🔥 saveNote called!', { collection: collection.get('name'), slug, noteId: note.id });
-    
-    dispatch(saveNoteRequest(note.id));
-    
+    dispatch(notesLoading(collection, slug));
     try {
-      if (typeof backend.saveNotesFile === 'function') {
-        const allNotes = state.entryDraft.get('notes');
-        const notesPath = `${collection.get('folder')}/${slug}.json`;
-        await backend.saveNotesFile(notesPath, allNotes.toJS());
-        dispatch(saveNoteSuccess(note.id));       
-      } else {
-        throw new Error('Backend does not support notes persistence');
-      }
-    } catch (error) { 
-      dispatch(saveNoteFailure(note.id, error));
+      const state = getState();
+      const backend = currentBackend(state.config);
+      const notes = await backend.getNotes(collection.get('name'), slug);
+      
+      // Set entrySlug for all notes
+      const notesWithSlug = notes.map(note => ({ ...note, entrySlug: slug }));
+      
+      dispatch(notesLoaded(collection, slug, notesWithSlug));
+      dispatch(loadNotesForEntry(notesWithSlug));
+    } catch (error) {
+      dispatch(notesLoadError(error, collection, slug));
+      dispatch(loadNotesForEntry([])); // Start with empty notes
     }
   };
 }
 
-export function addNoteAndSave(collection: Collection, slug: string, note: Note, saveImmediately = true) {
-  return async (dispatch: ThunkDispatch<State, {}, AnyAction>) => {
-    dispatch(addNote(note));
-    if (saveImmediately) {
-      await dispatch(saveNote(collection, slug, note));
+export function persistNote(collection: Collection, slug: string, note: Omit<Note, 'id'>) {
+  return async (dispatch: ThunkDispatch<State, {}, AnyAction>, getState: () => State) => {
+    const backend = currentBackend(getState().config);
+    dispatch(notePersisting(collection, slug, note as Note));
+    
+    try {
+      const savedNote = await backend.addNote(collection.get('name'), slug, note);
+      dispatch(notePersisted(collection, slug, savedNote));
+      dispatch(addNote(savedNote));
+      return savedNote;
+    } catch (error) {
+      dispatch(notePersistFail(collection, slug, note as Note, error));
     }
   };
 }
 
-export function updateNoteAndSave(collection: Collection, slug: string, noteId: string, updates: Partial<Note>, saveImmediately = true) {
-  return async (dispatch: ThunkDispatch<State, {}, AnyAction>) => {
-    dispatch(updateNote(noteId, updates));
-    if (saveImmediately) {
-      const updatedNote = { id: noteId, ...updates } as Note;
-      await dispatch(saveNote(collection, slug, updatedNote));
+export function updateNotePersist(collection: Collection, slug: string, noteId: string, updates: Partial<Note>) {
+  return async (dispatch: ThunkDispatch<State, {}, AnyAction>, getState: () => State) => {
+    const state = getState();
+    const backend = currentBackend(state.config);
+    
+    // Create a temporary note object for the persist actions
+    const tempNote = { id: noteId, ...updates } as Note;
+    dispatch(notePersisting(collection, slug, tempNote));
+    
+    try {
+      const updatedNote = await backend.updateNote(collection.get('name'), slug, noteId, updates);
+      dispatch(notePersisted(collection, slug, updatedNote));
+      dispatch(updateNote(noteId, updates));
+      
+      dispatch(addNotification({
+        message: {
+          key: 'ui.toast.noteUpdated',
+        },
+        type: 'success',
+        dismissAfter: 4000,
+      }));
+      
+      return updatedNote;
+    } catch (error) {
+      dispatch(notePersistFail(collection, slug, tempNote, error));
+      dispatch(addNotification({
+        message: {
+          details: error.message,
+          key: 'ui.toast.onFailToUpdateNote',
+        },
+        type: 'error',
+        dismissAfter: 8000,
+      }));
     }
   };
 }
 
-export function deleteNoteAndSave(collection: Collection, slug: string, noteId: string, saveImmediately = true) {
-  return async (dispatch: ThunkDispatch<State, {}, AnyAction>) => {
-    dispatch(deleteNote(noteId));
-    if (saveImmediately) {
-      const dummyNote = { id: noteId } as Note;
-      await dispatch(saveNote(collection, slug, dummyNote));
+export function deleteNotePersist(collection: Collection, slug: string, noteId: string) {
+  return async (dispatch: ThunkDispatch<State, {}, AnyAction>, getState: () => State) => {
+    const state = getState();
+    const backend = currentBackend(state.config);
+    
+    dispatch(noteDeleting(collection, slug, noteId));
+    
+    try {
+      await backend.deleteNote(collection.get('name'), slug, noteId);
+      dispatch(noteDeleted(collection, slug, noteId));
+      dispatch(deleteNote(noteId));
+      
+      dispatch(addNotification({
+        message: {
+          key: 'ui.toast.noteDeleted',
+        },
+        type: 'success',
+        dismissAfter: 4000,
+      }));
+    } catch (error) {
+      dispatch(noteDeleteFail(collection, slug, noteId, error));
+      dispatch(addNotification({
+        message: {
+          details: error.message,
+          key: 'ui.toast.onFailToDeleteNote',
+        },
+        type: 'error',
+        dismissAfter: 8000,
+      }));
     }
   };
 }
 
-function saveNotesToFile(state: State, collection: Collection, slug: string) {
-  const backend = currentBackend(state.config);
-  const notes = state.entryDraft.get('notes');
-
-  if (typeof backend.saveNotesFile === 'function') {
-    const notesPath = `${collection.get('folder')}/${slug}.json`;
-    return backend.saveNotesFile(notesPath, notes.toJS());
-  }
-
-  console.log('Backend does not support notes persistence yet.')
-}
-
-function loadNotesFromFile(dispatch: ThunkDispatch<State, {}, AnyAction>, state: State, collection: Collection, slug: string) {
-  const backend = currentBackend(state.config);
-  if (typeof backend.getNotesFile === 'function') {
-    const notesPath = `${collection.get('folder')}/${slug}.json`;
-    return backend.getNotesFile(notesPath).then(notes => {
-      dispatch(loadNotesForEntry(notes));
-    });
-  }
-  
-  console.log('Backend does not support notes persistence yet');
-  dispatch(loadNotesForEntry([])); // Start with empty notes
+export function toggleNoteResolutionPersist(collection: Collection, slug: string, noteId: string) {
+  return async (dispatch: ThunkDispatch<State, {}, AnyAction>, getState: () => State) => {
+    const state = getState();
+    const backend = currentBackend(state.config);
+    
+    // Create a temporary note object for the persist actions
+    const tempNote = { id: noteId } as Note;
+    dispatch(notePersisting(collection, slug, tempNote));
+    
+    try {
+      const updatedNote = await backend.toggleNoteResolution(collection.get('name'), slug, noteId);
+      dispatch(notePersisted(collection, slug, updatedNote));
+      dispatch(updateNote(noteId, { resolved: updatedNote.resolved }));
+      
+      dispatch(addNotification({
+        message: {
+          key: updatedNote.resolved ? 'ui.toast.noteResolved' : 'ui.toast.noteReopened',
+        },
+        type: 'success',
+        dismissAfter: 4000,
+      }));
+      
+      return updatedNote;
+    } catch (error) {
+      dispatch(notePersistFail(collection, slug, tempNote, error));
+      dispatch(addNotification({
+        message: {
+          details: error.message,
+          key: 'ui.toast.onFailToToggleNote',
+        },
+        type: 'error',
+        dismissAfter: 8000,
+      }));
+    }
+  };
 }
 
 function getPathError(
diff --git a/packages/decap-cms-core/src/backend.ts b/packages/decap-cms-core/src/backend.ts
index afa1f707e9a7..663f51a9a8ec 100644
--- a/packages/decap-cms-core/src/backend.ts
+++ b/packages/decap-cms-core/src/backend.ts
@@ -602,6 +602,60 @@ export class Backend {
     console.log('Backend does not support notes persistence yet');
     return [];
   }
+    async getNotes(collection: string, slug: string): Promise<Note[]> {
+    if (typeof this.implementation.getNotes === 'function') {
+      return this.implementation.getNotes(collection, slug);
+    }
+    
+    // If backend doesn't support notes, return empty array
+    console.warn(`Backend '${this.backendName}' does not support notes`);
+    return [];
+  }
+
+  async addNote(collection: string, slug: string, note: Omit<Note, 'id'>): Promise<Note> {
+    if (typeof this.implementation.addNote === 'function') {
+      return this.implementation.addNote(collection, slug, note);
+    }
+    
+    throw new Error(`Backend '${this.backendName}' does not support adding notes`);
+  }
+
+  async updateNote(collection: string, slug: string, noteId: string, updates: Partial<Note>): Promise<Note> {
+    if (typeof this.implementation.updateNote === 'function') {
+      return this.implementation.updateNote(collection, slug, noteId, updates);
+    }
+    
+    throw new Error(`Backend '${this.backendName}' does not support updating notes`);
+  }
+
+  async deleteNote(collection: string, slug: string, noteId: string): Promise<void> {
+    if (typeof this.implementation.deleteNote === 'function') {
+      return this.implementation.deleteNote(collection, slug, noteId);
+    }
+    
+    throw new Error(`Backend '${this.backendName}' does not support deleting notes`);
+  }
+
+  async toggleNoteResolution(collection: string, slug: string, noteId: string): Promise<Note> {
+    if (typeof this.implementation.toggleNoteResolution === 'function') {
+      return this.implementation.toggleNoteResolution(collection, slug, noteId);
+    }
+    
+    throw new Error(`Backend '${this.backendName}' does not support toggling note resolution`);
+  }
+
+  async getPRMetadata(collection: string, slug: string): Promise<{
+    id: string;
+    url: string;
+    author: string;
+    createdAt: string;
+  } | null> {
+    if (typeof this.implementation.getPRMetadata === 'function') {
+      return this.implementation.getPRMetadata(collection, slug);
+    }
+    
+    return null;
+  }
 
   // The same as listEntries, except that if a cursor with the "next"
   // action available is returned, it calls "next" on the cursor and
diff --git a/packages/decap-cms-core/src/components/Editor/Editor.js b/packages/decap-cms-core/src/components/Editor/Editor.js
index a3a891e490f5..994221f0b65d 100644
--- a/packages/decap-cms-core/src/components/Editor/Editor.js
+++ b/packages/decap-cms-core/src/components/Editor/Editor.js
@@ -23,9 +23,10 @@ import {
   retrieveLocalBackup,
   deleteLocalBackup,
   loadNotesForEntry,
-  addNoteAndSave,
-  updateNoteAndSave,
-  deleteNoteAndSave,
+  loadNotes,
+  persistNote,
+  updateNotePersist,
+  deleteNotePersist,
 } from '../../actions/entries';
 import {
   updateUnpublishedEntryStatus,
@@ -51,6 +52,7 @@ export class Editor extends React.Component {
     entry: ImmutablePropTypes.map,
     entryDraft: ImmutablePropTypes.map.isRequired,
     loadEntry: PropTypes.func.isRequired,
+    loadNotes: PropTypes.func,
     persistEntry: PropTypes.func.isRequired,
     deleteEntry: PropTypes.func.isRequired,
     showDelete: PropTypes.bool.isRequired,
@@ -179,6 +181,23 @@ export class Editor extends React.Component {
         this.deleteBackup();
       }
     }
+    if (
+    !prevProps.entry && 
+    this.props.entry && 
+    !this.props.newEntry &&
+    this.props.hasWorkflow
+  ) {
+    this.props.loadNotes(this.props.collection, this.props.slug);
+  }
+
+  if (
+    prevProps.entry !== this.props.entry && 
+    this.props.entry && 
+    !this.props.newEntry &&
+    this.props.hasWorkflow
+  ) {
+    this.props.loadNotes(this.props.collection, this.props.slug);
+  }
 
     if (this.props.hasChanged) {
       this.createBackup(this.props.entryDraft.get('entry'), this.props.collection);
@@ -345,13 +364,14 @@ export class Editor extends React.Component {
     
     switch(action) {
       case 'ADD_NOTE':
-        this.props.addNoteAndSave(collection, slug, payload);
+        this.props.persistNote(collection, slug, payload);
+        console.log(payload)
         break;
       case 'UPDATE_NOTE':
-        this.props.updateNoteAndSave(collection, slug, payload.id, payload.updates);
+        this.props.updateNotePersist(collection, slug, payload.id, payload.updates);
         break;
       case 'DELETE_NOTE':
-        this.props.deleteNoteAndSave(collection, slug, payload.id);
+        this.props.deleteNotePersist(collection, slug, payload.id);
         break;
       default:
         console.log('Unknown notes action:', action, payload)
@@ -427,6 +447,7 @@ export class Editor extends React.Component {
         hasUnpublishedChanges={unpublishedEntry}
         isNewEntry={newEntry}
         isModification={isModification}
+        isPublished={isPublished}
         currentStatus={currentStatus}
         onLogoutClick={logoutUser}
         deployPreview={deployPreview}
@@ -517,9 +538,10 @@ const mapDispatchToProps = {
   deleteUnpublishedEntry,
   logoutUser,
   loadNotesForEntry,
-  addNoteAndSave,
-  updateNoteAndSave,
-  deleteNoteAndSave
+  loadNotes,
+  persistNote,
+  updateNotePersist,
+  deleteNotePersist
 };
 
 export default connect(mapStateToProps, mapDispatchToProps)(withWorkflow(translate()(Editor)));
diff --git a/packages/decap-cms-core/src/components/Editor/EditorInterface.js b/packages/decap-cms-core/src/components/Editor/EditorInterface.js
index 016486227634..0e0a0e217729 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorInterface.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorInterface.js
@@ -166,7 +166,14 @@ function isPreviewEnabled(collection, entry) {
   return collection.getIn(['editor', 'preview'], true);
 }
 
-function isNotesEnabled(collection, entry) {
+function isNotesEnabled(collection, entry, isPublished) {
+// Notes are only enabled on unpublished entries
+
+  if (isPublished) {
+    return false;
+  }
+  
+
   if (collection.get('type') === FILES) {
     const file = getFileFromSlug(collection, entry.get('slug'));
     const notesEnabled = file?.getIn(['editor', 'notes']);
@@ -274,6 +281,7 @@ class EditorInterface extends Component {
       hasUnpublishedChanges,
       isNewEntry,
       isModification,
+      isPublished,
       currentStatus,
       onLogoutClick,
       loadDeployPreview,
@@ -286,7 +294,7 @@ class EditorInterface extends Component {
     const { scrollSyncEnabled, showEventBlocker } = this.state;
 
     const previewEnabled = isPreviewEnabled(collection, entry);
-    const notesEnabled = isNotesEnabled(collection, entry);
+    const notesEnabled = isNotesEnabled(collection, entry, isPublished);
 
     const { locales, defaultLocale } = getI18nInfo(this.props.collection);
     const collectionI18nEnabled = hasI18n(collection) && locales.length > 1;
@@ -370,6 +378,7 @@ class EditorInterface extends Component {
                 onChange={this.handleNotesChange}
                 entry={entry}
                 collection={collection}
+                user={user}
                 t={t}
               />
             </NotesPaneContainer>
@@ -513,6 +522,7 @@ EditorInterface.propTypes = {
   hasUnpublishedChanges: PropTypes.bool,
   isNewEntry: PropTypes.bool,
   isModification: PropTypes.bool,
+  isPublished: PropTypes.bool,
   currentStatus: PropTypes.string,
   onLogoutClick: PropTypes.func.isRequired,
   deployPreview: PropTypes.object,
diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js
index c7818dba46d7..8829183d168c 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js
@@ -87,13 +87,10 @@ class EditorNotesPane extends Component {
   };
 
   handleAddNote = (content) => {
-    const { onChange, entry } = this.props;
+    const { onChange, user } = this.props;
     const newNote = {
-      id: `note_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`,
       content: content.trim(),
-      timestamp: new Date().toISOString(),
-      author: 'current-user', // TODO: Get from auth state
-      entrySlug: entry.get('slug'),
+      author: user?.name || user?.login  || 'Anonymous',
       resolved: false,
     };
 
@@ -116,7 +113,7 @@ class EditorNotesPane extends Component {
 
   render() {
     const { notes, t } = this.props;
-    const notesList = notes || List();
+    const notesList = notes && notes.size !== undefined ? notes : List(notes || []);
     const notesCount = notesList.size;
     const unresolvedCount = notesList.filter(note => !note.get('resolved')).size;
 
diff --git a/packages/decap-cms-lib-util/src/implementation.ts b/packages/decap-cms-lib-util/src/implementation.ts
index deb521a0035e..7e513d4f58f2 100644
--- a/packages/decap-cms-lib-util/src/implementation.ts
+++ b/packages/decap-cms-lib-util/src/implementation.ts
@@ -171,6 +171,20 @@ export interface Implementation {
   saveNotesFile?: (path: string, notes: Note[]) => Promise<void>
   getNotesFile?: (path: string) => Promise<Note[]>;
 
+  getNotes?: (collection: string, slug: string) => Promise<Note[]>;
+  addNote?: (collection: string, slug: string, note: Omit<Note, 'id'>) => Promise<Note>;
+  updateNote?: (collection: string, slug: string, noteId: string, updates: Partial<Note>) => Promise<Note>;
+  deleteNote?: (collection: string, slug: string, noteId: string) => Promise<void>;
+  toggleNoteResolution?: (collection: string, slug: string, noteId: string) => Promise<Note>;
+  syncNotes?: (collection: string, slug: string, localNotes: Note[]) => Promise<Note[]>;
+
+  getPRMetadata?: (collection: string, slug: string) => Promise<{
+    id: string;
+    url: string;
+    author: string;
+    createdAt: string;
+  } | null>;
+
   unpublishedEntries: () => Promise<string[]>;
   unpublishedEntry: (args: {
     id?: string;

From 51abb33fbae9a6831b9fb3669ae1e3b45a95dc72 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Mon, 28 Jul 2025 12:56:52 +0100
Subject: [PATCH 06/40] feat: adding notes to test backend

---
 .../src/implementation.ts                     | 89 ++++++++++++++-----
 .../src/components/Editor/Editor.js           |  1 -
 2 files changed, 69 insertions(+), 21 deletions(-)

diff --git a/packages/decap-cms-backend-test/src/implementation.ts b/packages/decap-cms-backend-test/src/implementation.ts
index d0b700159fb3..6ad1504b3517 100644
--- a/packages/decap-cms-backend-test/src/implementation.ts
+++ b/packages/decap-cms-backend-test/src/implementation.ts
@@ -51,11 +51,13 @@ declare global {
   interface Window {
     repoFiles: RepoTree;
     repoFilesUnpublished: { [key: string]: UnpublishedRepoEntry };
+    repoNotes: { [key: string]: Note[] };
   }
 }
 
 window.repoFiles = window.repoFiles || {};
 window.repoFilesUnpublished = window.repoFilesUnpublished || [];
+window.repoNotes = window.repoNotes || {};
 
 function getFile(path: string, tree: RepoTree) {
   const segments = path.split('/');
@@ -395,30 +397,77 @@ export default class TestBackend implements Implementation {
     };
   }
 
-    async saveNotesFile(path: string, notes: Note[]) {
-    try {
-      const notesData = JSON.stringify(notes, null, 2);
-      writeFile(path, notesData, window.repoFiles);
-      console.log(`✅ Notes saved to: ${path}`);
-    } catch (error) {
-      console.error('❌ Failed to save notes:', error);
-      throw error;
+  async getNotes(collection: string, slug: string): Promise<Note[]> {
+    const key = `${collection}/${slug}`;
+    return window.repoNotes[key] || [];
+  }
+
+  async addNote(collection: string, slug: string, note: Omit<Note, 'id'>): Promise<Note> {
+    const key = `${collection}/${slug}`;
+    const newNote: Note = {
+      ...note,
+      id: uuid(),
+      timestamp: new Date().toISOString(),
+    };
+    
+    if (!window.repoNotes[key]) {
+      window.repoNotes[key] = [];
     }
+    
+    window.repoNotes[key].push(newNote);
+    return newNote;
   }
 
-  async getNotesFile(path: string) {
-    try {
-      const file = getFile(path, window.repoFiles);
-      if (file.content) {
-        const notes = JSON.parse(file.content as string);
-        console.log(`✅ Notes loaded from: ${path}`);
-        return notes;
-      }
-      return []; // No notes file exists
-    } catch (error) {
-      console.error('❌ Failed to load notes:', error);
-      return []; // Return empty on error
+  async updateNote(collection: string, slug: string, noteId: string, updates: Partial<Note>): Promise<Note> {
+    const key = `${collection}/${slug}`;
+    const notes = window.repoNotes[key] || [];
+    const noteIndex = notes.findIndex(note => note.id === noteId);
+    
+    if (noteIndex === -1) {
+      throw new Error(`Note with id ${noteId} not found`);
+    }
+    
+    const updatedNote = {
+      ...notes[noteIndex],
+      ...updates,
+      updatedAt: new Date().toISOString(),
+    };
+    
+    window.repoNotes[key][noteIndex] = updatedNote;
+    return updatedNote;
+  }
+
+  async deleteNote(collection: string, slug: string, noteId: string): Promise<void> {
+    const key = `${collection}/${slug}`;
+    const notes = window.repoNotes[key] || [];
+    const noteIndex = notes.findIndex(note => note.id === noteId);
+    
+    if (noteIndex === -1) {
+      throw new Error(`Note with id ${noteId} not found`);
+    }
+    
+    window.repoNotes[key].splice(noteIndex, 1);
+  }
+
+  async toggleNoteResolution(collection: string, slug: string, noteId: string): Promise<Note> {
+    const key = `${collection}/${slug}`;
+    const notes = window.repoNotes[key] || [];
+    const note = notes.find(note => note.id === noteId);
+    
+    if (!note) {
+      throw new Error(`Note with id ${noteId} not found`);
     }
+    
+    const updatedNote = {
+      ...note,
+      resolved: !note.resolved,
+      updatedAt: new Date().toISOString(),
+    };
+    
+    const noteIndex = notes.findIndex(n => n.id === noteId);
+    window.repoNotes[key][noteIndex] = updatedNote;
+    
+    return updatedNote;
   }
 
   normalizeAsset(assetProxy: AssetProxy) {
diff --git a/packages/decap-cms-core/src/components/Editor/Editor.js b/packages/decap-cms-core/src/components/Editor/Editor.js
index 994221f0b65d..7109d463e140 100644
--- a/packages/decap-cms-core/src/components/Editor/Editor.js
+++ b/packages/decap-cms-core/src/components/Editor/Editor.js
@@ -365,7 +365,6 @@ export class Editor extends React.Component {
     switch(action) {
       case 'ADD_NOTE':
         this.props.persistNote(collection, slug, payload);
-        console.log(payload)
         break;
       case 'UPDATE_NOTE':
         this.props.updateNotePersist(collection, slug, payload.id, payload.updates);

From be1a1d62cfd623ddd5f0fe8230cb60e5bc1900e4 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Mon, 28 Jul 2025 12:59:48 +0100
Subject: [PATCH 07/40] chore: adding english locale to Note toasts

---
 packages/decap-cms-locales/src/en/index.js | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/packages/decap-cms-locales/src/en/index.js b/packages/decap-cms-locales/src/en/index.js
index 81e0f763927d..f2acbf379d50 100644
--- a/packages/decap-cms-locales/src/en/index.js
+++ b/packages/decap-cms-locales/src/en/index.js
@@ -293,6 +293,13 @@ const en = {
       onFailToUnpublishEntry: 'Failed to unpublish entry: %{details}',
       entryUpdated: 'Entry status updated',
       onDeleteUnpublishedChanges: 'Unpublished changes deleted',
+      noteUpdated: 'Note updated',
+      onFailToUpdateNote: 'Failed to update note: %{details}',
+      noteDeleted: 'Note deleted', 
+      onFailToDeleteNote: 'Failed to delete note: %{details}',
+      noteResolved: 'Note resolved',
+      noteReopened: 'Note reopened', 
+      onFailToToggleNote: 'Failed to toggle note resolution: %{details}',
       onFailToAuth: '%{details}',
       onLoggedOut: 'You have been logged out, please back up any data and login again',
       onBackendDown:

From 8ea8cb2e7c480a38d4dffdef53b88dea7ee5e899 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Mon, 28 Jul 2025 13:50:59 +0100
Subject: [PATCH 08/40] chore: linting + notes will only work on
 EditorialWorkflow

---
 packages/decap-cms-backend-github/src/API.ts  |  39 +--
 .../src/implementation.tsx                    |  68 ++---
 .../src/types/githubPullRequests.ts           |   2 +-
 .../src/implementation.ts                     |  88 ++++++-
 .../src/__tests__/implementation.spec.js      | 241 ------------------
 .../src/implementation.ts                     |  29 ++-
 .../decap-cms-core/src/actions/entries.ts     | 144 ++++++-----
 packages/decap-cms-core/src/backend.ts        |  45 ++--
 .../src/components/Editor/Editor.js           |  37 ++-
 .../src/components/Editor/EditorInterface.js  |  17 +-
 .../Editor/EditorNotesPane/AddNoteForm.js     |  32 ++-
 .../Editor/EditorNotesPane/EditorNotesPane.js |  27 +-
 .../Editor/EditorNotesPane/NoteItem.js        |  22 +-
 .../Editor/EditorNotesPane/NotesList.js       |  23 +-
 .../decap-cms-core/src/reducers/entryDraft.js |  20 +-
 packages/decap-cms-core/src/types/redux.ts    |   8 +-
 .../decap-cms-lib-util/src/implementation.ts  |  15 +-
 packages/decap-cms-lib-util/src/index.ts      |   2 +-
 packages/decap-cms-locales/src/en/index.js    |   4 +-
 .../decap-server/src/middlewares/joi/index.ts |  31 ---
 .../src/middlewares/localFs/index.ts          |  33 ---
 .../src/middlewares/localGit/index.ts         |  30 ---
 22 files changed, 339 insertions(+), 618 deletions(-)

diff --git a/packages/decap-cms-backend-github/src/API.ts b/packages/decap-cms-backend-github/src/API.ts
index a618cfc1f9fb..f00cde6104f2 100644
--- a/packages/decap-cms-backend-github/src/API.ts
+++ b/packages/decap-cms-backend-github/src/API.ts
@@ -1483,12 +1483,13 @@ export default class API {
   private static readonly NOTE_STATUS_RESOLVED = 'RESOLVED';
   private static readonly NOTE_STATUS_OPEN = 'OPEN';
   // 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]+)$/;
+  private static readonly NOTE_REGEX =
+    /^<!-- DecapCMS Note - Status: (RESOLVED|OPEN) -->([\s\S]+)$/;
 
   private async getPRComments(prNumber: string | number): Promise<GitHubIssueComment[]> {
     try {
       const response: GitHubIssueComment[] = await this.request(
-        `${this.originRepoURL}/issues/${prNumber}/comments`
+        `${this.originRepoURL}/issues/${prNumber}/comments`,
       );
       return Array.isArray(response) ? response : [];
     } catch (error) {
@@ -1502,7 +1503,7 @@ export default class API {
    */
   private formatNoteForPR(note: Note): string {
     const status = note.resolved ? API.NOTE_STATUS_RESOLVED : API.NOTE_STATUS_OPEN;
-    
+
     return `<!-- DecapCMS Note - Status: ${status} -->    
 ${note.content}`;
   }
@@ -1512,17 +1513,17 @@ ${note.content}`;
    */
   private parseCommentToNote(comment: GitHubIssueComment): Note {
     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;
-    
+
     return {
       id: comment.id.toString(),
       author: comment.user.login,
       timestamp: comment.created_at,
       content,
       resolved,
-      entrySlug: ''
+      entrySlug: '',
     };
   }
 
@@ -1537,11 +1538,11 @@ ${note.content}`;
       {
         method: 'POST',
         body: JSON.stringify({
-          body: this.formatNoteForPR(note)
-        })
-      }
+          body: this.formatNoteForPR(note),
+        }),
+      },
     );
-    
+
     return response.id.toString();
   }
 
@@ -1549,14 +1550,14 @@ ${note.content}`;
     await this.request(`${this.originRepoURL}/issues/comments/${commentId}`, {
       method: 'PATCH',
       body: JSON.stringify({
-        body: this.formatNoteForPR(note)
-      })
+        body: this.formatNoteForPR(note),
+      }),
     });
   }
 
   async deletePRComment(commentId: string | number): Promise<void> {
     await this.request(`${this.originRepoURL}/issues/comments/${commentId}`, {
-      method: 'DELETE'
+      method: 'DELETE',
     });
   }
 
@@ -1573,22 +1574,22 @@ ${note.content}`;
       const response: GitHubPull[] = await this.request(`${this.originRepoURL}/pulls`, {
         params: {
           head: await this.getHeadReference(branchName),
-          state: 'open'
-        }
+          state: 'open',
+        },
       });
-      
+
       const pr = response[0];
       if (!pr) return null;
-      
+
       return {
         id: pr.number.toString(),
         url: pr.html_url,
         author: pr.user?.login || 'unknown',
-        createdAt: pr.created_at
+        createdAt: pr.created_at,
       };
     } catch (error) {
       console.error('Failed to get PR metadata:', error);
       return null;
     }
   }
-}
\ No newline at end of file
+}
diff --git a/packages/decap-cms-backend-github/src/implementation.tsx b/packages/decap-cms-backend-github/src/implementation.tsx
index e71b8e9e793b..6d040f1b428b 100644
--- a/packages/decap-cms-backend-github/src/implementation.tsx
+++ b/packages/decap-cms-backend-github/src/implementation.tsx
@@ -718,7 +718,7 @@ export default class GitHub implements Implementation {
     );
   }
 
-    // Notes implementation, which is an abstraction to Github's PR issue comments.
+  // Notes implementation, which is an abstraction to Github's PR issue comments.
 
   /**
    * Helper method to get PR info for an entry
@@ -727,26 +727,25 @@ export default class GitHub implements Implementation {
     const contentKey = this.api!.generateContentKey(collection, slug);
     const branch = branchFromContentKey(contentKey);
     const pullRequest = await this.api!.getBranchPullRequest(branch);
-    
+
     return {
       branch,
       pullRequest,
-      hasPR: pullRequest.number !== -1
+      hasPR: pullRequest.number !== -1,
     };
   }
 
   async getNotes(collection: string, slug: string): Promise<Note[]> {
-    
-    if(!this.options.useWorkflow) {
-      return []
+    if (!this.options.useWorkflow) {
+      return [];
     }
     try {
       const { pullRequest, hasPR } = await this.getPRInfo(collection, slug);
-      
+
       if (!hasPR) {
         return [];
       }
-      
+
       const notes = await this.api!.getNotesFromPR(pullRequest.number);
       return notes.map(note => ({ ...note, entrySlug: slug }));
     } catch (error) {
@@ -756,84 +755,85 @@ export default class GitHub implements Implementation {
   }
 
   async addNote(collection: string, slug: string, noteData: Omit<Note, 'id'>): Promise<Note> {
-    
-    if(!this.options.useWorkflow) {
-      throw new Error('Notes are only available when workflow is enabled.')
+    if (!this.options.useWorkflow) {
+      throw new Error('Notes are only available when workflow is enabled.');
     }
 
     const { pullRequest, hasPR } = await this.getPRInfo(collection, slug);
-    
+
     if (!hasPR) {
       throw new Error('Cannot add notes to draft entries. Please submit for review first.');
     }
-    
+
     const note: Note = {
       ...noteData,
       id: 'temp-' + Date.now(),
       entrySlug: slug,
       timestamp: noteData.timestamp || new Date().toISOString(),
-      resolved: noteData.resolved || false
+      resolved: noteData.resolved || false,
     };
-    
+
     const commentId = await this.api!.createPRComment(pullRequest.number, note);
     return { ...note, id: commentId };
   }
 
-  async updateNote(collection: string, slug: string, noteId: string, updates: Partial<Note>): Promise<Note> {
-
-    if(!this.options.useWorkflow) {
-      throw new Error('Notes are only available when workflow is enabled.')
+  async updateNote(
+    collection: string,
+    slug: string,
+    noteId: string,
+    updates: Partial<Note>,
+  ): Promise<Note> {
+    if (!this.options.useWorkflow) {
+      throw new Error('Notes are only available when workflow is enabled.');
     }
 
     const currentNotes = await this.getNotes(collection, slug);
     const existingNote = currentNotes.find(note => note.id === noteId);
-    
+
     if (!existingNote) {
       throw new Error(`Note with ID ${noteId} not found`);
     }
-    
+
     const updatedNote: Note = {
       ...existingNote,
       ...updates,
       id: noteId,
-      entrySlug: slug
+      entrySlug: slug,
     };
-    
+
     await this.api!.updatePRComment(noteId, updatedNote);
     return updatedNote;
   }
 
   async deleteNote(collection: string, slug: string, noteId: string): Promise<void> {
-
-    if(!this.options.useWorkflow) {
-      throw new Error('Notes are only available when workflow is enabled.')
+    if (!this.options.useWorkflow) {
+      throw new Error('Notes are only available when workflow is enabled.');
     }
 
     const currentNotes = await this.getNotes(collection, slug);
     const noteExists = currentNotes.some(note => note.id === noteId);
-    
+
     if (!noteExists) {
       throw new Error(`Note with ID ${noteId} not found`);
     }
-    
+
     await this.api!.deletePRComment(noteId);
   }
 
   async toggleNoteResolution(collection: string, slug: string, noteId: string): Promise<Note> {
-
-    if(!this.options.useWorkflow) {
-      throw new Error('Notes are only available when workflow is enabled.')
+    if (!this.options.useWorkflow) {
+      throw new Error('Notes are only available when workflow is enabled.');
     }
 
     const currentNotes = await this.getNotes(collection, slug);
     const note = currentNotes.find(n => n.id === noteId);
-    
+
     if (!note) {
       throw new Error(`Note with ID ${noteId} not found`);
     }
-    
+
     return this.updateNote(collection, slug, noteId, {
-      resolved: !note.resolved
+      resolved: !note.resolved,
     });
   }
 }
diff --git a/packages/decap-cms-backend-github/src/types/githubPullRequests.ts b/packages/decap-cms-backend-github/src/types/githubPullRequests.ts
index e36fe877931c..55f488fc3516 100644
--- a/packages/decap-cms-backend-github/src/types/githubPullRequests.ts
+++ b/packages/decap-cms-backend-github/src/types/githubPullRequests.ts
@@ -15,4 +15,4 @@ type GitHubIssueComment = {
   author_association: string;
 };
 
-export type { GitHubIssueComment }
\ No newline at end of file
+export type { GitHubIssueComment };
diff --git a/packages/decap-cms-backend-proxy/src/implementation.ts b/packages/decap-cms-backend-proxy/src/implementation.ts
index 2dc4da760894..ae2f9a5e94ec 100644
--- a/packages/decap-cms-backend-proxy/src/implementation.ts
+++ b/packages/decap-cms-backend-proxy/src/implementation.ts
@@ -248,30 +248,94 @@ export default class ProxyBackend implements Implementation {
     return deserializeMediaFile(file);
   }
 
-  async saveNotesFile(path: string, notes: Note[]) {
+  async getNotes(collection: string, slug: string): Promise<Note[]> {
+    try {
+      const response = await this.request({
+        action: 'getNotes',
+        params: {
+          branch: this.branch,
+          collection,
+          slug
+        },
+      });
+      return response.notes || [];
+    } catch (error) {
+      console.warn('Failed to get notes:', error);
+      return [];
+    }
+  }
+
+  async addNote(collection: string, slug: string, note: Omit<Note, 'id'>): Promise<Note> {
+    const response = await this.request({
+      action: 'addNote',
+      params: {
+        branch: this.branch,
+        collection,
+        slug,
+        note
+      },
+    });
+    return response.note;
+  }
+
+  async updateNote(collection: string, slug: string, noteId: string, updates: Partial<Note>): Promise<Note> {
+    const response = await this.request({
+      action: 'updateNote',
+      params: {
+        branch: this.branch,
+        collection,
+        slug,
+        noteId,
+        updates
+      },
+    });
+    return response.note;
+  }
+
+  async deleteNote(collection: string, slug: string, noteId: string): Promise<void> {
+    await this.request({
+      action: 'deleteNote',
+      params: {
+        branch: this.branch,
+        collection,
+        slug,
+        noteId
+      },
+    });
+  }
+
+  async toggleNoteResolution(collection: string, slug: string, noteId: string): Promise<Note> {
     const response = await this.request({
-      action: 'saveNotesFile',
-      params: { 
-        branch: this.branch, 
-        path, 
-        notes 
+      action: 'toggleNoteResolution',
+      params: {
+        branch: this.branch,
+        collection,
+        slug,
+        noteId
       },
     });
-    return response;
+    return response.note;
   }
 
-  async getNotesFile(path: string): Promise<Note[]> {
+  async getPRMetadata(collection: string, slug: string): Promise<{
+    id: string;
+    url: string;
+    author: string;
+    createdAt: string;
+  } | null> {
     try {
       const response = await this.request({
-        action: 'getNotesFile',
+        action: 'getPRMetadata',
         params: {
           branch: this.branch,
-          path
+          collection,
+          slug
         },
       });
-      return response.notes || [];
+      return response.metadata || null;
     } catch (error) {
-      return [];
+      console.warn('Failed to get PR metadata:', error);
+      return null;
     }
   }
 
diff --git a/packages/decap-cms-backend-test/src/__tests__/implementation.spec.js b/packages/decap-cms-backend-test/src/__tests__/implementation.spec.js
index d1b207447648..b4b1a5920510 100644
--- a/packages/decap-cms-backend-test/src/__tests__/implementation.spec.js
+++ b/packages/decap-cms-backend-test/src/__tests__/implementation.spec.js
@@ -263,245 +263,4 @@ describe('test backend implementation', () => {
       ]);
     });
   });
-
-  describe('Notes functionality', () => {
-    let backend;
-
-    beforeEach(() => {
-      window.repoFiles = {};
-      backend = new TestBackend({ media_folder: 'uploads' });
-    });
-
-    describe('saveNotesFile', () => {
-      it('should save notes to the correct path', async () => {
-        const notes = [
-          {
-            id: 'note-1',
-            content: 'This is my first note',
-            timestamp: '2024-01-15T10:30:00Z',
-            author: 'John Doe',
-            entrySlug: 'my-first-post',
-            resolved: false
-          },
-          {
-            id: 'note-2', 
-            content: 'This is a resolved note',
-            timestamp: '2024-01-15T11:45:00Z',
-            author: 'Jane Smith',
-            entrySlug: 'my-first-post',
-            resolved: true
-          }
-        ];
-
-        await backend.saveNotesFile('.notes/blog/my-first-post.json', notes);
-
-        expect(window.repoFiles).toEqual({
-          '.notes': {
-            blog: {
-              'my-first-post.json': {
-                path: '.notes/blog/my-first-post.json',
-                content: JSON.stringify(notes, null, 2)
-              }
-            }
-          }
-        });
-      });
-
-      it('should save notes for nested collections', async () => {
-        const notes = [
-          {
-            id: 'note-1',
-            content: 'Note for nested entry',
-            timestamp: '2024-01-15T10:30:00Z',
-            author: 'John Doe',
-            entrySlug: 'nested-entry',
-            resolved: false
-          }
-        ];
-
-        await backend.saveNotesFile('.notes/projects/web-development/nested-entry.json', notes);
-
-        expect(window.repoFiles).toEqual({
-          '.notes': {
-            projects: {
-              'web-development': {
-                'nested-entry.json': {
-                  path: '.notes/projects/web-development/nested-entry.json',
-                  content: JSON.stringify(notes, null, 2)
-                }
-              }
-            }
-          }
-        });
-      });
-
-      it('should save empty notes array', async () => {
-        await backend.saveNotesFile('.notes/blog/empty-post.json', []);
-
-        expect(window.repoFiles['.notes']['blog']['empty-post.json'].content).toBe('[]');
-      });
-
-      it('should preserve other files when saving notes', async () => {
-        // Setup existing content
-        window.repoFiles = {
-          posts: {
-            'existing-post.md': {
-              content: 'existing content',
-              path: 'posts/existing-post.md'
-            }
-          },
-          '.notes': {
-            blog: {
-              'other-post.json': {
-                content: '[]',
-                path: '.notes/blog/other-post.json'
-              }
-            }
-          }
-        };
-
-        const notes = [{ id: 'note-1', content: 'New note', timestamp: '2024-01-15T10:30:00Z', author: 'John', entrySlug: 'new-post', resolved: false }];
-        await backend.saveNotesFile('.notes/blog/new-post.json', notes);
-
-        // Should preserve existing content
-        expect(window.repoFiles.posts['existing-post.md']).toBeDefined();
-        expect(window.repoFiles['.notes'].blog['other-post.json']).toBeDefined();
-        expect(window.repoFiles['.notes'].blog['new-post.json']).toBeDefined();
-      });
-    });
-
-    describe('getNotesFile', () => {
-      it('should load existing notes', async () => {
-        const notes = [
-          {
-            id: 'note-1',
-            content: 'Test note content',
-            timestamp: '2024-01-15T10:30:00Z',
-            author: 'John Doe',
-            entrySlug: 'test-post',
-            resolved: false
-          }
-        ];
-
-        // Setup notes in window.repoFiles
-        window.repoFiles = {
-          '.notes': {
-            blog: {
-              'test-post.json': {
-                path: '.notes/blog/test-post.json',
-                content: JSON.stringify(notes)
-              }
-            }
-          }
-        };
-
-        const loadedNotes = await backend.getNotesFile('.notes/blog/test-post.json');
-        expect(loadedNotes).toEqual(notes);
-      });
-
-      it('should return empty array for non-existent notes file', async () => {
-        const loadedNotes = await backend.getNotesFile('.notes/blog/non-existent.json');
-        expect(loadedNotes).toEqual([]);
-      });
-
-      it('should return empty array for empty notes file', async () => {
-        window.repoFiles = {
-          '.notes': {
-            blog: {
-              'empty.json': {
-                path: '.notes/blog/empty.json',
-                content: '[]'
-              }
-            }
-          }
-        };
-
-        const loadedNotes = await backend.getNotesFile('.notes/blog/empty.json');
-        expect(loadedNotes).toEqual([]);
-      });
-
-      it('should handle malformed JSON gracefully', async () => {
-        window.repoFiles = {
-          '.notes': {
-            blog: {
-              'corrupted.json': {
-                path: '.notes/blog/corrupted.json',
-                content: '{ invalid json'
-              }
-            }
-          }
-        };
-
-        const loadedNotes = await backend.getNotesFile('.notes/blog/corrupted.json');
-        expect(loadedNotes).toEqual([]);
-      });
-    });
-
-    describe('notes save and load cycle', () => {
-      it('should save and then load the same notes', async () => {
-        const originalNotes = [
-          {
-            id: 'note-1',
-            content: 'First note',
-            timestamp: '2024-01-15T10:30:00Z',
-            author: 'John Doe',
-            entrySlug: 'test-entry',
-            resolved: false
-          },
-          {
-            id: 'note-2',
-            content: 'Second note with special chars: éñ中文',
-            timestamp: '2024-01-15T11:30:00Z',
-            author: 'Jane Smith',
-            entrySlug: 'test-entry',
-            resolved: true
-          }
-        ];
-
-        // Save notes
-        await backend.saveNotesFile('.notes/blog/test-entry.json', originalNotes);
-
-        // Load notes
-        const loadedNotes = await backend.getNotesFile('.notes/blog/test-entry.json');
-
-        expect(loadedNotes).toEqual(originalNotes);
-      });
-
-      it('should handle multiple collections separately', async () => {
-        const blogNotes = [{ id: 'blog-note', content: 'Blog note', timestamp: '2024-01-15T10:30:00Z', author: 'John', entrySlug: 'blog-post', resolved: false }];
-        const pageNotes = [{ id: 'page-note', content: 'Page note', timestamp: '2024-01-15T11:30:00Z', author: 'Jane', entrySlug: 'about-page', resolved: false }];
-
-        // Save to different collections
-        await backend.saveNotesFile('.notes/blog/my-post.json', blogNotes);
-        await backend.saveNotesFile('.notes/pages/about.json', pageNotes);
-
-        // Load from different collections
-        const loadedBlogNotes = await backend.getNotesFile('.notes/blog/my-post.json');
-        const loadedPageNotes = await backend.getNotesFile('.notes/pages/about.json');
-
-        expect(loadedBlogNotes).toEqual(blogNotes);
-        expect(loadedPageNotes).toEqual(pageNotes);
-      });
-    });
-
-    describe('edge cases', () => {
-      it('should handle notes with complex content', async () => {
-        const complexNotes = [
-          {
-            id: 'complex-note',
-            content: 'Note with "quotes", line\nbreaks, and {json: "like"} content',
-            timestamp: '2024-01-15T10:30:00Z',
-            author: 'Test User',
-            entrySlug: 'complex-entry',
-            resolved: false
-          }
-        ];
-
-        await backend.saveNotesFile('.notes/blog/complex.json', complexNotes);
-        const loadedNotes = await backend.getNotesFile('.notes/blog/complex.json');
-
-        expect(loadedNotes).toEqual(complexNotes);
-      });
-    });
-  })
 });
diff --git a/packages/decap-cms-backend-test/src/implementation.ts b/packages/decap-cms-backend-test/src/implementation.ts
index 6ad1504b3517..1dbbdbddc043 100644
--- a/packages/decap-cms-backend-test/src/implementation.ts
+++ b/packages/decap-cms-backend-test/src/implementation.ts
@@ -409,30 +409,35 @@ export default class TestBackend implements Implementation {
       id: uuid(),
       timestamp: new Date().toISOString(),
     };
-    
+
     if (!window.repoNotes[key]) {
       window.repoNotes[key] = [];
     }
-    
+
     window.repoNotes[key].push(newNote);
     return newNote;
   }
 
-  async updateNote(collection: string, slug: string, noteId: string, updates: Partial<Note>): Promise<Note> {
+  async updateNote(
+    collection: string,
+    slug: string,
+    noteId: string,
+    updates: Partial<Note>,
+  ): Promise<Note> {
     const key = `${collection}/${slug}`;
     const notes = window.repoNotes[key] || [];
     const noteIndex = notes.findIndex(note => note.id === noteId);
-    
+
     if (noteIndex === -1) {
       throw new Error(`Note with id ${noteId} not found`);
     }
-    
+
     const updatedNote = {
       ...notes[noteIndex],
       ...updates,
       updatedAt: new Date().toISOString(),
     };
-    
+
     window.repoNotes[key][noteIndex] = updatedNote;
     return updatedNote;
   }
@@ -441,11 +446,11 @@ export default class TestBackend implements Implementation {
     const key = `${collection}/${slug}`;
     const notes = window.repoNotes[key] || [];
     const noteIndex = notes.findIndex(note => note.id === noteId);
-    
+
     if (noteIndex === -1) {
       throw new Error(`Note with id ${noteId} not found`);
     }
-    
+
     window.repoNotes[key].splice(noteIndex, 1);
   }
 
@@ -453,20 +458,20 @@ export default class TestBackend implements Implementation {
     const key = `${collection}/${slug}`;
     const notes = window.repoNotes[key] || [];
     const note = notes.find(note => note.id === noteId);
-    
+
     if (!note) {
       throw new Error(`Note with id ${noteId} not found`);
     }
-    
+
     const updatedNote = {
       ...note,
       resolved: !note.resolved,
       updatedAt: new Date().toISOString(),
     };
-    
+
     const noteIndex = notes.findIndex(n => n.id === noteId);
     window.repoNotes[key][noteIndex] = updatedNote;
-    
+
     return updatedNote;
   }
 
diff --git a/packages/decap-cms-core/src/actions/entries.ts b/packages/decap-cms-core/src/actions/entries.ts
index 57dcd10d78d5..b0fe82b17691 100644
--- a/packages/decap-cms-core/src/actions/entries.ts
+++ b/packages/decap-cms-core/src/actions/entries.ts
@@ -100,7 +100,6 @@ export const NOTE_DELETE_REQUEST = 'NOTE_DELETE_REQUEST';
 export const NOTE_DELETE_SUCCESS = 'NOTE_DELETE_SUCCESS';
 export const NOTE_DELETE_FAILURE = 'NOTE_DELETE_FAILURE';
 
-
 /*
  * Simple Action Creators (Internal)
  * We still need to export them for tests
@@ -476,10 +475,10 @@ export function removeDraftEntryMediaFile({ id }: { id: string }) {
 }
 
 export function loadNotesForEntry(notes: Note[]) {
-  return { type: DRAFT_NOTES_LOAD, payload: {notes}};
+  return { type: DRAFT_NOTES_LOAD, payload: { notes } };
 }
 
-export function addNote(note: Note) { 
+export function addNote(note: Note) {
   return { type: DRAFT_NOTE_ADD, payload: { note } };
 }
 
@@ -1025,7 +1024,7 @@ export function deleteEntry(collection: Collection, slug: string) {
       });
   };
 }
-  export function notesLoading(collection: Collection, slug: string) {
+export function notesLoading(collection: Collection, slug: string) {
   return {
     type: NOTES_REQUEST,
     payload: {
@@ -1133,10 +1132,10 @@ export function loadNotes(collection: Collection, slug: string) {
       const state = getState();
       const backend = currentBackend(state.config);
       const notes = await backend.getNotes(collection.get('name'), slug);
-      
+
       // Set entrySlug for all notes
       const notesWithSlug = notes.map(note => ({ ...note, entrySlug: slug }));
-      
+
       dispatch(notesLoaded(collection, slug, notesWithSlug));
       dispatch(loadNotesForEntry(notesWithSlug));
     } catch (error) {
@@ -1150,7 +1149,7 @@ export function persistNote(collection: Collection, slug: string, note: Omit<Not
   return async (dispatch: ThunkDispatch<State, {}, AnyAction>, getState: () => State) => {
     const backend = currentBackend(getState().config);
     dispatch(notePersisting(collection, slug, note as Note));
-    
+
     try {
       const savedNote = await backend.addNote(collection.get('name'), slug, note);
       dispatch(notePersisted(collection, slug, savedNote));
@@ -1162,39 +1161,48 @@ export function persistNote(collection: Collection, slug: string, note: Omit<Not
   };
 }
 
-export function updateNotePersist(collection: Collection, slug: string, noteId: string, updates: Partial<Note>) {
+export function updateNotePersist(
+  collection: Collection,
+  slug: string,
+  noteId: string,
+  updates: Partial<Note>,
+) {
   return async (dispatch: ThunkDispatch<State, {}, AnyAction>, getState: () => State) => {
     const state = getState();
     const backend = currentBackend(state.config);
-    
+
     // Create a temporary note object for the persist actions
     const tempNote = { id: noteId, ...updates } as Note;
     dispatch(notePersisting(collection, slug, tempNote));
-    
+
     try {
       const updatedNote = await backend.updateNote(collection.get('name'), slug, noteId, updates);
       dispatch(notePersisted(collection, slug, updatedNote));
       dispatch(updateNote(noteId, updates));
-      
-      dispatch(addNotification({
-        message: {
-          key: 'ui.toast.noteUpdated',
-        },
-        type: 'success',
-        dismissAfter: 4000,
-      }));
-      
+
+      dispatch(
+        addNotification({
+          message: {
+            key: 'ui.toast.noteUpdated',
+          },
+          type: 'success',
+          dismissAfter: 4000,
+        }),
+      );
+
       return updatedNote;
     } catch (error) {
       dispatch(notePersistFail(collection, slug, tempNote, error));
-      dispatch(addNotification({
-        message: {
-          details: error.message,
-          key: 'ui.toast.onFailToUpdateNote',
-        },
-        type: 'error',
-        dismissAfter: 8000,
-      }));
+      dispatch(
+        addNotification({
+          message: {
+            details: error.message,
+            key: 'ui.toast.onFailToUpdateNote',
+          },
+          type: 'error',
+          dismissAfter: 8000,
+        }),
+      );
     }
   };
 }
@@ -1203,31 +1211,35 @@ export function deleteNotePersist(collection: Collection, slug: string, noteId:
   return async (dispatch: ThunkDispatch<State, {}, AnyAction>, getState: () => State) => {
     const state = getState();
     const backend = currentBackend(state.config);
-    
+
     dispatch(noteDeleting(collection, slug, noteId));
-    
+
     try {
       await backend.deleteNote(collection.get('name'), slug, noteId);
       dispatch(noteDeleted(collection, slug, noteId));
       dispatch(deleteNote(noteId));
-      
-      dispatch(addNotification({
-        message: {
-          key: 'ui.toast.noteDeleted',
-        },
-        type: 'success',
-        dismissAfter: 4000,
-      }));
+
+      dispatch(
+        addNotification({
+          message: {
+            key: 'ui.toast.noteDeleted',
+          },
+          type: 'success',
+          dismissAfter: 4000,
+        }),
+      );
     } catch (error) {
       dispatch(noteDeleteFail(collection, slug, noteId, error));
-      dispatch(addNotification({
-        message: {
-          details: error.message,
-          key: 'ui.toast.onFailToDeleteNote',
-        },
-        type: 'error',
-        dismissAfter: 8000,
-      }));
+      dispatch(
+        addNotification({
+          message: {
+            details: error.message,
+            key: 'ui.toast.onFailToDeleteNote',
+          },
+          type: 'error',
+          dismissAfter: 8000,
+        }),
+      );
     }
   };
 }
@@ -1236,35 +1248,39 @@ export function toggleNoteResolutionPersist(collection: Collection, slug: string
   return async (dispatch: ThunkDispatch<State, {}, AnyAction>, getState: () => State) => {
     const state = getState();
     const backend = currentBackend(state.config);
-    
+
     // Create a temporary note object for the persist actions
     const tempNote = { id: noteId } as Note;
     dispatch(notePersisting(collection, slug, tempNote));
-    
+
     try {
       const updatedNote = await backend.toggleNoteResolution(collection.get('name'), slug, noteId);
       dispatch(notePersisted(collection, slug, updatedNote));
       dispatch(updateNote(noteId, { resolved: updatedNote.resolved }));
-      
-      dispatch(addNotification({
-        message: {
-          key: updatedNote.resolved ? 'ui.toast.noteResolved' : 'ui.toast.noteReopened',
-        },
-        type: 'success',
-        dismissAfter: 4000,
-      }));
-      
+
+      dispatch(
+        addNotification({
+          message: {
+            key: updatedNote.resolved ? 'ui.toast.noteResolved' : 'ui.toast.noteReopened',
+          },
+          type: 'success',
+          dismissAfter: 4000,
+        }),
+      );
+
       return updatedNote;
     } catch (error) {
       dispatch(notePersistFail(collection, slug, tempNote, error));
-      dispatch(addNotification({
-        message: {
-          details: error.message,
-          key: 'ui.toast.onFailToToggleNote',
-        },
-        type: 'error',
-        dismissAfter: 8000,
-      }));
+      dispatch(
+        addNotification({
+          message: {
+            details: error.message,
+            key: 'ui.toast.onFailToToggleNote',
+          },
+          type: 'error',
+          dismissAfter: 8000,
+        }),
+      );
     }
   };
 }
diff --git a/packages/decap-cms-core/src/backend.ts b/packages/decap-cms-core/src/backend.ts
index 663f51a9a8ec..806577397480 100644
--- a/packages/decap-cms-core/src/backend.ts
+++ b/packages/decap-cms-core/src/backend.ts
@@ -583,30 +583,11 @@ export class Backend {
     };
   }
 
-    async saveNotesFile(path: string, notes: Note[]) {
-    if (typeof this.implementation.saveNotesFile === 'function') {
-      return this.implementation.saveNotesFile(path, notes)
-    }
-
-    console.log ('Backend unsupported for notes yet');
-
-    }
-
-  async getNotesFile(path: string) {
-    // Check if the implementation supports notes
-    if (typeof this.implementation.getNotesFile === 'function') {
-      return this.implementation.getNotesFile(path);
-    }
-    
-    // Fallback: return empty notes for backends that don't support notes yet
-    console.log('Backend does not support notes persistence yet');
-    return [];
-  }
-    async getNotes(collection: string, slug: string): Promise<Note[]> {
+  async getNotes(collection: string, slug: string): Promise<Note[]> {
     if (typeof this.implementation.getNotes === 'function') {
       return this.implementation.getNotes(collection, slug);
     }
-    
+
     // If backend doesn't support notes, return empty array
     console.warn(`Backend '${this.backendName}' does not support notes`);
     return [];
@@ -616,15 +597,20 @@ export class Backend {
     if (typeof this.implementation.addNote === 'function') {
       return this.implementation.addNote(collection, slug, note);
     }
-    
+
     throw new Error(`Backend '${this.backendName}' does not support adding notes`);
   }
 
-  async updateNote(collection: string, slug: string, noteId: string, updates: Partial<Note>): Promise<Note> {
+  async updateNote(
+    collection: string,
+    slug: string,
+    noteId: string,
+    updates: Partial<Note>,
+  ): Promise<Note> {
     if (typeof this.implementation.updateNote === 'function') {
       return this.implementation.updateNote(collection, slug, noteId, updates);
     }
-    
+
     throw new Error(`Backend '${this.backendName}' does not support updating notes`);
   }
 
@@ -632,7 +618,7 @@ export class Backend {
     if (typeof this.implementation.deleteNote === 'function') {
       return this.implementation.deleteNote(collection, slug, noteId);
     }
-    
+
     throw new Error(`Backend '${this.backendName}' does not support deleting notes`);
   }
 
@@ -640,11 +626,14 @@ export class Backend {
     if (typeof this.implementation.toggleNoteResolution === 'function') {
       return this.implementation.toggleNoteResolution(collection, slug, noteId);
     }
-    
+
     throw new Error(`Backend '${this.backendName}' does not support toggling note resolution`);
   }
 
-  async getPRMetadata(collection: string, slug: string): Promise<{
+  async getPRMetadata(
+    collection: string,
+    slug: string,
+  ): Promise<{
     id: string;
     url: string;
     author: string;
@@ -653,7 +642,7 @@ export class Backend {
     if (typeof this.implementation.getPRMetadata === 'function') {
       return this.implementation.getPRMetadata(collection, slug);
     }
-    
+
     return null;
   }
 
diff --git a/packages/decap-cms-core/src/components/Editor/Editor.js b/packages/decap-cms-core/src/components/Editor/Editor.js
index 7109d463e140..c6fc775b347d 100644
--- a/packages/decap-cms-core/src/components/Editor/Editor.js
+++ b/packages/decap-cms-core/src/components/Editor/Editor.js
@@ -181,23 +181,18 @@ export class Editor extends React.Component {
         this.deleteBackup();
       }
     }
-    if (
-    !prevProps.entry && 
-    this.props.entry && 
-    !this.props.newEntry &&
-    this.props.hasWorkflow
-  ) {
-    this.props.loadNotes(this.props.collection, this.props.slug);
-  }
+    if (!prevProps.entry && this.props.entry && !this.props.newEntry && this.props.hasWorkflow) {
+      this.props.loadNotes(this.props.collection, this.props.slug);
+    }
 
-  if (
-    prevProps.entry !== this.props.entry && 
-    this.props.entry && 
-    !this.props.newEntry &&
-    this.props.hasWorkflow
-  ) {
-    this.props.loadNotes(this.props.collection, this.props.slug);
-  }
+    if (
+      prevProps.entry !== this.props.entry &&
+      this.props.entry &&
+      !this.props.newEntry &&
+      this.props.hasWorkflow
+    ) {
+      this.props.loadNotes(this.props.collection, this.props.slug);
+    }
 
     if (this.props.hasChanged) {
       this.createBackup(this.props.entryDraft.get('entry'), this.props.collection);
@@ -361,8 +356,8 @@ export class Editor extends React.Component {
 
   handleNotesChange = (action, payload) => {
     const { collection, slug } = this.props;
-    
-    switch(action) {
+
+    switch (action) {
       case 'ADD_NOTE':
         this.props.persistNote(collection, slug, payload);
         break;
@@ -373,9 +368,9 @@ export class Editor extends React.Component {
         this.props.deleteNotePersist(collection, slug, payload.id);
         break;
       default:
-        console.log('Unknown notes action:', action, payload)
+        console.log('Unknown notes action:', action, payload);
     }
-  }
+  };
 
   render() {
     const {
@@ -540,7 +535,7 @@ const mapDispatchToProps = {
   loadNotes,
   persistNote,
   updateNotePersist,
-  deleteNotePersist
+  deleteNotePersist,
 };
 
 export default connect(mapStateToProps, mapDispatchToProps)(withWorkflow(translate()(Editor)));
diff --git a/packages/decap-cms-core/src/components/Editor/EditorInterface.js b/packages/decap-cms-core/src/components/Editor/EditorInterface.js
index 0e0a0e217729..06dde5c6f6de 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorInterface.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorInterface.js
@@ -166,13 +166,10 @@ function isPreviewEnabled(collection, entry) {
   return collection.getIn(['editor', 'preview'], true);
 }
 
-function isNotesEnabled(collection, entry, isPublished) {
-// Notes are only enabled on unpublished entries
-
-  if (isPublished) {
+function isNotesEnabled(collection, entry, isNewEntry, isPublished, hasWorkflow) {
+  if (isNewEntry || isPublished || !hasWorkflow) {
     return false;
   }
-  
 
   if (collection.get('type') === FILES) {
     const file = getFileFromSlug(collection, entry.get('slug'));
@@ -219,7 +216,7 @@ class EditorInterface extends Component {
 
   handleTogglePreview = () => {
     const newPreviewVisible = !this.state.previewVisible;
-    this.setState({ 
+    this.setState({
       previewVisible: newPreviewVisible,
       notesVisible: false, // Hide notes when showing preview
     });
@@ -229,7 +226,7 @@ class EditorInterface extends Component {
 
   handleToggleNotes = () => {
     const newNotesVisible = !this.state.notesVisible;
-    this.setState({ 
+    this.setState({
       notesVisible: newNotesVisible,
       previewVisible: false, // Hide preview when showing notes
     });
@@ -238,7 +235,7 @@ class EditorInterface extends Component {
   };
 
   handleNotesChange = (action, payload) => {
-    this.props.onNotesChange(action, payload)
+    this.props.onNotesChange(action, payload);
   };
 
   handleToggleScrollSync = () => {
@@ -294,7 +291,7 @@ class EditorInterface extends Component {
     const { scrollSyncEnabled, showEventBlocker } = this.state;
 
     const previewEnabled = isPreviewEnabled(collection, entry);
-    const notesEnabled = isNotesEnabled(collection, entry, isPublished);
+    const notesEnabled = isNotesEnabled(collection, entry, isNewEntry, isPublished, hasWorkflow);
 
     const { locales, defaultLocale } = getI18nInfo(this.props.collection);
     const collectionI18nEnabled = hasI18n(collection) && locales.length > 1;
@@ -533,4 +530,4 @@ EditorInterface.propTypes = {
   onNotesChange: PropTypes.func,
 };
 
-export default EditorInterface;
\ No newline at end of file
+export default EditorInterface;
diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js
index e59c448e3450..5457be049937 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js
@@ -62,7 +62,7 @@ const AddButton = styled.button`
 
 const CharCount = styled.span`
   font-size: 12px;
-  color: ${props => props.warn ? colors.errorText : colors.controlLabel};
+  color: ${props => (props.warn ? colors.errorText : colors.controlLabel)};
 `;
 
 const Hint = styled.p`
@@ -85,14 +85,14 @@ class AddNoteForm extends Component {
 
   maxLength = 1000;
 
-  handleContentChange = (e) => {
+  handleContentChange = e => {
     const content = e.target.value;
     if (content.length <= this.maxLength) {
       this.setState({ content });
     }
   };
 
-  handleSubmit = (e) => {
+  handleSubmit = e => {
     e.preventDefault();
     const { content } = this.state;
     const trimmedContent = content.trim();
@@ -103,7 +103,7 @@ class AddNoteForm extends Component {
     }
   };
 
-  handleKeyDown = (e) => {
+  handleKeyDown = e => {
     if (e.key === 'Enter' && (e.ctrlKey || e.metaKey)) {
       e.preventDefault();
       this.handleSubmit(e);
@@ -140,23 +140,21 @@ class AddNoteForm extends Component {
             onFocus={this.handleFocus}
             onBlur={this.handleBlur}
             placeholder={t('editor.editorNotesPane.addPlaceholder')}
-            rows='4'
+            rows="4"
           />
-              <FormActions>
-                <CharCount warn={isNearLimit}>
-                  {charCount}/{this.maxLength}
-                </CharCount>
-                <AddButton type="submit" disabled={!canSubmit}>
-                  {t('editor.editorNotesPane.addNote')}
-                </AddButton>
-              </FormActions>
-              <Hint>
-                {t('editor.editorNotesPane.shortcut')}
-              </Hint>
+          <FormActions>
+            <CharCount warn={isNearLimit}>
+              {charCount}/{this.maxLength}
+            </CharCount>
+            <AddButton type="submit" disabled={!canSubmit}>
+              {t('editor.editorNotesPane.addNote')}
+            </AddButton>
+          </FormActions>
+          <Hint>{t('editor.editorNotesPane.shortcut')}</Hint>
         </form>
       </FormContainer>
     );
   }
 }
 
-export default AddNoteForm;
\ No newline at end of file
+export default AddNoteForm;
diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js
index 8829183d168c..86b51155d90d 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js
@@ -86,11 +86,11 @@ class EditorNotesPane extends Component {
     t: key => key, // Fallback translation function
   };
 
-  handleAddNote = (content) => {
+  handleAddNote = content => {
     const { onChange, user } = this.props;
     const newNote = {
       content: content.trim(),
-      author: user?.name || user?.login  || 'Anonymous',
+      author: user?.name || user?.login || 'Anonymous',
       resolved: false,
     };
 
@@ -102,12 +102,12 @@ class EditorNotesPane extends Component {
     onChange('UPDATE_NOTE', { id: noteId, updates });
   };
 
-  handleDeleteNote = (noteId) => {
+  handleDeleteNote = noteId => {
     const { onChange } = this.props;
     onChange('DELETE_NOTE', { id: noteId });
   };
 
-  handleResolveNote = (noteId) => {
+  handleResolveNote = noteId => {
     this.handleUpdateNote(noteId, { resolved: true });
   };
 
@@ -120,13 +120,9 @@ class EditorNotesPane extends Component {
     return (
       <NotesContainer>
         <NotesHeader>
-          <NotesTitle>
-            {t('editor.editorNotesPane.title')}
-          </NotesTitle>
+          <NotesTitle>{t('editor.editorNotesPane.title')}</NotesTitle>
           {notesCount > 0 && (
-            <NotesCount>
-              {unresolvedCount > 0 ? unresolvedCount : notesCount}
-            </NotesCount>
+            <NotesCount>{unresolvedCount > 0 ? unresolvedCount : notesCount}</NotesCount>
           )}
         </NotesHeader>
 
@@ -134,9 +130,7 @@ class EditorNotesPane extends Component {
           {notesCount === 0 ? (
             <EmptyState>
               <EmptyStateIcon>📝</EmptyStateIcon>
-              <EmptyStateText>
-                {t('editor.editorNotesPane.emptyState')}
-              </EmptyStateText>
+              <EmptyStateText>{t('editor.editorNotesPane.emptyState')}</EmptyStateText>
             </EmptyState>
           ) : (
             <NotesList
@@ -148,14 +142,11 @@ class EditorNotesPane extends Component {
             />
           )}
 
-          <AddNoteForm
-            onAdd={this.handleAddNote}
-            t={t}
-          />
+          <AddNoteForm onAdd={this.handleAddNote} t={t} />
         </NotesContent>
       </NotesContainer>
     );
   }
 }
 
-export default EditorNotesPane;
\ No newline at end of file
+export default EditorNotesPane;
diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js
index 5c14480f0975..a62413a948ff 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js
@@ -5,13 +5,13 @@ import styled from '@emotion/styled';
 import { colors, transitions } from 'decap-cms-ui-default';
 
 const NoteCard = styled.div`
-  background-color: ${props => props.resolved ? colors.inputBackground : 'white'};
-  border: 1px solid ${props => props.resolved ? colors.textFieldBorder : colors.textFieldBorder};
+  background-color: ${props => (props.resolved ? colors.inputBackground : 'white')};
+  border: 1px solid ${props => (props.resolved ? colors.textFieldBorder : colors.textFieldBorder)};
   border-radius: 4px;
   margin-bottom: 8px;
   padding: 12px;
   transition: all ${transitions.main};
-  opacity: ${props => props.resolved ? 0.7 : 1};
+  opacity: ${props => (props.resolved ? 0.7 : 1)};
 
   &:hover {
     border-color: ${colors.active};
@@ -86,7 +86,7 @@ const ActionButton = styled.button`
 
   &:hover {
     background-color: ${colors.inputBackground};
-    color: ${props => props.danger ? colors.errorText : colors.active};
+    color: ${props => (props.danger ? colors.errorText : colors.active)};
   }
 
   &:disabled {
@@ -119,7 +119,7 @@ class NoteItem extends Component {
     editContent: '',
   };
 
-  formatTimestamp = (timestamp) => {
+  formatTimestamp = timestamp => {
     const date = new Date(timestamp);
     const now = new Date();
     const diffMs = now - date;
@@ -131,7 +131,7 @@ class NoteItem extends Component {
     if (diffMins < 60) return `${diffMins}m ago`;
     if (diffHours < 24) return `${diffHours}h ago`;
     if (diffDays < 7) return `${diffDays}d ago`;
-    
+
     return date.toLocaleDateString();
   };
 
@@ -164,7 +164,7 @@ class NoteItem extends Component {
     });
   };
 
-  handleEditKeyDown = (e) => {
+  handleEditKeyDown = e => {
     if (e.key === 'Enter' && (e.ctrlKey || e.metaKey)) {
       e.preventDefault();
       this.handleEditSave();
@@ -197,9 +197,7 @@ class NoteItem extends Component {
           <NoteAuthor>{note.get('author')}</NoteAuthor>
           <div style={{ display: 'flex', alignItems: 'center', gap: '8px' }}>
             {resolved && <ResolvedBadge>resolved</ResolvedBadge>}
-            <NoteTimestamp>
-              {this.formatTimestamp(note.get('timestamp'))}
-            </NoteTimestamp>
+            <NoteTimestamp>{this.formatTimestamp(note.get('timestamp'))}</NoteTimestamp>
           </div>
         </NoteHeader>
 
@@ -207,7 +205,7 @@ class NoteItem extends Component {
           {isEditing ? (
             <EditableText
               value={editContent}
-              onChange={(e) => this.setState({ editContent: e.target.value })}
+              onChange={e => this.setState({ editContent: e.target.value })}
               onKeyDown={this.handleEditKeyDown}
               placeholder={t('editor.editorNotesPane.editPlaceholder')}
               autoFocus
@@ -250,4 +248,4 @@ class NoteItem extends Component {
   }
 }
 
-export default NoteItem;
\ No newline at end of file
+export default NoteItem;
diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NotesList.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NotesList.js
index b14e4a0d1bf4..4e22a8772b79 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NotesList.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NotesList.js
@@ -11,17 +11,16 @@ const ListContainer = styled.div`
   padding: 8px;
 `;
 
-function NotesList ({ notes, onUpdate, onDelete, onResolve, t }) {
+function NotesList({ notes, onUpdate, onDelete, onResolve, t }) {
   // Sort notes: unresolved first, then by newest
-  const sortedNotes = notes
-    .sort((a, b) => {
-      // First sort by resolved status (unresolved first)
-      if (a.get('resolved') !== b.get('resolved')) {
-        return a.get('resolved') ? 1 : -1;
-      }
-      // Then sort by timestamp (newest first)
-      return new Date(b.get('timestamp')) - new Date(a.get('timestamp'));
-    });
+  const sortedNotes = notes.sort((a, b) => {
+    // First sort by resolved status (unresolved first)
+    if (a.get('resolved') !== b.get('resolved')) {
+      return a.get('resolved') ? 1 : -1;
+    }
+    // Then sort by timestamp (newest first)
+    return new Date(b.get('timestamp')) - new Date(a.get('timestamp'));
+  });
 
   return (
     <ListContainer>
@@ -37,7 +36,7 @@ function NotesList ({ notes, onUpdate, onDelete, onResolve, t }) {
       ))}
     </ListContainer>
   );
-};
+}
 
 NotesList.propTypes = {
   notes: ImmutablePropTypes.list.isRequired,
@@ -47,4 +46,4 @@ NotesList.propTypes = {
   t: PropTypes.func.isRequired,
 };
 
-export default NotesList;
\ No newline at end of file
+export default NotesList;
diff --git a/packages/decap-cms-core/src/reducers/entryDraft.js b/packages/decap-cms-core/src/reducers/entryDraft.js
index 4e1f594523ea..8493e1939108 100644
--- a/packages/decap-cms-core/src/reducers/entryDraft.js
+++ b/packages/decap-cms-core/src/reducers/entryDraft.js
@@ -210,22 +210,20 @@ function entryDraftReducer(state = Map(), action) {
 
     case DRAFT_NOTES_LOAD:
       return state.set('notes', fromJS(action.payload.notes));
-    
+
     case DRAFT_NOTE_ADD:
       return state.update('notes', notes => notes.push(fromJS(action.payload.note)));
-    
+
     case DRAFT_NOTE_UPDATE:
-      return state.update('notes', notes => 
+      return state.update('notes', notes =>
         notes.map(note =>
-          note.get('id') === action.payload.id
-            ? note.merge(fromJS(action.payload.updates))
-            : note
-        )
-      )
-    
+          note.get('id') === action.payload.id ? note.merge(fromJS(action.payload.updates)) : note,
+        ),
+      );
+
     case DRAFT_NOTE_DELETE:
-      return state.update('notes', notes => 
-        notes.filterNot(note => note.get('id') === action.payload.id)
+      return state.update('notes', notes =>
+        notes.filterNot(note => note.get('id') === action.payload.id),
       );
 
     default:
diff --git a/packages/decap-cms-core/src/types/redux.ts b/packages/decap-cms-core/src/types/redux.ts
index 90308709513d..11ad36e9b634 100644
--- a/packages/decap-cms-core/src/types/redux.ts
+++ b/packages/decap-cms-core/src/types/redux.ts
@@ -294,12 +294,12 @@ export interface CmsCollectionFile {
   public_folder?: string;
 }
 
-export type NoteMap = StaticallyTypedRecord<Note>
+export type NoteMap = StaticallyTypedRecord<Note>;
 
-export type Notes = List<NoteMap>
+export type Notes = List<NoteMap>;
 
 export interface LoadNotesPayload {
-  notes: Note[]
+  notes: Note[];
 }
 
 export interface AddNotePayload {
@@ -308,7 +308,7 @@ export interface AddNotePayload {
 
 export interface UpdateNotePayload {
   id: string;
-  updates: Partial<Note>
+  updates: Partial<Note>;
 }
 
 export interface DeleteNotePayload {
diff --git a/packages/decap-cms-lib-util/src/implementation.ts b/packages/decap-cms-lib-util/src/implementation.ts
index 7e513d4f58f2..ca1c5451202e 100644
--- a/packages/decap-cms-lib-util/src/implementation.ts
+++ b/packages/decap-cms-lib-util/src/implementation.ts
@@ -168,17 +168,22 @@ export interface Implementation {
   persistMedia: (file: AssetProxy, opts: PersistOptions) => Promise<ImplementationMediaFile>;
   deleteFiles: (paths: string[], commitMessage: string) => Promise<void>;
 
-  saveNotesFile?: (path: string, notes: Note[]) => Promise<void>
-  getNotesFile?: (path: string) => Promise<Note[]>;
-
   getNotes?: (collection: string, slug: string) => Promise<Note[]>;
   addNote?: (collection: string, slug: string, note: Omit<Note, 'id'>) => Promise<Note>;
-  updateNote?: (collection: string, slug: string, noteId: string, updates: Partial<Note>) => Promise<Note>;
+  updateNote?: (
+    collection: string,
+    slug: string,
+    noteId: string,
+    updates: Partial<Note>,
+  ) => Promise<Note>;
   deleteNote?: (collection: string, slug: string, noteId: string) => Promise<void>;
   toggleNoteResolution?: (collection: string, slug: string, noteId: string) => Promise<Note>;
   syncNotes?: (collection: string, slug: string, localNotes: Note[]) => Promise<Note[]>;
 
-  getPRMetadata?: (collection: string, slug: string) => Promise<{
+  getPRMetadata?: (
+    collection: string,
+    slug: string,
+  ) => Promise<{
     id: string;
     url: string;
     author: string;
diff --git a/packages/decap-cms-lib-util/src/index.ts b/packages/decap-cms-lib-util/src/index.ts
index 60f248181bc9..a9763b0dc04b 100644
--- a/packages/decap-cms-lib-util/src/index.ts
+++ b/packages/decap-cms-lib-util/src/index.ts
@@ -76,7 +76,7 @@ import type {
   Config as C,
   UnpublishedEntryMediaFile as UEMF,
   DataFile as DF,
-  Note as NT
+  Note as NT,
 } from './implementation';
 import type { AsyncLock as AL } from './asyncLock';
 
diff --git a/packages/decap-cms-locales/src/en/index.js b/packages/decap-cms-locales/src/en/index.js
index f2acbf379d50..02cf35ddeb06 100644
--- a/packages/decap-cms-locales/src/en/index.js
+++ b/packages/decap-cms-locales/src/en/index.js
@@ -295,10 +295,10 @@ const en = {
       onDeleteUnpublishedChanges: 'Unpublished changes deleted',
       noteUpdated: 'Note updated',
       onFailToUpdateNote: 'Failed to update note: %{details}',
-      noteDeleted: 'Note deleted', 
+      noteDeleted: 'Note deleted',
       onFailToDeleteNote: 'Failed to delete note: %{details}',
       noteResolved: 'Note resolved',
-      noteReopened: 'Note reopened', 
+      noteReopened: 'Note reopened',
       onFailToToggleNote: 'Failed to toggle note resolution: %{details}',
       onFailToAuth: '%{details}',
       onLoggedOut: 'You have been logged out, please back up any data and login again',
diff --git a/packages/decap-server/src/middlewares/joi/index.ts b/packages/decap-server/src/middlewares/joi/index.ts
index 1b99cfb68faa..430816bc02b9 100644
--- a/packages/decap-server/src/middlewares/joi/index.ts
+++ b/packages/decap-server/src/middlewares/joi/index.ts
@@ -21,8 +21,6 @@ const allowedActions = [
   'deleteFile',
   'deleteFiles',
   'getDeployPreview',
-  'saveNotesFile',
-  'getNotesFile',
 ];
 
 const requiredString = Joi.string().required();
@@ -224,35 +222,6 @@ export function defaultSchema({ path = requiredString } = {}) {
           })
           .required(),
       },
-      {
-        is: 'saveNotesFile',
-        then: defaultParams
-          .keys({
-            path,
-            notes: Joi.array()
-              .items(
-                Joi.object({
-                  id: requiredString,
-                  content: requiredString,
-                  timestamp: requiredString,
-                  author: requiredString,
-                  entrySlug: requiredString,
-                  resolved: requiredBool,
-                })
-              )
-              .required(),
-          })
-          .required(),
-      },
-
-      {
-        is: 'getNotesFile',
-        then: defaultParams
-          .keys({
-            path,
-          })
-          .required(),
-      },
     ],
     otherwise: Joi.forbidden(),
   });
diff --git a/packages/decap-server/src/middlewares/localFs/index.ts b/packages/decap-server/src/middlewares/localFs/index.ts
index 4233999f6db8..e1c265763d10 100644
--- a/packages/decap-server/src/middlewares/localFs/index.ts
+++ b/packages/decap-server/src/middlewares/localFs/index.ts
@@ -128,39 +128,6 @@ export function localFsMiddleware({ repoPath, logger }: FsOptions) {
           res.json(null);
           break;
         }
-        case 'getNotesFile': {
-          const { path: notesPath } = body.params;
-          try {
-            const { promises: fs } = await import('fs');
-            const fullPath = path.join(repoPath, notesPath);
-            const data = await fs.readFile(fullPath, 'utf8');
-            const notes = JSON.parse(data);
-            res.json({ notes });
-          } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            res.status(404).json({ error: errorMessage });
-          }
-          break;
-        }
-
-        case 'saveNotesFile': {
-          const { path: notesPath, notes } = body.params;
-          try {
-            const { promises: fs } = await import('fs');
-            const fullPath = path.join(repoPath, notesPath);
-            const dir = path.dirname(fullPath);
-            
-            await fs.mkdir(dir, { recursive: true });
-            
-            await fs.writeFile(fullPath, JSON.stringify(notes, null, 2));
-
-            res.json({ success: true });
-          } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            res.status(500).json({ error: errorMessage });
-          }
-          break;
-        }
         default: {
           const message = `Unknown action ${body.action}`;
           res.status(422).json({ error: message });
diff --git a/packages/decap-server/src/middlewares/localGit/index.ts b/packages/decap-server/src/middlewares/localGit/index.ts
index 24e2240d69b3..a8765223ef1a 100644
--- a/packages/decap-server/src/middlewares/localGit/index.ts
+++ b/packages/decap-server/src/middlewares/localGit/index.ts
@@ -430,36 +430,6 @@ export function localGitMiddleware({ repoPath, logger }: GitOptions) {
           res.json(null);
           break;
         }
-        case 'getNotesFile': {
-          const { path: notesPath } = body.params;
-          try {
-            const fullPath = path.join(repoPath, notesPath);
-            const data = await fs.readFile(fullPath, 'utf8');
-            const notes = JSON.parse(data);
-            res.json({ notes });
-          } catch (error) {
-            res.json({ notes: [] });
-          }
-          break;
-        }
-
-        case 'saveNotesFile': {
-          const { path: notesPath, notes } = body.params;
-          try {
-            const fullPath = path.join(repoPath, notesPath);
-            const dir = path.dirname(fullPath);
-
-            await fs.mkdir(dir, { recursive: true });
-
-            await fs.writeFile(fullPath, JSON.stringify(notes, null, 2));
-            
-            res.json({ success: true });
-          } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            res.status(500).json({ error: errorMessage });
-          }
-          break;
-        }
         default: {
           const message = `Unknown action ${body.action}`;
           res.status(422).json({ error: message });

From c97975d3b1b6b6c6caa65729ee1b1f6e681cf35d Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Mon, 28 Jul 2025 14:17:28 +0100
Subject: [PATCH 09/40] feat: notes can be unresolved

---
 .../Editor/EditorNotesPane/EditorNotesPane.js | 11 +++++---
 .../Editor/EditorNotesPane/NoteItem.js        | 26 +++++++++----------
 .../Editor/EditorNotesPane/NotesList.js       |  6 ++---
 packages/decap-cms-locales/src/en/index.js    |  1 +
 4 files changed, 25 insertions(+), 19 deletions(-)

diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js
index 86b51155d90d..b1ed210b07c0 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js
@@ -107,8 +107,13 @@ class EditorNotesPane extends Component {
     onChange('DELETE_NOTE', { id: noteId });
   };
 
-  handleResolveNote = noteId => {
-    this.handleUpdateNote(noteId, { resolved: true });
+  handleToggleNoteResolution = noteId => {
+    const { notes } = this.props;
+    const notesList = notes && notes.size !== undefined ? notes : List(notes || []);
+    const note = notesList.find(n => n.get('id') === noteId);
+    const currentResolved = note ? note.get('resolved') : false;
+    
+    this.handleUpdateNote(noteId, { resolved: !currentResolved });
   };
 
   render() {
@@ -137,7 +142,7 @@ class EditorNotesPane extends Component {
               notes={notesList}
               onUpdate={this.handleUpdateNote}
               onDelete={this.handleDeleteNote}
-              onResolve={this.handleResolveNote}
+              onToggleResolution={this.handleToggleNoteResolution}
               t={t}
             />
           )}
diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js
index a62413a948ff..ec9adcdccc22 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js
@@ -110,7 +110,7 @@ class NoteItem extends Component {
     note: ImmutablePropTypes.map.isRequired,
     onUpdate: PropTypes.func.isRequired,
     onDelete: PropTypes.func.isRequired,
-    onResolve: PropTypes.func.isRequired,
+    onToggleResolution: PropTypes.func.isRequired,
     t: PropTypes.func.isRequired,
   };
 
@@ -181,11 +181,10 @@ class NoteItem extends Component {
     }
   };
 
-  handleResolve = () => {
-    const { note, onResolve } = this.props;
-    onResolve(note.get('id'));
+  handleToggleResolution = () => {
+    const { note, onToggleResolution } = this.props;
+    onToggleResolution(note.get('id'));
   };
-
   render() {
     const { note, t } = this.props;
     const { isEditing, editContent } = this.state;
@@ -228,15 +227,16 @@ class NoteItem extends Component {
           ) : (
             <>
               {!resolved && (
-                <>
-                  <ActionButton onClick={this.handleEditStart}>
-                    {t('editor.editorNotesPane.edit')}
-                  </ActionButton>
-                  <ActionButton onClick={this.handleResolve}>
-                    {t('editor.editorNotesPane.resolve')}
-                  </ActionButton>
-                </>
+                <ActionButton onClick={this.handleEditStart}>
+                  {t('editor.editorNotesPane.edit')}
+                </ActionButton>
               )}
+              <ActionButton onClick={this.handleToggleResolution}>
+                {resolved 
+                  ? t('editor.editorNotesPane.unresolve') 
+                  : t('editor.editorNotesPane.resolve')
+                }
+              </ActionButton>
               <ActionButton onClick={this.handleDelete} danger>
                 {t('editor.editorNotesPane.delete')}
               </ActionButton>
diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NotesList.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NotesList.js
index 4e22a8772b79..4e6a4cebee6e 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NotesList.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NotesList.js
@@ -11,7 +11,7 @@ const ListContainer = styled.div`
   padding: 8px;
 `;
 
-function NotesList({ notes, onUpdate, onDelete, onResolve, t }) {
+function NotesList({ notes, onUpdate, onDelete, onToggleResolution, t }) {
   // Sort notes: unresolved first, then by newest
   const sortedNotes = notes.sort((a, b) => {
     // First sort by resolved status (unresolved first)
@@ -30,7 +30,7 @@ function NotesList({ notes, onUpdate, onDelete, onResolve, t }) {
           note={note}
           onUpdate={onUpdate}
           onDelete={onDelete}
-          onResolve={onResolve}
+          onToggleResolution={onToggleResolution}
           t={t}
         />
       ))}
@@ -42,7 +42,7 @@ NotesList.propTypes = {
   notes: ImmutablePropTypes.list.isRequired,
   onUpdate: PropTypes.func.isRequired,
   onDelete: PropTypes.func.isRequired,
-  onResolve: PropTypes.func.isRequired,
+  onToggleResolution: PropTypes.func.isRequired, 
   t: PropTypes.func.isRequired,
 };
 
diff --git a/packages/decap-cms-locales/src/en/index.js b/packages/decap-cms-locales/src/en/index.js
index 02cf35ddeb06..2999c916bbcd 100644
--- a/packages/decap-cms-locales/src/en/index.js
+++ b/packages/decap-cms-locales/src/en/index.js
@@ -132,6 +132,7 @@ const en = {
       edit: 'Edit',
       delete: 'Delete',
       resolve: 'Resolve',
+      unresolve: 'Unresolve',
       confirmDelete: 'Are you sure you want to delete this note?',
       shortcut: 'Tip: Press Ctrl+Enter to add note quickly',
     },

From eb9e5c6bacbc82aa032c39d7fd1aba6b2a501cde Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Mon, 28 Jul 2025 14:29:45 +0100
Subject: [PATCH 10/40] fix: removing char limit on notes

---
 .../Editor/EditorNotesPane/AddNoteForm.js        | 16 +---------------
 1 file changed, 1 insertion(+), 15 deletions(-)

diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js
index 5457be049937..ef09c5d52de6 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js
@@ -60,11 +60,6 @@ const AddButton = styled.button`
   }
 `;
 
-const CharCount = styled.span`
-  font-size: 12px;
-  color: ${props => (props.warn ? colors.errorText : colors.controlLabel)};
-`;
-
 const Hint = styled.p`
   font-size: 12px;
   color: ${colors.controlLabel};
@@ -83,13 +78,9 @@ class AddNoteForm extends Component {
     isFocused: false,
   };
 
-  maxLength = 1000;
-
   handleContentChange = e => {
     const content = e.target.value;
-    if (content.length <= this.maxLength) {
-      this.setState({ content });
-    }
+    this.setState({ content });
   };
 
   handleSubmit = e => {
@@ -126,9 +117,7 @@ class AddNoteForm extends Component {
   render() {
     const { t } = this.props;
     const { content } = this.state;
-    const charCount = content.length;
     const canSubmit = content.trim().length > 0;
-    const isNearLimit = charCount > this.maxLength * 0.8;
 
     return (
       <FormContainer>
@@ -143,9 +132,6 @@ class AddNoteForm extends Component {
             rows="4"
           />
           <FormActions>
-            <CharCount warn={isNearLimit}>
-              {charCount}/{this.maxLength}
-            </CharCount>
             <AddButton type="submit" disabled={!canSubmit}>
               {t('editor.editorNotesPane.addNote')}
             </AddButton>

From 039e84daa6ba3ef32677e855eec33cad106e7b89 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Mon, 28 Jul 2025 18:01:51 +0100
Subject: [PATCH 11/40] feat: avatar now visible in notes

---
 packages/decap-cms-backend-github/src/API.ts  |  1 +
 .../Editor/EditorNotesPane/NoteItem.js        | 68 +++++++++++++++++--
 .../decap-cms-lib-util/src/implementation.ts  |  1 +
 3 files changed, 64 insertions(+), 6 deletions(-)

diff --git a/packages/decap-cms-backend-github/src/API.ts b/packages/decap-cms-backend-github/src/API.ts
index f00cde6104f2..f2a39b68b752 100644
--- a/packages/decap-cms-backend-github/src/API.ts
+++ b/packages/decap-cms-backend-github/src/API.ts
@@ -1520,6 +1520,7 @@ ${note.content}`;
     return {
       id: comment.id.toString(),
       author: comment.user.login,
+      avatarUrl: comment.user.avatar_url,
       timestamp: comment.created_at,
       content,
       resolved,
diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js
index ec9adcdccc22..7af9b5cab47d 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js
@@ -32,6 +32,37 @@ const NoteAuthor = styled.span`
   font-weight: 500;
 `;
 
+const AuthorSection = styled.div`
+  display: flex;
+  align-items: center;
+  gap: 8px;
+`;
+
+const Avatar = styled.div`
+  width: 24px;
+  height: 24px;
+  border-radius: 50%;
+  overflow: hidden;
+  background-color: ${colors.inputBackground};
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  flex-shrink: 0;
+`;
+
+const AvatarImage = styled.img`
+  width: 100%;
+  height: 100%;
+  object-fit: cover;
+`;
+
+const AvatarInitials = styled.span`
+  font-size: 10px;
+  font-weight: 600;
+  color: ${colors.controlLabel};
+  text-transform: uppercase;
+`;
+
 const NoteTimestamp = styled.span`
   font-size: 11px;
   color: ${colors.controlLabel};
@@ -119,6 +150,14 @@ class NoteItem extends Component {
     editContent: '',
   };
 
+  getAuthorInitials = (author) => {
+    return author
+      .split(' ')
+      .map(name => name.charAt(0))
+      .join('')
+      .slice(0, 2);
+  };
+
   formatTimestamp = timestamp => {
     const date = new Date(timestamp);
     const now = new Date();
@@ -192,13 +231,30 @@ class NoteItem extends Component {
 
     return (
       <NoteCard resolved={resolved}>
-        <NoteHeader>
+      <NoteHeader>
+        <AuthorSection>
+          <Avatar>
+            {note.get('avatarUrl') ? (
+              <AvatarImage 
+                src={note.get('avatarUrl')} 
+                alt={`${note.get('author')} avatar`}
+                onError={(e) => {
+                  e.target.style.display = 'none';
+                  e.target.nextSibling.style.display = 'flex';
+                }}
+              />
+            ) : null}
+            <AvatarInitials style={{ display: note.get('avatarUrl') ? 'none' : 'flex' }}>
+              {this.getAuthorInitials(note.get('author'))}
+            </AvatarInitials>
+          </Avatar>
           <NoteAuthor>{note.get('author')}</NoteAuthor>
-          <div style={{ display: 'flex', alignItems: 'center', gap: '8px' }}>
-            {resolved && <ResolvedBadge>resolved</ResolvedBadge>}
-            <NoteTimestamp>{this.formatTimestamp(note.get('timestamp'))}</NoteTimestamp>
-          </div>
-        </NoteHeader>
+        </AuthorSection>
+        <div style={{ display: 'flex', alignItems: 'center', gap: '8px' }}>
+          {resolved && <ResolvedBadge>resolved</ResolvedBadge>}
+          <NoteTimestamp>{this.formatTimestamp(note.get('timestamp'))}</NoteTimestamp>
+        </div>
+      </NoteHeader>
 
         <NoteContent>
           {isEditing ? (
diff --git a/packages/decap-cms-lib-util/src/implementation.ts b/packages/decap-cms-lib-util/src/implementation.ts
index ca1c5451202e..ed76e379fdc5 100644
--- a/packages/decap-cms-lib-util/src/implementation.ts
+++ b/packages/decap-cms-lib-util/src/implementation.ts
@@ -65,6 +65,7 @@ export type DataFile = {
 
 export interface Note {
   id: string;
+  avatarUrl?: string;
   content: string;
   timestamp: string;
   author: string;

From 7117c47fd9a7cc4cb7255fd9f886c29427c5696e Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Mon, 28 Jul 2025 18:25:05 +0100
Subject: [PATCH 12/40] fix: now getting author and avatar immediately on note
 creation + notification added

---
 .../src/implementation.tsx                    |  4 ++++
 .../decap-cms-core/src/actions/entries.ts     | 20 ++++++++++++++++++-
 packages/decap-cms-locales/src/en/index.js    |  1 +
 3 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/packages/decap-cms-backend-github/src/implementation.tsx b/packages/decap-cms-backend-github/src/implementation.tsx
index 6d040f1b428b..6df577094e3c 100644
--- a/packages/decap-cms-backend-github/src/implementation.tsx
+++ b/packages/decap-cms-backend-github/src/implementation.tsx
@@ -765,9 +765,13 @@ export default class GitHub implements Implementation {
       throw new Error('Cannot add notes to draft entries. Please submit for review first.');
     }
 
+    const currentUser = await this.currentUser({ token: this.token! });
+
     const note: Note = {
       ...noteData,
       id: 'temp-' + Date.now(),
+      author: currentUser.login || currentUser.name,
+      avatarUrl: currentUser.avatar_url,
       entrySlug: slug,
       timestamp: noteData.timestamp || new Date().toISOString(),
       resolved: noteData.resolved || false,
diff --git a/packages/decap-cms-core/src/actions/entries.ts b/packages/decap-cms-core/src/actions/entries.ts
index b0fe82b17691..5f8ebddfc761 100644
--- a/packages/decap-cms-core/src/actions/entries.ts
+++ b/packages/decap-cms-core/src/actions/entries.ts
@@ -1149,14 +1149,32 @@ export function persistNote(collection: Collection, slug: string, note: Omit<Not
   return async (dispatch: ThunkDispatch<State, {}, AnyAction>, getState: () => State) => {
     const backend = currentBackend(getState().config);
     dispatch(notePersisting(collection, slug, note as Note));
-
     try {
       const savedNote = await backend.addNote(collection.get('name'), slug, note);
       dispatch(notePersisted(collection, slug, savedNote));
       dispatch(addNote(savedNote));
+      dispatch(
+        addNotification({
+          message: {
+            key: 'ui.toast.noteAdded',
+          },
+          type: 'success',
+          dismissAfter: 4000,
+        }),
+      );
       return savedNote;
     } catch (error) {
       dispatch(notePersistFail(collection, slug, note as Note, error));
+      dispatch(
+        addNotification({
+          message: {
+            details: error.message,
+            key: 'ui.toast.onFailToAddNote',
+          },
+          type: 'error',
+          dismissAfter: 8000,
+        }),
+      );
     }
   };
 }
diff --git a/packages/decap-cms-locales/src/en/index.js b/packages/decap-cms-locales/src/en/index.js
index 2999c916bbcd..84e0078c9355 100644
--- a/packages/decap-cms-locales/src/en/index.js
+++ b/packages/decap-cms-locales/src/en/index.js
@@ -294,6 +294,7 @@ const en = {
       onFailToUnpublishEntry: 'Failed to unpublish entry: %{details}',
       entryUpdated: 'Entry status updated',
       onDeleteUnpublishedChanges: 'Unpublished changes deleted',
+      noteAdded: 'Note added',
       noteUpdated: 'Note updated',
       onFailToUpdateNote: 'Failed to update note: %{details}',
       noteDeleted: 'Note deleted',

From e2f38db315ae0ef093ae591eb8a17aa0c6623cf4 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Mon, 28 Jul 2025 18:57:16 +0100
Subject: [PATCH 13/40] feat: you can only edit or delete your own notes

---
 .../Editor/EditorNotesPane/EditorNotesPane.js |  4 +++-
 .../Editor/EditorNotesPane/NoteItem.js        | 23 ++++++++++++++++---
 .../Editor/EditorNotesPane/NotesList.js       |  4 +++-
 3 files changed, 26 insertions(+), 5 deletions(-)

diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js
index b1ed210b07c0..5f7af127936f 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js
@@ -78,6 +78,7 @@ class EditorNotesPane extends Component {
     onChange: PropTypes.func.isRequired,
     entry: ImmutablePropTypes.map.isRequired,
     collection: ImmutablePropTypes.map.isRequired,
+    user: PropTypes.object,
     t: PropTypes.func,
   };
 
@@ -90,7 +91,7 @@ class EditorNotesPane extends Component {
     const { onChange, user } = this.props;
     const newNote = {
       content: content.trim(),
-      author: user?.name || user?.login || 'Anonymous',
+      author: user?.login || user?.name || 'Anonymous',
       resolved: false,
     };
 
@@ -143,6 +144,7 @@ class EditorNotesPane extends Component {
               onUpdate={this.handleUpdateNote}
               onDelete={this.handleDeleteNote}
               onToggleResolution={this.handleToggleNoteResolution}
+              user={this.props.user}
               t={t}
             />
           )}
diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js
index 7af9b5cab47d..de8e4194d1fa 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js
@@ -142,6 +142,7 @@ class NoteItem extends Component {
     onUpdate: PropTypes.func.isRequired,
     onDelete: PropTypes.func.isRequired,
     onToggleResolution: PropTypes.func.isRequired,
+    user: PropTypes.object,
     t: PropTypes.func.isRequired,
   };
 
@@ -150,6 +151,12 @@ class NoteItem extends Component {
     editContent: '',
   };
 
+  isCurrentUserAuthor = () => {
+    const { note, user } = this.props;
+    const currentUserName = user?.login || user?.name || 'Anonymous';
+    return note.get('author') === currentUserName;
+  };
+
   getAuthorInitials = (author) => {
     return author
       .split(' ')
@@ -283,17 +290,27 @@ class NoteItem extends Component {
           ) : (
             <>
               {!resolved && (
-                <ActionButton onClick={this.handleEditStart}>
+                <ActionButton 
+                  onClick={this.handleEditStart}
+                  disabled={!this.isCurrentUserAuthor()}
+                >
                   {t('editor.editorNotesPane.edit')}
                 </ActionButton>
               )}
-              <ActionButton onClick={this.handleToggleResolution}>
+              <ActionButton 
+                onClick={this.handleToggleResolution}
+                disabled={!this.isCurrentUserAuthor()}
+              >
                 {resolved 
                   ? t('editor.editorNotesPane.unresolve') 
                   : t('editor.editorNotesPane.resolve')
                 }
               </ActionButton>
-              <ActionButton onClick={this.handleDelete} danger>
+              <ActionButton 
+                onClick={this.handleDelete} 
+                danger
+                disabled={!this.isCurrentUserAuthor()}
+              >
                 {t('editor.editorNotesPane.delete')}
               </ActionButton>
             </>
diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NotesList.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NotesList.js
index 4e6a4cebee6e..8557fa3484f9 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NotesList.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NotesList.js
@@ -11,7 +11,7 @@ const ListContainer = styled.div`
   padding: 8px;
 `;
 
-function NotesList({ notes, onUpdate, onDelete, onToggleResolution, t }) {
+function NotesList({ notes, onUpdate, onDelete, onToggleResolution, user, t }) {
   // Sort notes: unresolved first, then by newest
   const sortedNotes = notes.sort((a, b) => {
     // First sort by resolved status (unresolved first)
@@ -31,6 +31,7 @@ function NotesList({ notes, onUpdate, onDelete, onToggleResolution, t }) {
           onUpdate={onUpdate}
           onDelete={onDelete}
           onToggleResolution={onToggleResolution}
+          user={user}
           t={t}
         />
       ))}
@@ -43,6 +44,7 @@ NotesList.propTypes = {
   onUpdate: PropTypes.func.isRequired,
   onDelete: PropTypes.func.isRequired,
   onToggleResolution: PropTypes.func.isRequired, 
+  user: PropTypes.object,
   t: PropTypes.func.isRequired,
 };
 

From d07a7bff5717847056ca390b9e5f17ab171384e6 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Mon, 28 Jul 2025 19:51:46 +0100
Subject: [PATCH 14/40] chore: adding error handling for API calls and fixing
 colours in NoteForm

---
 packages/decap-cms-backend-github/src/API.ts  | 63 +++++++++++++------
 .../Editor/EditorNotesPane/AddNoteForm.js     |  8 +--
 2 files changed, 47 insertions(+), 24 deletions(-)

diff --git a/packages/decap-cms-backend-github/src/API.ts b/packages/decap-cms-backend-github/src/API.ts
index f2a39b68b752..0fde8d4fcfc4 100644
--- a/packages/decap-cms-backend-github/src/API.ts
+++ b/packages/decap-cms-backend-github/src/API.ts
@@ -1512,11 +1512,19 @@ ${note.content}`;
    * Parse a GitHub comment into a Note object
    */
   private parseCommentToNote(comment: GitHubIssueComment): 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,
@@ -1533,33 +1541,48 @@ ${note.content}`;
     return comments.map(comment => this.parseCommentToNote(comment));
   }
 
-  async createPRComment(prNumber: string | number, note: Note): Promise<string> {
-    const response: GitHubIssueComment = await this.request(
-      `${this.originRepoURL}/issues/${prNumber}/comments`,
-      {
-        method: 'POST',
-        body: JSON.stringify({
-          body: this.formatNoteForPR(note),
-        }),
-      },
-    );
+async createPRComment(prNumber: string | number, note: Note): Promise<string> {
+    try {
+      const response: GitHubIssueComment = await this.request(
+        `${this.originRepoURL}/issues/${prNumber}/comments`,
+        {
+          method: 'POST',
+          body: JSON.stringify({
+            body: this.formatNoteForPR(note),
+          }),
+        },
+      );
 
-    return response.id.toString();
+      return response.id.toString();
+    } catch (error) {
+      console.error('Failed to create PR comment:', error);
+      throw new APIError('Failed to create note', error.status || 500, API_NAME);
+    }
   }
 
   async updatePRComment(commentId: string | number, note: Note): Promise<void> {
-    await this.request(`${this.originRepoURL}/issues/comments/${commentId}`, {
-      method: 'PATCH',
-      body: JSON.stringify({
-        body: this.formatNoteForPR(note),
-      }),
-    });
+    try {
+      await this.request(`${this.originRepoURL}/issues/comments/${commentId}`, {
+        method: 'PATCH',
+        body: JSON.stringify({
+          body: this.formatNoteForPR(note),
+        }),
+      });
+    } catch (error) {
+      console.error('Failed to update PR comment:', error);
+      throw new APIError('Failed to update note', error.status || 500, API_NAME);
+    }
   }
 
   async deletePRComment(commentId: string | number): Promise<void> {
-    await this.request(`${this.originRepoURL}/issues/comments/${commentId}`, {
-      method: 'DELETE',
-    });
+    try {
+      await this.request(`${this.originRepoURL}/issues/comments/${commentId}`, {
+        method: 'DELETE',
+      });
+    } catch (error) {
+      console.error('Failed to delete PR comment:', error);
+      throw new APIError('Failed to delete note', error.status || 500, API_NAME);
+    }
   }
 
   /**
diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js
index ef09c5d52de6..7b0c3e1c47f7 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js
@@ -24,7 +24,7 @@ const TextArea = styled.textarea`
 
   &:focus {
     border-color: ${colors.active};
-    box-shadow: 0 0 0 2px rgba(70, 151, 218, 0.1);
+    box-shadow: 0 0 0 2px ${colors.activeBackground};
   }
 
   &::placeholder {
@@ -41,7 +41,7 @@ const FormActions = styled.div`
 
 const AddButton = styled.button`
   background-color: ${colors.active};
-  color: white;
+  color: ${colors.textLight};
   border: none;
   padding: 8px 16px;
   border-radius: 4px;
@@ -51,7 +51,7 @@ const AddButton = styled.button`
   transition: all ${transitions.main};
 
   &:hover:not(:disabled) {
-    background-color: ${colors.activeAccent};
+    background-color: ${colors.statusReadyText};
   }
 
   &:disabled {
@@ -143,4 +143,4 @@ class AddNoteForm extends Component {
   }
 }
 
-export default AddNoteForm;
+export default AddNoteForm;
\ No newline at end of file

From 9048235799a1c086a2d47641ff538ae29107ec82 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Mon, 28 Jul 2025 21:42:29 +0100
Subject: [PATCH 15/40] fix: passing tests

---
 packages/decap-cms-backend-github/src/API.ts  |  2 +-
 .../Editor/EditorNotesPane/AddNoteForm.js     |  2 +-
 .../Editor/EditorNotesPane/EditorNotesPane.js |  2 +-
 .../Editor/EditorNotesPane/NoteItem.js        | 68 +++++++++----------
 .../Editor/EditorNotesPane/NotesList.js       |  2 +-
 5 files changed, 36 insertions(+), 40 deletions(-)

diff --git a/packages/decap-cms-backend-github/src/API.ts b/packages/decap-cms-backend-github/src/API.ts
index 0fde8d4fcfc4..47fce3488d24 100644
--- a/packages/decap-cms-backend-github/src/API.ts
+++ b/packages/decap-cms-backend-github/src/API.ts
@@ -1541,7 +1541,7 @@ ${note.content}`;
     return comments.map(comment => this.parseCommentToNote(comment));
   }
 
-async createPRComment(prNumber: string | number, note: Note): Promise<string> {
+  async createPRComment(prNumber: string | number, note: Note): Promise<string> {
     try {
       const response: GitHubIssueComment = await this.request(
         `${this.originRepoURL}/issues/${prNumber}/comments`,
diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js
index 7b0c3e1c47f7..2618bd7d10f4 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js
@@ -143,4 +143,4 @@ class AddNoteForm extends Component {
   }
 }
 
-export default AddNoteForm;
\ No newline at end of file
+export default AddNoteForm;
diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js
index 5f7af127936f..69dc967b20ff 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js
@@ -113,7 +113,7 @@ class EditorNotesPane extends Component {
     const notesList = notes && notes.size !== undefined ? notes : List(notes || []);
     const note = notesList.find(n => n.get('id') === noteId);
     const currentResolved = note ? note.get('resolved') : false;
-    
+
     this.handleUpdateNote(noteId, { resolved: !currentResolved });
   };
 
diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js
index de8e4194d1fa..3991fb9be341 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js
@@ -157,7 +157,7 @@ class NoteItem extends Component {
     return note.get('author') === currentUserName;
   };
 
-  getAuthorInitials = (author) => {
+  getAuthorInitials = author => {
     return author
       .split(' ')
       .map(name => name.charAt(0))
@@ -238,30 +238,30 @@ class NoteItem extends Component {
 
     return (
       <NoteCard resolved={resolved}>
-      <NoteHeader>
-        <AuthorSection>
-          <Avatar>
-            {note.get('avatarUrl') ? (
-              <AvatarImage 
-                src={note.get('avatarUrl')} 
-                alt={`${note.get('author')} avatar`}
-                onError={(e) => {
-                  e.target.style.display = 'none';
-                  e.target.nextSibling.style.display = 'flex';
-                }}
-              />
-            ) : null}
-            <AvatarInitials style={{ display: note.get('avatarUrl') ? 'none' : 'flex' }}>
-              {this.getAuthorInitials(note.get('author'))}
-            </AvatarInitials>
-          </Avatar>
-          <NoteAuthor>{note.get('author')}</NoteAuthor>
-        </AuthorSection>
-        <div style={{ display: 'flex', alignItems: 'center', gap: '8px' }}>
-          {resolved && <ResolvedBadge>resolved</ResolvedBadge>}
-          <NoteTimestamp>{this.formatTimestamp(note.get('timestamp'))}</NoteTimestamp>
-        </div>
-      </NoteHeader>
+        <NoteHeader>
+          <AuthorSection>
+            <Avatar>
+              {note.get('avatarUrl') ? (
+                <AvatarImage
+                  src={note.get('avatarUrl')}
+                  alt={`${note.get('author')} avatar`}
+                  onError={e => {
+                    e.target.style.display = 'none';
+                    e.target.nextSibling.style.display = 'flex';
+                  }}
+                />
+              ) : null}
+              <AvatarInitials style={{ display: note.get('avatarUrl') ? 'none' : 'flex' }}>
+                {this.getAuthorInitials(note.get('author'))}
+              </AvatarInitials>
+            </Avatar>
+            <NoteAuthor>{note.get('author')}</NoteAuthor>
+          </AuthorSection>
+          <div style={{ display: 'flex', alignItems: 'center', gap: '8px' }}>
+            {resolved && <ResolvedBadge>resolved</ResolvedBadge>}
+            <NoteTimestamp>{this.formatTimestamp(note.get('timestamp'))}</NoteTimestamp>
+          </div>
+        </NoteHeader>
 
         <NoteContent>
           {isEditing ? (
@@ -290,24 +290,20 @@ class NoteItem extends Component {
           ) : (
             <>
               {!resolved && (
-                <ActionButton 
-                  onClick={this.handleEditStart}
-                  disabled={!this.isCurrentUserAuthor()}
-                >
+                <ActionButton onClick={this.handleEditStart} disabled={!this.isCurrentUserAuthor()}>
                   {t('editor.editorNotesPane.edit')}
                 </ActionButton>
               )}
-              <ActionButton 
+              <ActionButton
                 onClick={this.handleToggleResolution}
                 disabled={!this.isCurrentUserAuthor()}
               >
-                {resolved 
-                  ? t('editor.editorNotesPane.unresolve') 
-                  : t('editor.editorNotesPane.resolve')
-                }
+                {resolved
+                  ? t('editor.editorNotesPane.unresolve')
+                  : t('editor.editorNotesPane.resolve')}
               </ActionButton>
-              <ActionButton 
-                onClick={this.handleDelete} 
+              <ActionButton
+                onClick={this.handleDelete}
                 danger
                 disabled={!this.isCurrentUserAuthor()}
               >
diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NotesList.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NotesList.js
index 8557fa3484f9..15cfaf2daab0 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NotesList.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NotesList.js
@@ -43,7 +43,7 @@ NotesList.propTypes = {
   notes: ImmutablePropTypes.list.isRequired,
   onUpdate: PropTypes.func.isRequired,
   onDelete: PropTypes.func.isRequired,
-  onToggleResolution: PropTypes.func.isRequired, 
+  onToggleResolution: PropTypes.func.isRequired,
   user: PropTypes.object,
   t: PropTypes.func.isRequired,
 };

From 5a4c192dde0def6c8bfd950aaa692346c9095b8b Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Mon, 28 Jul 2025 21:43:01 +0100
Subject: [PATCH 16/40] fix: automated test account for Notes

---
 .../__tests__/editorialWorkflow.spec.js       | 27 +++++++++++++++++--
 .../decap-cms-core/src/actions/entries.ts     |  2 +-
 .../src/reducers/__tests__/entryDraft.spec.js |  9 ++++++-
 3 files changed, 34 insertions(+), 4 deletions(-)

diff --git a/packages/decap-cms-core/src/actions/__tests__/editorialWorkflow.spec.js b/packages/decap-cms-core/src/actions/__tests__/editorialWorkflow.spec.js
index f03069a4907c..b90a4982ed17 100644
--- a/packages/decap-cms-core/src/actions/__tests__/editorialWorkflow.spec.js
+++ b/packages/decap-cms-core/src/actions/__tests__/editorialWorkflow.spec.js
@@ -79,7 +79,7 @@ describe('editorialWorkflow actions', () => {
   });
 
   describe('publishUnpublishedEntry', () => {
-    it('should publish unpublished entry and report success', () => {
+    it('should publish unpublished entry and report success', async () => {
       const { currentBackend } = require('../../backend');
 
       const entry = {};
@@ -87,6 +87,7 @@ describe('editorialWorkflow actions', () => {
         publishUnpublishedEntry: jest.fn().mockResolvedValue(),
         getEntry: jest.fn().mockResolvedValue(entry),
         getMedia: jest.fn().mockResolvedValue([]),
+        getNotes: jest.fn().mockResolvedValue([]),
       };
 
       const store = mockStore({
@@ -106,7 +107,7 @@ describe('editorialWorkflow actions', () => {
 
       return store.dispatch(actions.publishUnpublishedEntry('posts', slug)).then(() => {
         const actions = store.getActions();
-        expect(actions).toHaveLength(8);
+        expect(actions).toHaveLength(11);
 
         expect(actions[0]).toEqual({
           type: 'UNPUBLISHED_ENTRY_PUBLISH_REQUEST',
@@ -163,6 +164,28 @@ describe('editorialWorkflow actions', () => {
             entry,
           },
         });
+
+        expect(actions[8]).toEqual({
+          type: 'NOTES_REQUEST',
+          payload: {
+            collection: 'posts',
+            slug,
+          },
+        });
+        expect(actions[9]).toEqual({
+          type: 'NOTES_SUCCESS',
+          payload: {
+            collection: 'posts',
+            slug,
+            notes: [],
+          },
+        });
+        expect(actions[10]).toEqual({
+          type: 'DRAFT_NOTES_LOAD',
+          payload: {
+            notes: [],
+          },
+        });
       });
     });
 
diff --git a/packages/decap-cms-core/src/actions/entries.ts b/packages/decap-cms-core/src/actions/entries.ts
index 5f8ebddfc761..2981293cadfe 100644
--- a/packages/decap-cms-core/src/actions/entries.ts
+++ b/packages/decap-cms-core/src/actions/entries.ts
@@ -566,7 +566,7 @@ export function loadEntry(collection: Collection, slug: string) {
       const loadedEntry = await tryLoadEntry(getState(), collection, slug);
       dispatch(entryLoaded(collection, loadedEntry));
       dispatch(createDraftFromEntry(loadedEntry));
-      dispatch(loadNotes(collection, slug));
+      await dispatch(loadNotes(collection, slug));
     } catch (error) {
       dispatch(
         addNotification({
diff --git a/packages/decap-cms-core/src/reducers/__tests__/entryDraft.spec.js b/packages/decap-cms-core/src/reducers/__tests__/entryDraft.spec.js
index 8899ed85d47c..bcd2b4622684 100644
--- a/packages/decap-cms-core/src/reducers/__tests__/entryDraft.spec.js
+++ b/packages/decap-cms-core/src/reducers/__tests__/entryDraft.spec.js
@@ -1,4 +1,4 @@
-import { Map, fromJS } from 'immutable';
+import { Map, fromJS, List } from 'immutable';
 
 import * as actions from '../../actions/entries';
 import reducer from '../entryDraft';
@@ -11,6 +11,7 @@ const initialState = Map({
   fieldsErrors: Map(),
   hasChanged: false,
   key: '',
+  notes: List([]),
 });
 
 const entry = {
@@ -37,6 +38,7 @@ describe('entryDraft reducer', () => {
           fieldsErrors: Map(),
           hasChanged: false,
           key: '1',
+          notes: List([]),
         }),
       );
     });
@@ -55,6 +57,7 @@ describe('entryDraft reducer', () => {
           fieldsErrors: Map(),
           hasChanged: false,
           key: '1',
+          notes: List([]),
         }),
       );
     });
@@ -132,6 +135,7 @@ describe('entryDraft reducer', () => {
         fieldsErrors: {},
         hasChanged: true,
         key: '',
+        notes: [], // This stays as regular array in .toJS() output
       });
     });
   });
@@ -149,6 +153,7 @@ describe('entryDraft reducer', () => {
         fieldsErrors: {},
         hasChanged: true,
         key: '',
+        notes: [], // This stays as regular array in .toJS() output
       });
     });
   });
@@ -170,6 +175,7 @@ describe('entryDraft reducer', () => {
         fieldsErrors: {},
         hasChanged: true,
         key: '1',
+        notes: [], // This stays as regular array in .toJS() output
       });
     });
   });
@@ -192,6 +198,7 @@ describe('entryDraft reducer', () => {
           entry: { ...entry, mediaFiles: [{ id: '1' }] },
         },
         key: '',
+        notes: [], // This stays as regular array in .toJS() output
       });
     });
   });

From 0636dfbd96ce95d9666b838afa9618e62df7c791 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Mon, 22 Sep 2025 11:57:22 -0400
Subject: [PATCH 17/40] fix: inverted logic for initializing notesVisible

---
 .../decap-cms-core/src/components/Editor/EditorInterface.js     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/decap-cms-core/src/components/Editor/EditorInterface.js b/packages/decap-cms-core/src/components/Editor/EditorInterface.js
index 06dde5c6f6de..b06a40bd72d3 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorInterface.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorInterface.js
@@ -183,7 +183,7 @@ class EditorInterface extends Component {
   state = {
     showEventBlocker: false,
     previewVisible: localStorage.getItem(PREVIEW_VISIBLE) !== 'false',
-    notesVisible: localStorage.getItem(NOTES_VISIBLE) === 'false',
+    notesVisible: localStorage.getItem(NOTES_VISIBLE) !== 'false',
     scrollSyncEnabled: localStorage.getItem(SCROLL_SYNC_ENABLED) !== 'false',
     i18nVisible: localStorage.getItem(I18N_VISIBLE) !== 'false',
   };

From 706ec594bb704f148eb2202795ff4c83293e1646 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Mon, 22 Sep 2025 12:20:23 -0400
Subject: [PATCH 18/40] fix: more robust handleBlur function for notes

---
 .../Editor/EditorNotesPane/AddNoteForm.js       | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js
index 2618bd7d10f4..c3efc93fcb85 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js
@@ -105,14 +105,15 @@ class AddNoteForm extends Component {
     this.setState({ isFocused: true });
   };
 
-  handleBlur = () => {
-    // Delay to allow button click to register
-    setTimeout(() => {
-      if (!this.state.content.trim()) {
-        this.setState({ isFocused: false });
-      }
-    }, 150);
-  };
+  handleBlur = e => {
+    const { relatedTarget } = e;
+    if (relatedTarget && relatedTarget.type === 'submit') {
+      return; // Do not update state if blur is caused by clicking the submit button
+    }
+    if (!this.state.content.trim()) {
+      this.setState({ isFocused: false });
+    }
+  }
 
   render() {
     const { t } = this.props;

From 240091bcb976774a7ddc8fdbb322d01b817f5bd0 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Mon, 22 Sep 2025 15:29:06 -0400
Subject: [PATCH 19/40] feat: notes pane feature is now opt-in depending on
 config

---
 packages/decap-cms-core/index.d.ts             |  1 +
 packages/decap-cms-core/src/actions/config.ts  | 18 ++++++++++++++++--
 packages/decap-cms-core/src/actions/entries.ts |  6 +++++-
 packages/decap-cms-core/src/types/redux.ts     |  2 ++
 4 files changed, 24 insertions(+), 3 deletions(-)

diff --git a/packages/decap-cms-core/index.d.ts b/packages/decap-cms-core/index.d.ts
index 91aefaad075d..8511058e9000 100644
--- a/packages/decap-cms-core/index.d.ts
+++ b/packages/decap-cms-core/index.d.ts
@@ -408,6 +408,7 @@ declare module 'decap-cms-core' {
     i18n?: CmsI18nConfig;
     local_backend?: boolean | CmsLocalBackend;
     editor?: {
+      notes?: boolean;
       preview?: boolean;
     };
   }
diff --git a/packages/decap-cms-core/src/actions/config.ts b/packages/decap-cms-core/src/actions/config.ts
index 0911d5cda3d6..ddd4c445d169 100644
--- a/packages/decap-cms-core/src/actions/config.ts
+++ b/packages/decap-cms-core/src/actions/config.ts
@@ -210,7 +210,18 @@ export function applyDefaults(originalConfig: CmsConfig) {
   return produce(originalConfig, config => {
     config.publish_mode = config.publish_mode || SIMPLE_PUBLISH_MODE;
     config.slug = config.slug || {};
-    config.collections = config.collections || [];
+    config.collections = config.collections || []
+
+    if (!config.editor) {
+      config.editor = {};
+    }
+
+    if (!('preview' in config.editor)) {
+      config.editor.preview = true;
+    }
+    if (!('notes' in config.editor)) {
+      config.editor.notes = false;
+    };
 
     // Use `site_url` as default `display_url`.
     if (!config.display_url && config.site_url) {
@@ -357,7 +368,10 @@ export function applyDefaults(originalConfig: CmsConfig) {
       });
 
       if (config.editor && !collection.editor) {
-        collection.editor = { preview: config.editor.preview };
+        collection.editor = {
+          preview: config.editor.preview,
+          notes: config.editor.notes
+        };
       }
     }
   });
diff --git a/packages/decap-cms-core/src/actions/entries.ts b/packages/decap-cms-core/src/actions/entries.ts
index 2981293cadfe..5917700fb9c6 100644
--- a/packages/decap-cms-core/src/actions/entries.ts
+++ b/packages/decap-cms-core/src/actions/entries.ts
@@ -566,7 +566,11 @@ export function loadEntry(collection: Collection, slug: string) {
       const loadedEntry = await tryLoadEntry(getState(), collection, slug);
       dispatch(entryLoaded(collection, loadedEntry));
       dispatch(createDraftFromEntry(loadedEntry));
-      await dispatch(loadNotes(collection, slug));
+      const state = getState();
+      const isNotesEnabled = state.config.editor?.notes ?? false;
+      if (isNotesEnabled) {
+        await dispatch(loadNotes(collection, slug));
+      }
     } catch (error) {
       dispatch(
         addNotification({
diff --git a/packages/decap-cms-core/src/types/redux.ts b/packages/decap-cms-core/src/types/redux.ts
index 11ad36e9b634..e0bef0262cfd 100644
--- a/packages/decap-cms-core/src/types/redux.ts
+++ b/packages/decap-cms-core/src/types/redux.ts
@@ -345,6 +345,7 @@ export interface CmsCollection {
   delete?: boolean;
   editor?: {
     preview?: boolean;
+    notes?: boolean;
     visualEditing?: boolean;
   };
   publish?: boolean;
@@ -444,6 +445,7 @@ export interface CmsConfig {
   local_backend?: boolean | CmsLocalBackend;
   editor?: {
     preview?: boolean;
+    notes?: boolean;
   };
   error: string | undefined;
   isFetching: boolean;

From 4edb039bf5ff4e49b9e814622fafeeb81cfb4795 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Mon, 22 Sep 2025 15:38:45 -0400
Subject: [PATCH 20/40] chore: changed icon for notesPane to quote

---
 .../decap-cms-core/src/components/Editor/EditorInterface.js     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/decap-cms-core/src/components/Editor/EditorInterface.js b/packages/decap-cms-core/src/components/Editor/EditorInterface.js
index b06a40bd72d3..acd2b40060e9 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorInterface.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorInterface.js
@@ -466,7 +466,7 @@ class EditorInterface extends Component {
                 isActive={notesVisible}
                 onClick={this.handleToggleNotes}
                 size="large"
-                type="page"
+                type="quote"
                 title={t('editor.editorInterface.toggleNotes')}
               />
             )}

From f3a14efa54805af61fb28a881641a20d10bb31b1 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Mon, 22 Sep 2025 22:36:26 -0400
Subject: [PATCH 21/40] feat: notes now use Github issues  making notes usable
 for both published and unpublished entries

---
 packages/decap-cms-backend-github/src/API.ts  | 288 ++++++++++++++----
 .../src/implementation.tsx                    | 197 +++++-------
 .../src/types/githubPullRequests.ts           |  18 --
 .../src/components/Editor/EditorInterface.js  |   2 +-
 4 files changed, 322 insertions(+), 183 deletions(-)
 delete mode 100644 packages/decap-cms-backend-github/src/types/githubPullRequests.ts

diff --git a/packages/decap-cms-backend-github/src/API.ts b/packages/decap-cms-backend-github/src/API.ts
index 47fce3488d24..4ae1682e56f4 100644
--- a/packages/decap-cms-backend-github/src/API.ts
+++ b/packages/decap-cms-backend-github/src/API.ts
@@ -41,7 +41,6 @@ import type {
 } from 'decap-cms-lib-util';
 import type { Semaphore } from 'semaphore';
 import type { Octokit } from '@octokit/rest';
-import type { GitHubIssueComment } from './types/githubPullRequests';
 
 type GitHubUser = Octokit.UsersGetAuthenticatedResponse;
 type GitCreateTreeParamsTree = Octokit.GitCreateTreeParamsTree;
@@ -76,6 +75,26 @@ interface TreeFile {
   raw?: string;
 }
 
+interface GitHubIssue {
+  id: number;
+  number: number;
+  title: string;
+  body: string;
+  state: 'open' | 'closed';
+  comments: number;
+  html_url: string;
+  created_at: string;
+  updated_at: string;
+  user: {
+    login: string;
+    avatar_url: string;
+  } | null;
+  labels: Array<{
+    name: string;
+    color: string;
+  }>;
+}
+
 type Override<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;
 
 type TreeEntry = Override<GitCreateTreeParamsTree, { sha: string | null }>;
@@ -1482,36 +1501,26 @@ export default class API {
    */
   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]+)$/;
 
-  private async getPRComments(prNumber: string | number): Promise<GitHubIssueComment[]> {
-    try {
-      const response: GitHubIssueComment[] = await this.request(
-        `${this.originRepoURL}/issues/${prNumber}/comments`,
-      );
-      return Array.isArray(response) ? response : [];
-    } catch (error) {
-      console.error('Failed to get PR comments:', error);
-      return [];
-    }
-  }
-
   /**
    * Format a note for PR comment display
    */
-  private formatNoteForPR(note: Note): string {
+  private formatNoteForGithub(note: Note): string {
     const status = note.resolved ? API.NOTE_STATUS_RESOLVED : API.NOTE_STATUS_OPEN;
 
-    return `<!-- DecapCMS Note - Status: ${status} -->    
+    return `<!-- DecapCMS Note - Status: ${status} -->
 ${note.content}`;
   }
 
   /**
    * Parse a GitHub comment into a Note object
    */
-  private parseCommentToNote(comment: GitHubIssueComment): Note {
+  private parseCommentToNote(comment: GitHubIssue): Note {
     if (!comment || !comment.body || !comment.user) {
       throw new Error('Invalid comment structure');
     }
@@ -1536,54 +1545,231 @@ ${note.content}`;
     };
   }
 
-  async getNotesFromPR(prNumber: string | number): Promise<Note[]> {
-    const comments = await this.getPRComments(prNumber);
-    return comments.map(comment => this.parseCommentToNote(comment));
-  }
+  /**
+ * Create a GitHub issue for storing notes for a specific entry
+ */
+async createEntryIssue(
+  collectionName: string,
+  slug: string,
+  entryTitle?: string
+): Promise<GitHubIssue> {
+  const title = `${API.NOTE_ISSUE_PREFIX}${entryTitle || `${collectionName}/${slug}`}`;
+  const body = `This issue tracks notes for entry: \`${collectionName}/${slug}\`\n\n---\n*This issue was created automatically by Decap CMS for note management.*`;
+
+  const response: GitHubIssue = await this.request(`${this.repoURL}/issues`, {
+    method: 'POST',
+    body: JSON.stringify({
+      title,
+      body,
+      labels: [API.NOTES_LABEL, `collection:${collectionName}`]
+    }),
+  });
+
+  return response;
+}
 
-  async createPRComment(prNumber: string | number, note: Note): Promise<string> {
-    try {
-      const response: GitHubIssueComment = await this.request(
-        `${this.originRepoURL}/issues/${prNumber}/comments`,
-        {
-          method: 'POST',
-          body: JSON.stringify({
-            body: this.formatNoteForPR(note),
-          }),
-        },
-      );
+/**
+ * Find existing issue for an entry or create a new one
+ */
+async getOrCreateEntryIssue(
+  collectionName: string,
+  slug: string,
+  entryTitle?: string
+): Promise<GitHubIssue> {
+  // Search for existing issue
+  const searchQuery = `repo:${this.repo} label:${API.NOTES_LABEL} "${collectionName}/${slug}" in:body state:open`;
+
+  try {
+    const searchResponse = await this.request('/search/issues', {
+      params: { q: searchQuery }
+    });
 
-      return response.id.toString();
-    } catch (error) {
-      console.error('Failed to create PR comment:', error);
-      throw new APIError('Failed to create note', error.status || 500, API_NAME);
+    if (searchResponse.items && searchResponse.items.length > 0) {
+      return searchResponse.items[0];
     }
+  } catch (error) {
+    console.warn('Failed to search for existing notes issue:', error);
   }
 
-  async updatePRComment(commentId: string | number, note: Note): Promise<void> {
-    try {
-      await this.request(`${this.originRepoURL}/issues/comments/${commentId}`, {
-        method: 'PATCH',
+  // Create new issue if none exists
+  return this.createEntryIssue(collectionName, slug, entryTitle);
+}
+
+/**
+ * Get comments from a GitHub issue
+ */
+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 [];
+  }
+}
+
+/**
+ * Create a comment on a GitHub issue
+ */
+async createIssueComment(issueNumber: number, note: Note): Promise<string> {
+  try {
+    const response: GitHubIssue = await this.request(
+      `${this.repoURL}/issues/${issueNumber}/comments`,
+      {
+        method: 'POST',
         body: JSON.stringify({
-          body: this.formatNoteForPR(note),
+          body: this.formatNoteForGithub(note),
         }),
-      });
-    } catch (error) {
-      console.error('Failed to update PR comment:', error);
-      throw new APIError('Failed to update note', error.status || 500, API_NAME);
+      }
+    );
+
+    return response.id.toString();
+  } catch (error) {
+    console.error('Failed to create issue comment:', error);
+    throw new APIError('Failed to create note', error.status || 500, API_NAME);
+  }
+}
+
+/**
+ * Update a GitHub issue comment
+ */
+async updateIssueComment(commentId: string | number, note: Note): Promise<void> {
+  try {
+    await this.request(`${this.repoURL}/issues/comments/${commentId}`, {
+      method: 'PATCH',
+      body: JSON.stringify({
+        body: this.formatNoteForGithub(note),
+      }),
+    });
+  } catch (error) {
+    console.error('Failed to update issue comment:', error);
+    throw new APIError('Failed to update note', error.status || 500, API_NAME);
+  }
+}
+
+/**
+ * Delete a GitHub issue comment
+ */
+async deleteIssueComment(commentId: string | number): Promise<void> {
+  try {
+    await this.request(`${this.repoURL}/issues/comments/${commentId}`, {
+      method: 'DELETE',
+    });
+  } catch (error) {
+    console.error('Failed to delete issue comment:', error);
+    throw new APIError('Failed to delete note', error.status || 500, API_NAME);
+  }
+}
+
+  /**
+ * Get all notes for an entry (works for all entries)
+ */
+async getEntryNotes(collectionName: string, slug: string): Promise<Note[]> {
+  try {
+    const issue = await this.getOrCreateEntryIssue(collectionName, slug);
+    const comments = await this.getIssueComments(issue.number);
+    return comments.map(comment => this.parseCommentToNote(comment));
+  } catch (error) {
+    console.error('Failed to get entry notes:', error);
+    return [];
+  }
+}
+
+/**
+ * Add a note to any entry
+ */
+async addNoteToEntry(
+  collectionName: string,
+  slug: string,
+  note: Note,
+  entryTitle?: string
+): Promise<string> {
+  try {
+    const issue = await this.getOrCreateEntryIssue(collectionName, slug, entryTitle);
+    const issueNoteId = await this.createIssueComment(issue.number, note);
+    return issueNoteId;
+  } catch (error) {
+    console.error('Failed to add note to entry:', error);
+    throw new APIError('Failed to create note', error.status || 500, API_NAME);
+  }
+}
+
+async updateEntryNote(noteId: string, note: Note): Promise<void> {
+  try {
+    await this.updateIssueComment(noteId, note);
+  } catch (error) {
+    console.error('Failed to update entry note:', error);
+    throw new APIError('Failed to update note', error.status || 500, API_NAME);
+  }
+}
+
+async deleteEntryNote(noteId: string): Promise<void> {
+  try {
+    await this.deleteIssueComment(noteId);
+  } catch (error) {
+    console.error('Failed to delete entry note:', error);
+    throw new APIError('Failed to delete note', error.status || 500, API_NAME);
+  }
+}
+
+/**
+ * Get all entries that have notes (useful for showing notes indicator in UI)
+ */
+async getEntriesWithNotes(): Promise<Array<{ collection: string; slug: string; noteCount: number }>> {
+  try {
+    const searchQuery = `repo:${this.repo} label:${API.NOTES_LABEL} state:open`;
+    const searchResponse = await this.request('/search/issues', {
+      params: { q: searchQuery, per_page: 100 }
+    });
+
+    const entriesWithNotes = [];
+
+    for (const issue of searchResponse.items || []) {
+      // Extract collection/slug from issue body
+      const match = issue.body.match(/entry: `(.+)\/(.+)`/);
+      if (match) {
+        const [, collection, slug] = match;
+        entriesWithNotes.push({
+          collection,
+          slug,
+          noteCount: issue.comments
+        });
+      }
     }
+
+    return entriesWithNotes;
+  } catch (error) {
+    console.error('Failed to get entries with notes:', error);
+    return [];
   }
+}
 
-  async deletePRComment(commentId: string | number): Promise<void> {
-    try {
-      await this.request(`${this.originRepoURL}/issues/comments/${commentId}`, {
-        method: 'DELETE',
+/**
+ * Close notes issue when entry is deleted
+ */
+async closeEntryNotesIssue(collectionName: string, slug: string): Promise<void> {
+  try {
+    const searchQuery = `repo:${this.repo} label:${API.NOTES_LABEL} "${collectionName}/${slug}" in:body state:open`;
+    const searchResponse = await this.request('/search/issues', {
+      params: { q: searchQuery }
+    });
+
+    if (searchResponse.items && searchResponse.items.length > 0) {
+      const issue = searchResponse.items[0];
+      await this.request(`${this.repoURL}/issues/${issue.number}`, {
+        method: 'PATCH',
+        body: JSON.stringify({
+          state: 'closed',
+          labels: [...(issue.labels || []).map((l: { name: string }) => l.name), 'entry-deleted']
+        })
       });
-    } catch (error) {
-      console.error('Failed to delete PR comment:', error);
-      throw new APIError('Failed to delete note', error.status || 500, API_NAME);
     }
+  } catch (error) {
+    console.warn('Failed to close notes issue:', error);
   }
+}
 
   /**
    * Get PR metadata from branch name
diff --git a/packages/decap-cms-backend-github/src/implementation.tsx b/packages/decap-cms-backend-github/src/implementation.tsx
index 6df577094e3c..bfc144393523 100644
--- a/packages/decap-cms-backend-github/src/implementation.tsx
+++ b/packages/decap-cms-backend-github/src/implementation.tsx
@@ -701,13 +701,21 @@ export default class GitHub implements Implementation {
   }
 
   deleteUnpublishedEntry(collection: string, slug: string) {
-    // deleteUnpublishedEntry is a transactional operation
-    return runWithLock(
-      this.lock,
-      () => this.api!.deleteUnpublishedEntry(collection, slug),
-      'Failed to acquire delete entry lock',
-    );
-  }
+  // deleteUnpublishedEntry is a transactional operation
+  return runWithLock(
+    this.lock,
+    async () => {
+      await this.api!.deleteUnpublishedEntry(collection, slug);
+      // Clean up associated notes issue
+      try {
+        await this.api!.closeEntryNotesIssue(collection, slug);
+      } catch (error) {
+        console.warn('Failed to close notes issue during entry deletion:', error);
+      }
+    },
+    'Failed to acquire delete entry lock',
+  );
+}
 
   publishUnpublishedEntry(collection: string, slug: string) {
     // publishUnpublishedEntry is a transactional operation
@@ -720,124 +728,87 @@ export default class GitHub implements Implementation {
 
   // Notes implementation, which is an abstraction to Github's PR issue comments.
 
-  /**
-   * Helper method to get PR info for an entry
-   */
-  private async getPRInfo(collection: string, slug: string) {
-    const contentKey = this.api!.generateContentKey(collection, slug);
-    const branch = branchFromContentKey(contentKey);
-    const pullRequest = await this.api!.getBranchPullRequest(branch);
-
-    return {
-      branch,
-      pullRequest,
-      hasPR: pullRequest.number !== -1,
-    };
-  }
-
-  async getNotes(collection: string, slug: string): Promise<Note[]> {
-    if (!this.options.useWorkflow) {
-      return [];
-    }
-    try {
-      const { pullRequest, hasPR } = await this.getPRInfo(collection, slug);
-
-      if (!hasPR) {
-        return [];
-      }
-
-      const notes = await this.api!.getNotesFromPR(pullRequest.number);
-      return notes.map(note => ({ ...note, entrySlug: slug }));
-    } catch (error) {
-      console.error('Failed to get notes:', error);
-      return [];
-    }
+// Notes implementation using GitHub Issues
+async getNotes(collection: string, slug: string): Promise<Note[]> {
+  try {
+    const notes = await this.api!.getEntryNotes(collection, slug);
+    return notes.map(note => ({ ...note, entrySlug: slug }));
+  } catch (error) {
+    console.error('Failed to get notes:', error);
+    return [];
   }
+}
 
-  async addNote(collection: string, slug: string, noteData: Omit<Note, 'id'>): Promise<Note> {
-    if (!this.options.useWorkflow) {
-      throw new Error('Notes are only available when workflow is enabled.');
-    }
-
-    const { pullRequest, hasPR } = await this.getPRInfo(collection, slug);
-
-    if (!hasPR) {
-      throw new Error('Cannot add notes to draft entries. Please submit for review first.');
-    }
-
-    const currentUser = await this.currentUser({ token: this.token! });
-
-    const note: Note = {
-      ...noteData,
-      id: 'temp-' + Date.now(),
-      author: currentUser.login || currentUser.name,
-      avatarUrl: currentUser.avatar_url,
-      entrySlug: slug,
-      timestamp: noteData.timestamp || new Date().toISOString(),
-      resolved: noteData.resolved || false,
-    };
+async addNote(collection: string, slug: string, noteData: Omit<Note, 'id'>): Promise<Note> {
+  const currentUser = await this.currentUser({ token: this.token! });
+  const note: Note = {
+    ...noteData,
+    id: 'temp-' + Date.now(),
+    author: currentUser.login || currentUser.name,
+    avatarUrl: currentUser.avatar_url,
+    entrySlug: slug,
+    timestamp: noteData.timestamp || new Date().toISOString(),
+    resolved: noteData.resolved || false,
+  };
 
-    const commentId = await this.api!.createPRComment(pullRequest.number, note);
-    return { ...note, id: commentId };
+  // Get entry title for better issue naming
+  let entryTitle: string | undefined;
+  try {
+    const entryData = await this.getEntry(`${collection}/${slug}.md`); // Adjust path as needed
+    // Extract title from frontmatter if available
+    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
   }
 
-  async updateNote(
-    collection: string,
-    slug: string,
-    noteId: string,
-    updates: Partial<Note>,
-  ): Promise<Note> {
-    if (!this.options.useWorkflow) {
-      throw new Error('Notes are only available when workflow is enabled.');
-    }
-
-    const currentNotes = await this.getNotes(collection, slug);
-    const existingNote = currentNotes.find(note => note.id === noteId);
+  const commentId = await this.api!.addNoteToEntry(collection, slug, note, entryTitle);
+  return { ...note, id: commentId };
+}
 
-    if (!existingNote) {
-      throw new Error(`Note with ID ${noteId} not found`);
-    }
+async updateNote(
+  collection: string,
+  slug: string,
+  noteId: string,
+  updates: Partial<Note>,
+): Promise<Note> {
+  const currentNotes = await this.getNotes(collection, slug);
+  const existingNote = currentNotes.find(note => note.id === noteId);
+  if (!existingNote) {
+    throw new Error(`Note with ID ${noteId} not found`);
+  }
+
+  const updatedNote: Note = {
+    ...existingNote,
+    ...updates,
+    id: noteId,
+    entrySlug: slug,
+  };
 
-    const updatedNote: Note = {
-      ...existingNote,
-      ...updates,
-      id: noteId,
-      entrySlug: slug,
-    };
+  await this.api!.updateEntryNote(noteId, updatedNote);
+  return updatedNote;
+}
 
-    await this.api!.updatePRComment(noteId, updatedNote);
-    return updatedNote;
+async deleteNote(collection: string, slug: string, noteId: string): Promise<void> {
+  const currentNotes = await this.getNotes(collection, slug);
+  const noteExists = currentNotes.some(note => note.id === noteId);
+  if (!noteExists) {
+    throw new Error(`Note with ID ${noteId} not found`);
   }
 
-  async deleteNote(collection: string, slug: string, noteId: string): Promise<void> {
-    if (!this.options.useWorkflow) {
-      throw new Error('Notes are only available when workflow is enabled.');
-    }
-
-    const currentNotes = await this.getNotes(collection, slug);
-    const noteExists = currentNotes.some(note => note.id === noteId);
+  await this.api!.deleteEntryNote(noteId);
 
-    if (!noteExists) {
-      throw new Error(`Note with ID ${noteId} not found`);
-    }
+}
 
-    await this.api!.deletePRComment(noteId);
+async toggleNoteResolution(collection: string, slug: string, noteId: string): Promise<Note> {
+  const currentNotes = await this.getNotes(collection, slug);
+  const note = currentNotes.find(n => n.id === noteId);
+  if (!note) {
+    throw new Error(`Note with ID ${noteId} not found`);
   }
 
-  async toggleNoteResolution(collection: string, slug: string, noteId: string): Promise<Note> {
-    if (!this.options.useWorkflow) {
-      throw new Error('Notes are only available when workflow is enabled.');
-    }
-
-    const currentNotes = await this.getNotes(collection, slug);
-    const note = currentNotes.find(n => n.id === noteId);
-
-    if (!note) {
-      throw new Error(`Note with ID ${noteId} not found`);
-    }
-
-    return this.updateNote(collection, slug, noteId, {
-      resolved: !note.resolved,
-    });
-  }
+  return this.updateNote(collection, slug, noteId, {
+    resolved: !note.resolved,
+  });
+}
 }
diff --git a/packages/decap-cms-backend-github/src/types/githubPullRequests.ts b/packages/decap-cms-backend-github/src/types/githubPullRequests.ts
deleted file mode 100644
index 55f488fc3516..000000000000
--- a/packages/decap-cms-backend-github/src/types/githubPullRequests.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-type GitHubIssueComment = {
-  id: number;
-  node_id: string;
-  url: string;
-  html_url: string;
-  body: string;
-  user: {
-    login: string;
-    id: number;
-    avatar_url: string;
-    html_url: string;
-  };
-  created_at: string;
-  updated_at: string;
-  author_association: string;
-};
-
-export type { GitHubIssueComment };
diff --git a/packages/decap-cms-core/src/components/Editor/EditorInterface.js b/packages/decap-cms-core/src/components/Editor/EditorInterface.js
index acd2b40060e9..685bc693578a 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorInterface.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorInterface.js
@@ -167,7 +167,7 @@ function isPreviewEnabled(collection, entry) {
 }
 
 function isNotesEnabled(collection, entry, isNewEntry, isPublished, hasWorkflow) {
-  if (isNewEntry || isPublished || !hasWorkflow) {
+  if (isNewEntry || !hasWorkflow) {
     return false;
   }
 

From 9265a4f43b65b4d469c2f2f3097f4c524b69c5d7 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Thu, 25 Sep 2025 14:40:48 -0400
Subject: [PATCH 22/40] fix: removed condition that would loadNotes() twice

---
 packages/decap-cms-core/src/components/Editor/Editor.js | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/packages/decap-cms-core/src/components/Editor/Editor.js b/packages/decap-cms-core/src/components/Editor/Editor.js
index c6fc775b347d..f77452f8cdbc 100644
--- a/packages/decap-cms-core/src/components/Editor/Editor.js
+++ b/packages/decap-cms-core/src/components/Editor/Editor.js
@@ -181,9 +181,6 @@ export class Editor extends React.Component {
         this.deleteBackup();
       }
     }
-    if (!prevProps.entry && this.props.entry && !this.props.newEntry && this.props.hasWorkflow) {
-      this.props.loadNotes(this.props.collection, this.props.slug);
-    }
 
     if (
       prevProps.entry !== this.props.entry &&

From 722cbd5bb2c74451687f50feb5f1e5938076c999 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Thu, 25 Sep 2025 14:53:31 -0400
Subject: [PATCH 23/40] feat: lifecycle for github issues when
 publishing/unpublishing entries

---
 packages/decap-cms-backend-github/src/API.ts  | 58 ++++++++++++++++++-
 .../src/implementation.tsx                    |  8 ++-
 .../src/actions/editorialWorkflow.ts          |  1 +
 packages/decap-cms-core/src/backend.ts        |  8 +++
 .../decap-cms-lib-util/src/implementation.ts  |  1 +
 5 files changed, 74 insertions(+), 2 deletions(-)

diff --git a/packages/decap-cms-backend-github/src/API.ts b/packages/decap-cms-backend-github/src/API.ts
index 4ae1682e56f4..9ccb6d2993a7 100644
--- a/packages/decap-cms-backend-github/src/API.ts
+++ b/packages/decap-cms-backend-github/src/API.ts
@@ -1193,6 +1193,7 @@ export default class API {
     const pullRequest = await this.getBranchPullRequest(branch);
     await this.mergePR(pullRequest);
     await this.deleteBranch(branch);
+    await this.closeIssueOnPublish(collectionName, slug);
   }
 
   async createRef(type: string, name: string, sha: string) {
@@ -1577,7 +1578,7 @@ async getOrCreateEntryIssue(
   entryTitle?: string
 ): Promise<GitHubIssue> {
   // Search for existing issue
-  const searchQuery = `repo:${this.repo} label:${API.NOTES_LABEL} "${collectionName}/${slug}" in:body state:open`;
+  const searchQuery = `repo:${this.repo} label:${API.NOTES_LABEL} "${collectionName}/${slug}" in:body`;
 
   try {
     const searchResponse = await this.request('/search/issues', {
@@ -1663,6 +1664,61 @@ async deleteIssueComment(commentId: string | number): Promise<void> {
   }
 }
 
+/**
+ * Close the notes issue when an entry is published
+ */
+async closeIssueOnPublish(collectionName: string, slug: string): Promise<void> {
+  try {
+    const searchQuery = `repo:${this.repo} label:${API.NOTES_LABEL} "${collectionName}/${slug}" in:body state:open`;
+    const searchResponse = await this.request('/search/issues', {
+      params: { q: searchQuery }
+    });
+    
+    if (searchResponse.items && searchResponse.items.length > 0) {
+      const issue = searchResponse.items[0];
+      await this.request(`${this.repoURL}/issues/${issue.number}`, {
+        method: 'PATCH',
+        body: JSON.stringify({
+          state: 'closed',
+          labels: [...(issue.labels || []).map((l: { name: string }) => l.name), 'entry-published']
+        })
+      });
+    }
+  } catch (error) {
+    console.warn('Failed to close notes issue on publish:', error);
+  }
+}
+
+/**
+ * Reopen the notes issue when an entry is unpublished
+ */
+async reopenIssueOnUnpublish(collectionName: string, slug: string): Promise<void> {
+  try {
+    const searchQuery = `repo:${this.repo} label:${API.NOTES_LABEL} "${collectionName}/${slug}" in:body`;
+    const searchResponse = await this.request('/search/issues', {
+      params: { q: searchQuery }
+    });
+    
+    if (searchResponse.items && searchResponse.items.length > 0) {
+      const issue = searchResponse.items[0];
+      // Remove 'entry-published' or 'entry-deleted' labels and reopen
+      const updatedLabels = (issue.labels || [])
+        .map((l: { name: string }) => l.name)
+        .filter((name: string) => name !== 'entry-published' && name !== 'entry-deleted');
+      
+      await this.request(`${this.repoURL}/issues/${issue.number}`, {
+        method: 'PATCH',
+        body: JSON.stringify({
+          state: 'open',
+          labels: updatedLabels
+        })
+      });
+    }
+  } catch (error) {
+    console.warn('Failed to reopen notes issue on unpublish:', error);
+  }
+}
+
   /**
  * Get all notes for an entry (works for all entries)
  */
diff --git a/packages/decap-cms-backend-github/src/implementation.tsx b/packages/decap-cms-backend-github/src/implementation.tsx
index bfc144393523..78da66adbc9d 100644
--- a/packages/decap-cms-backend-github/src/implementation.tsx
+++ b/packages/decap-cms-backend-github/src/implementation.tsx
@@ -721,7 +721,9 @@ export default class GitHub implements Implementation {
     // publishUnpublishedEntry is a transactional operation
     return runWithLock(
       this.lock,
-      () => this.api!.publishUnpublishedEntry(collection, slug),
+      async () =>{ this.api!.publishUnpublishedEntry(collection, slug),
+        await this.api!.closeIssueOnPublish(collection, slug);
+      },
       'Failed to acquire publish entry lock',
     );
   }
@@ -811,4 +813,8 @@ async toggleNoteResolution(collection: string, slug: string, noteId: string): Pr
     resolved: !note.resolved,
   });
 }
+
+async reopenIssueForUnpublishedEntry(collection: string, slug: string) {
+  await this.api!.reopenIssueOnUnpublish(collection, slug);
+}
 }
diff --git a/packages/decap-cms-core/src/actions/editorialWorkflow.ts b/packages/decap-cms-core/src/actions/editorialWorkflow.ts
index cb4a0349d04d..ee5b9d817fdd 100644
--- a/packages/decap-cms-core/src/actions/editorialWorkflow.ts
+++ b/packages/decap-cms-core/src/actions/editorialWorkflow.ts
@@ -541,6 +541,7 @@ export function unpublishPublishedEntry(collection: Collection, slug: string) {
           status: status.get('PENDING_PUBLISH'),
         }),
       )
+      .then(() => backend.reopenIssueForUnpublishedEntry(collection.get('name'), slug))
       .then(() => {
         dispatch(unpublishedEntryPersisted(collection, entry));
         dispatch(entryDeleted(collection, slug));
diff --git a/packages/decap-cms-core/src/backend.ts b/packages/decap-cms-core/src/backend.ts
index 806577397480..b4fc89e337f3 100644
--- a/packages/decap-cms-core/src/backend.ts
+++ b/packages/decap-cms-core/src/backend.ts
@@ -630,6 +630,14 @@ export class Backend {
     throw new Error(`Backend '${this.backendName}' does not support toggling note resolution`);
   }
 
+  reopenIssueForUnpublishedEntry(collection: string, slug: string) {
+  if (typeof this.implementation.reopenIssueForUnpublishedEntry === 'function') {
+    return this.implementation.reopenIssueForUnpublishedEntry(collection, slug);
+  }
+  // If backend doesn't support this, silently skip
+  return Promise.resolve();
+}
+
   async getPRMetadata(
     collection: string,
     slug: string,
diff --git a/packages/decap-cms-lib-util/src/implementation.ts b/packages/decap-cms-lib-util/src/implementation.ts
index ed76e379fdc5..1ca0b79d14cd 100644
--- a/packages/decap-cms-lib-util/src/implementation.ts
+++ b/packages/decap-cms-lib-util/src/implementation.ts
@@ -180,6 +180,7 @@ export interface Implementation {
   deleteNote?: (collection: string, slug: string, noteId: string) => Promise<void>;
   toggleNoteResolution?: (collection: string, slug: string, noteId: string) => Promise<Note>;
   syncNotes?: (collection: string, slug: string, localNotes: Note[]) => Promise<Note[]>;
+  reopenIssueForUnpublishedEntry?: (collection: string, slug: string) => Promise<void>;
 
   getPRMetadata?: (
     collection: string,

From fc8c6476164db956b089bd8978978547dfbbeb7e Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Thu, 25 Sep 2025 15:00:21 -0400
Subject: [PATCH 24/40] chore: format

---
 packages/decap-cms-backend-github/src/API.ts  | 479 +++++++++---------
 .../src/implementation.tsx                    | 182 +++----
 packages/decap-cms-core/src/actions/config.ts |   6 +-
 packages/decap-cms-core/src/backend.ts        |  10 +-
 .../Editor/EditorNotesPane/AddNoteForm.js     |   2 +-
 5 files changed, 342 insertions(+), 337 deletions(-)

diff --git a/packages/decap-cms-backend-github/src/API.ts b/packages/decap-cms-backend-github/src/API.ts
index 9ccb6d2993a7..2a50e3d057ce 100644
--- a/packages/decap-cms-backend-github/src/API.ts
+++ b/packages/decap-cms-backend-github/src/API.ts
@@ -1547,285 +1547,290 @@ ${note.content}`;
   }
 
   /**
- * Create a GitHub issue for storing notes for a specific entry
- */
-async createEntryIssue(
-  collectionName: string,
-  slug: string,
-  entryTitle?: string
-): Promise<GitHubIssue> {
-  const title = `${API.NOTE_ISSUE_PREFIX}${entryTitle || `${collectionName}/${slug}`}`;
-  const body = `This issue tracks notes for entry: \`${collectionName}/${slug}\`\n\n---\n*This issue was created automatically by Decap CMS for note management.*`;
-
-  const response: GitHubIssue = await this.request(`${this.repoURL}/issues`, {
-    method: 'POST',
-    body: JSON.stringify({
-      title,
-      body,
-      labels: [API.NOTES_LABEL, `collection:${collectionName}`]
-    }),
-  });
-
-  return response;
-}
+   * Create a GitHub issue for storing notes for a specific entry
+   */
+  async createEntryIssue(
+    collectionName: string,
+    slug: string,
+    entryTitle?: string,
+  ): Promise<GitHubIssue> {
+    const title = `${API.NOTE_ISSUE_PREFIX}${entryTitle || `${collectionName}/${slug}`}`;
+    const body = `This issue tracks notes for entry: \`${collectionName}/${slug}\`\n\n---\n*This issue was created automatically by Decap CMS for note management.*`;
 
-/**
- * Find existing issue for an entry or create a new one
- */
-async getOrCreateEntryIssue(
-  collectionName: string,
-  slug: string,
-  entryTitle?: string
-): Promise<GitHubIssue> {
-  // Search for existing issue
-  const searchQuery = `repo:${this.repo} label:${API.NOTES_LABEL} "${collectionName}/${slug}" in:body`;
-
-  try {
-    const searchResponse = await this.request('/search/issues', {
-      params: { q: searchQuery }
+    const response: GitHubIssue = await this.request(`${this.repoURL}/issues`, {
+      method: 'POST',
+      body: JSON.stringify({
+        title,
+        body,
+        labels: [API.NOTES_LABEL, `collection:${collectionName}`],
+      }),
     });
 
-    if (searchResponse.items && searchResponse.items.length > 0) {
-      return searchResponse.items[0];
-    }
-  } catch (error) {
-    console.warn('Failed to search for existing notes issue:', error);
+    return response;
   }
 
-  // Create new issue if none exists
-  return this.createEntryIssue(collectionName, slug, entryTitle);
-}
+  /**
+   * Find existing issue for an entry or create a new one
+   */
+  async getOrCreateEntryIssue(
+    collectionName: string,
+    slug: string,
+    entryTitle?: string,
+  ): Promise<GitHubIssue> {
+    // Search for existing issue
+    const searchQuery = `repo:${this.repo} label:${API.NOTES_LABEL} "${collectionName}/${slug}" in:body`;
 
-/**
- * Get comments from a GitHub issue
- */
-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 [];
-  }
-}
+    try {
+      const searchResponse = await this.request('/search/issues', {
+        params: { q: searchQuery },
+      });
 
-/**
- * Create a comment on a GitHub issue
- */
-async createIssueComment(issueNumber: number, note: Note): Promise<string> {
-  try {
-    const response: GitHubIssue = await this.request(
-      `${this.repoURL}/issues/${issueNumber}/comments`,
-      {
-        method: 'POST',
-        body: JSON.stringify({
-          body: this.formatNoteForGithub(note),
-        }),
+      if (searchResponse.items && searchResponse.items.length > 0) {
+        return searchResponse.items[0];
       }
-    );
+    } catch (error) {
+      console.warn('Failed to search for existing notes issue:', error);
+    }
 
-    return response.id.toString();
-  } catch (error) {
-    console.error('Failed to create issue comment:', error);
-    throw new APIError('Failed to create note', error.status || 500, API_NAME);
+    // Create new issue if none exists
+    return this.createEntryIssue(collectionName, slug, entryTitle);
   }
-}
 
-/**
- * Update a GitHub issue comment
- */
-async updateIssueComment(commentId: string | number, note: Note): Promise<void> {
-  try {
-    await this.request(`${this.repoURL}/issues/comments/${commentId}`, {
-      method: 'PATCH',
-      body: JSON.stringify({
-        body: this.formatNoteForGithub(note),
-      }),
-    });
-  } catch (error) {
-    console.error('Failed to update issue comment:', error);
-    throw new APIError('Failed to update note', error.status || 500, API_NAME);
+  /**
+   * Get comments from a GitHub issue
+   */
+  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 [];
+    }
   }
-}
 
-/**
- * Delete a GitHub issue comment
- */
-async deleteIssueComment(commentId: string | number): Promise<void> {
-  try {
-    await this.request(`${this.repoURL}/issues/comments/${commentId}`, {
-      method: 'DELETE',
-    });
-  } catch (error) {
-    console.error('Failed to delete issue comment:', error);
-    throw new APIError('Failed to delete note', error.status || 500, API_NAME);
+  /**
+   * Create a comment on a GitHub issue
+   */
+  async createIssueComment(issueNumber: number, note: Note): Promise<string> {
+    try {
+      const response: GitHubIssue = await this.request(
+        `${this.repoURL}/issues/${issueNumber}/comments`,
+        {
+          method: 'POST',
+          body: JSON.stringify({
+            body: this.formatNoteForGithub(note),
+          }),
+        },
+      );
+
+      return response.id.toString();
+    } catch (error) {
+      console.error('Failed to create issue comment:', error);
+      throw new APIError('Failed to create note', error.status || 500, API_NAME);
+    }
   }
-}
 
-/**
- * Close the notes issue when an entry is published
- */
-async closeIssueOnPublish(collectionName: string, slug: string): Promise<void> {
-  try {
-    const searchQuery = `repo:${this.repo} label:${API.NOTES_LABEL} "${collectionName}/${slug}" in:body state:open`;
-    const searchResponse = await this.request('/search/issues', {
-      params: { q: searchQuery }
-    });
-    
-    if (searchResponse.items && searchResponse.items.length > 0) {
-      const issue = searchResponse.items[0];
-      await this.request(`${this.repoURL}/issues/${issue.number}`, {
+  /**
+   * Update a GitHub issue comment
+   */
+  async updateIssueComment(commentId: string | number, note: Note): Promise<void> {
+    try {
+      await this.request(`${this.repoURL}/issues/comments/${commentId}`, {
         method: 'PATCH',
         body: JSON.stringify({
-          state: 'closed',
-          labels: [...(issue.labels || []).map((l: { name: string }) => l.name), 'entry-published']
-        })
+          body: this.formatNoteForGithub(note),
+        }),
       });
+    } catch (error) {
+      console.error('Failed to update issue comment:', error);
+      throw new APIError('Failed to update note', error.status || 500, API_NAME);
     }
-  } catch (error) {
-    console.warn('Failed to close notes issue on publish:', error);
   }
-}
 
-/**
- * Reopen the notes issue when an entry is unpublished
- */
-async reopenIssueOnUnpublish(collectionName: string, slug: string): Promise<void> {
-  try {
-    const searchQuery = `repo:${this.repo} label:${API.NOTES_LABEL} "${collectionName}/${slug}" in:body`;
-    const searchResponse = await this.request('/search/issues', {
-      params: { q: searchQuery }
-    });
-    
-    if (searchResponse.items && searchResponse.items.length > 0) {
-      const issue = searchResponse.items[0];
-      // Remove 'entry-published' or 'entry-deleted' labels and reopen
-      const updatedLabels = (issue.labels || [])
-        .map((l: { name: string }) => l.name)
-        .filter((name: string) => name !== 'entry-published' && name !== 'entry-deleted');
-      
-      await this.request(`${this.repoURL}/issues/${issue.number}`, {
-        method: 'PATCH',
-        body: JSON.stringify({
-          state: 'open',
-          labels: updatedLabels
-        })
+  /**
+   * Delete a GitHub issue comment
+   */
+  async deleteIssueComment(commentId: string | number): Promise<void> {
+    try {
+      await this.request(`${this.repoURL}/issues/comments/${commentId}`, {
+        method: 'DELETE',
       });
+    } catch (error) {
+      console.error('Failed to delete issue comment:', error);
+      throw new APIError('Failed to delete note', error.status || 500, API_NAME);
     }
-  } catch (error) {
-    console.warn('Failed to reopen notes issue on unpublish:', error);
   }
-}
 
   /**
- * Get all notes for an entry (works for all entries)
- */
-async getEntryNotes(collectionName: string, slug: string): Promise<Note[]> {
-  try {
-    const issue = await this.getOrCreateEntryIssue(collectionName, slug);
-    const comments = await this.getIssueComments(issue.number);
-    return comments.map(comment => this.parseCommentToNote(comment));
-  } catch (error) {
-    console.error('Failed to get entry notes:', error);
-    return [];
-  }
-}
+   * Close the notes issue when an entry is published
+   */
+  async closeIssueOnPublish(collectionName: string, slug: string): Promise<void> {
+    try {
+      const searchQuery = `repo:${this.repo} label:${API.NOTES_LABEL} "${collectionName}/${slug}" in:body state:open`;
+      const searchResponse = await this.request('/search/issues', {
+        params: { q: searchQuery },
+      });
 
-/**
- * Add a note to any entry
- */
-async addNoteToEntry(
-  collectionName: string,
-  slug: string,
-  note: Note,
-  entryTitle?: string
-): Promise<string> {
-  try {
-    const issue = await this.getOrCreateEntryIssue(collectionName, slug, entryTitle);
-    const issueNoteId = await this.createIssueComment(issue.number, note);
-    return issueNoteId;
-  } catch (error) {
-    console.error('Failed to add note to entry:', error);
-    throw new APIError('Failed to create note', error.status || 500, API_NAME);
+      if (searchResponse.items && searchResponse.items.length > 0) {
+        const issue = searchResponse.items[0];
+        await this.request(`${this.repoURL}/issues/${issue.number}`, {
+          method: 'PATCH',
+          body: JSON.stringify({
+            state: 'closed',
+            labels: [
+              ...(issue.labels || []).map((l: { name: string }) => l.name),
+              'entry-published',
+            ],
+          }),
+        });
+      }
+    } catch (error) {
+      console.warn('Failed to close notes issue on publish:', error);
+    }
   }
-}
 
-async updateEntryNote(noteId: string, note: Note): Promise<void> {
-  try {
-    await this.updateIssueComment(noteId, note);
-  } catch (error) {
-    console.error('Failed to update entry note:', error);
-    throw new APIError('Failed to update note', error.status || 500, API_NAME);
+  /**
+   * Reopen the notes issue when an entry is unpublished
+   */
+  async reopenIssueOnUnpublish(collectionName: string, slug: string): Promise<void> {
+    try {
+      const searchQuery = `repo:${this.repo} label:${API.NOTES_LABEL} "${collectionName}/${slug}" in:body`;
+      const searchResponse = await this.request('/search/issues', {
+        params: { q: searchQuery },
+      });
+
+      if (searchResponse.items && searchResponse.items.length > 0) {
+        const issue = searchResponse.items[0];
+        // Remove 'entry-published' or 'entry-deleted' labels and reopen
+        const updatedLabels = (issue.labels || [])
+          .map((l: { name: string }) => l.name)
+          .filter((name: string) => name !== 'entry-published' && name !== 'entry-deleted');
+
+        await this.request(`${this.repoURL}/issues/${issue.number}`, {
+          method: 'PATCH',
+          body: JSON.stringify({
+            state: 'open',
+            labels: updatedLabels,
+          }),
+        });
+      }
+    } catch (error) {
+      console.warn('Failed to reopen notes issue on unpublish:', error);
+    }
   }
-}
 
-async deleteEntryNote(noteId: string): Promise<void> {
-  try {
-    await this.deleteIssueComment(noteId);
-  } catch (error) {
-    console.error('Failed to delete entry note:', error);
-    throw new APIError('Failed to delete note', error.status || 500, API_NAME);
+  /**
+   * Get all notes for an entry (works for all entries)
+   */
+  async getEntryNotes(collectionName: string, slug: string): Promise<Note[]> {
+    try {
+      const issue = await this.getOrCreateEntryIssue(collectionName, slug);
+      const comments = await this.getIssueComments(issue.number);
+      return comments.map(comment => this.parseCommentToNote(comment));
+    } catch (error) {
+      console.error('Failed to get entry notes:', error);
+      return [];
+    }
   }
-}
 
-/**
- * Get all entries that have notes (useful for showing notes indicator in UI)
- */
-async getEntriesWithNotes(): Promise<Array<{ collection: string; slug: string; noteCount: number }>> {
-  try {
-    const searchQuery = `repo:${this.repo} label:${API.NOTES_LABEL} state:open`;
-    const searchResponse = await this.request('/search/issues', {
-      params: { q: searchQuery, per_page: 100 }
-    });
+  /**
+   * Add a note to any entry
+   */
+  async addNoteToEntry(
+    collectionName: string,
+    slug: string,
+    note: Note,
+    entryTitle?: string,
+  ): Promise<string> {
+    try {
+      const issue = await this.getOrCreateEntryIssue(collectionName, slug, entryTitle);
+      const issueNoteId = await this.createIssueComment(issue.number, note);
+      return issueNoteId;
+    } catch (error) {
+      console.error('Failed to add note to entry:', error);
+      throw new APIError('Failed to create note', error.status || 500, API_NAME);
+    }
+  }
 
-    const entriesWithNotes = [];
-
-    for (const issue of searchResponse.items || []) {
-      // Extract collection/slug from issue body
-      const match = issue.body.match(/entry: `(.+)\/(.+)`/);
-      if (match) {
-        const [, collection, slug] = match;
-        entriesWithNotes.push({
-          collection,
-          slug,
-          noteCount: issue.comments
-        });
-      }
+  async updateEntryNote(noteId: string, note: Note): Promise<void> {
+    try {
+      await this.updateIssueComment(noteId, note);
+    } catch (error) {
+      console.error('Failed to update entry note:', error);
+      throw new APIError('Failed to update note', error.status || 500, API_NAME);
     }
+  }
 
-    return entriesWithNotes;
-  } catch (error) {
-    console.error('Failed to get entries with notes:', error);
-    return [];
+  async deleteEntryNote(noteId: string): Promise<void> {
+    try {
+      await this.deleteIssueComment(noteId);
+    } catch (error) {
+      console.error('Failed to delete entry note:', error);
+      throw new APIError('Failed to delete note', error.status || 500, API_NAME);
+    }
   }
-}
 
-/**
- * Close notes issue when entry is deleted
- */
-async closeEntryNotesIssue(collectionName: string, slug: string): Promise<void> {
-  try {
-    const searchQuery = `repo:${this.repo} label:${API.NOTES_LABEL} "${collectionName}/${slug}" in:body state:open`;
-    const searchResponse = await this.request('/search/issues', {
-      params: { q: searchQuery }
-    });
+  /**
+   * Get all entries that have notes (useful for showing notes indicator in UI)
+   */
+  async getEntriesWithNotes(): Promise<
+    Array<{ collection: string; slug: string; noteCount: number }>
+  > {
+    try {
+      const searchQuery = `repo:${this.repo} label:${API.NOTES_LABEL} state:open`;
+      const searchResponse = await this.request('/search/issues', {
+        params: { q: searchQuery, per_page: 100 },
+      });
 
-    if (searchResponse.items && searchResponse.items.length > 0) {
-      const issue = searchResponse.items[0];
-      await this.request(`${this.repoURL}/issues/${issue.number}`, {
-        method: 'PATCH',
-        body: JSON.stringify({
-          state: 'closed',
-          labels: [...(issue.labels || []).map((l: { name: string }) => l.name), 'entry-deleted']
-        })
+      const entriesWithNotes = [];
+
+      for (const issue of searchResponse.items || []) {
+        // Extract collection/slug from issue body
+        const match = issue.body.match(/entry: `(.+)\/(.+)`/);
+        if (match) {
+          const [, collection, slug] = match;
+          entriesWithNotes.push({
+            collection,
+            slug,
+            noteCount: issue.comments,
+          });
+        }
+      }
+
+      return entriesWithNotes;
+    } catch (error) {
+      console.error('Failed to get entries with notes:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Close notes issue when entry is deleted
+   */
+  async closeEntryNotesIssue(collectionName: string, slug: string): Promise<void> {
+    try {
+      const searchQuery = `repo:${this.repo} label:${API.NOTES_LABEL} "${collectionName}/${slug}" in:body state:open`;
+      const searchResponse = await this.request('/search/issues', {
+        params: { q: searchQuery },
       });
+
+      if (searchResponse.items && searchResponse.items.length > 0) {
+        const issue = searchResponse.items[0];
+        await this.request(`${this.repoURL}/issues/${issue.number}`, {
+          method: 'PATCH',
+          body: JSON.stringify({
+            state: 'closed',
+            labels: [...(issue.labels || []).map((l: { name: string }) => l.name), 'entry-deleted'],
+          }),
+        });
+      }
+    } catch (error) {
+      console.warn('Failed to close notes issue:', error);
     }
-  } catch (error) {
-    console.warn('Failed to close notes issue:', error);
   }
-}
 
   /**
    * Get PR metadata from branch name
diff --git a/packages/decap-cms-backend-github/src/implementation.tsx b/packages/decap-cms-backend-github/src/implementation.tsx
index 78da66adbc9d..b3899ad2805d 100644
--- a/packages/decap-cms-backend-github/src/implementation.tsx
+++ b/packages/decap-cms-backend-github/src/implementation.tsx
@@ -701,28 +701,29 @@ export default class GitHub implements Implementation {
   }
 
   deleteUnpublishedEntry(collection: string, slug: string) {
-  // deleteUnpublishedEntry is a transactional operation
-  return runWithLock(
-    this.lock,
-    async () => {
-      await this.api!.deleteUnpublishedEntry(collection, slug);
-      // Clean up associated notes issue
-      try {
-        await this.api!.closeEntryNotesIssue(collection, slug);
-      } catch (error) {
-        console.warn('Failed to close notes issue during entry deletion:', error);
-      }
-    },
-    'Failed to acquire delete entry lock',
-  );
-}
+    // deleteUnpublishedEntry is a transactional operation
+    return runWithLock(
+      this.lock,
+      async () => {
+        await this.api!.deleteUnpublishedEntry(collection, slug);
+        // Clean up associated notes issue
+        try {
+          await this.api!.closeEntryNotesIssue(collection, slug);
+        } catch (error) {
+          console.warn('Failed to close notes issue during entry deletion:', error);
+        }
+      },
+      'Failed to acquire delete entry lock',
+    );
+  }
 
   publishUnpublishedEntry(collection: string, slug: string) {
     // publishUnpublishedEntry is a transactional operation
     return runWithLock(
       this.lock,
-      async () =>{ this.api!.publishUnpublishedEntry(collection, slug),
-        await this.api!.closeIssueOnPublish(collection, slug);
+      async () => {
+        this.api!.publishUnpublishedEntry(collection, slug),
+          await this.api!.closeIssueOnPublish(collection, slug);
       },
       'Failed to acquire publish entry lock',
     );
@@ -730,91 +731,90 @@ export default class GitHub implements Implementation {
 
   // Notes implementation, which is an abstraction to Github's PR issue comments.
 
-// Notes implementation using GitHub Issues
-async getNotes(collection: string, slug: string): Promise<Note[]> {
-  try {
-    const notes = await this.api!.getEntryNotes(collection, slug);
-    return notes.map(note => ({ ...note, entrySlug: slug }));
-  } catch (error) {
-    console.error('Failed to get notes:', error);
-    return [];
+  // Notes implementation using GitHub Issues
+  async getNotes(collection: string, slug: string): Promise<Note[]> {
+    try {
+      const notes = await this.api!.getEntryNotes(collection, slug);
+      return notes.map(note => ({ ...note, entrySlug: slug }));
+    } catch (error) {
+      console.error('Failed to get notes:', error);
+      return [];
+    }
   }
-}
 
-async addNote(collection: string, slug: string, noteData: Omit<Note, 'id'>): Promise<Note> {
-  const currentUser = await this.currentUser({ token: this.token! });
-  const note: Note = {
-    ...noteData,
-    id: 'temp-' + Date.now(),
-    author: currentUser.login || currentUser.name,
-    avatarUrl: currentUser.avatar_url,
-    entrySlug: slug,
-    timestamp: noteData.timestamp || new Date().toISOString(),
-    resolved: noteData.resolved || false,
-  };
+  async addNote(collection: string, slug: string, noteData: Omit<Note, 'id'>): Promise<Note> {
+    const currentUser = await this.currentUser({ token: this.token! });
+    const note: Note = {
+      ...noteData,
+      id: 'temp-' + Date.now(),
+      author: currentUser.login || currentUser.name,
+      avatarUrl: currentUser.avatar_url,
+      entrySlug: slug,
+      timestamp: noteData.timestamp || new Date().toISOString(),
+      resolved: noteData.resolved || false,
+    };
 
-  // Get entry title for better issue naming
-  let entryTitle: string | undefined;
-  try {
-    const entryData = await this.getEntry(`${collection}/${slug}.md`); // Adjust path as needed
-    // Extract title from frontmatter if available
-    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
-  }
+    // Get entry title for better issue naming
+    let entryTitle: string | undefined;
+    try {
+      const entryData = await this.getEntry(`${collection}/${slug}.md`); // Adjust path as needed
+      // Extract title from frontmatter if available
+      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 = await this.api!.addNoteToEntry(collection, slug, note, entryTitle);
-  return { ...note, id: commentId };
-}
+    const commentId = await this.api!.addNoteToEntry(collection, slug, note, entryTitle);
+    return { ...note, id: commentId };
+  }
 
-async updateNote(
-  collection: string,
-  slug: string,
-  noteId: string,
-  updates: Partial<Note>,
-): Promise<Note> {
-  const currentNotes = await this.getNotes(collection, slug);
-  const existingNote = currentNotes.find(note => note.id === noteId);
-  if (!existingNote) {
-    throw new Error(`Note with ID ${noteId} not found`);
-  }
-
-  const updatedNote: Note = {
-    ...existingNote,
-    ...updates,
-    id: noteId,
-    entrySlug: slug,
-  };
+  async updateNote(
+    collection: string,
+    slug: string,
+    noteId: string,
+    updates: Partial<Note>,
+  ): Promise<Note> {
+    const currentNotes = await this.getNotes(collection, slug);
+    const existingNote = currentNotes.find(note => note.id === noteId);
+    if (!existingNote) {
+      throw new Error(`Note with ID ${noteId} not found`);
+    }
 
-  await this.api!.updateEntryNote(noteId, updatedNote);
-  return updatedNote;
-}
+    const updatedNote: Note = {
+      ...existingNote,
+      ...updates,
+      id: noteId,
+      entrySlug: slug,
+    };
 
-async deleteNote(collection: string, slug: string, noteId: string): Promise<void> {
-  const currentNotes = await this.getNotes(collection, slug);
-  const noteExists = currentNotes.some(note => note.id === noteId);
-  if (!noteExists) {
-    throw new Error(`Note with ID ${noteId} not found`);
+    await this.api!.updateEntryNote(noteId, updatedNote);
+    return updatedNote;
   }
 
-  await this.api!.deleteEntryNote(noteId);
-
-}
+  async deleteNote(collection: string, slug: string, noteId: string): Promise<void> {
+    const currentNotes = await this.getNotes(collection, slug);
+    const noteExists = currentNotes.some(note => note.id === noteId);
+    if (!noteExists) {
+      throw new Error(`Note with ID ${noteId} not found`);
+    }
 
-async toggleNoteResolution(collection: string, slug: string, noteId: string): Promise<Note> {
-  const currentNotes = await this.getNotes(collection, slug);
-  const note = currentNotes.find(n => n.id === noteId);
-  if (!note) {
-    throw new Error(`Note with ID ${noteId} not found`);
+    await this.api!.deleteEntryNote(noteId);
   }
 
-  return this.updateNote(collection, slug, noteId, {
-    resolved: !note.resolved,
-  });
-}
+  async toggleNoteResolution(collection: string, slug: string, noteId: string): Promise<Note> {
+    const currentNotes = await this.getNotes(collection, slug);
+    const note = currentNotes.find(n => n.id === noteId);
+    if (!note) {
+      throw new Error(`Note with ID ${noteId} not found`);
+    }
 
-async reopenIssueForUnpublishedEntry(collection: string, slug: string) {
-  await this.api!.reopenIssueOnUnpublish(collection, slug);
-}
+    return this.updateNote(collection, slug, noteId, {
+      resolved: !note.resolved,
+    });
+  }
+
+  async reopenIssueForUnpublishedEntry(collection: string, slug: string) {
+    await this.api!.reopenIssueOnUnpublish(collection, slug);
+  }
 }
diff --git a/packages/decap-cms-core/src/actions/config.ts b/packages/decap-cms-core/src/actions/config.ts
index ddd4c445d169..cb7f7b08bb68 100644
--- a/packages/decap-cms-core/src/actions/config.ts
+++ b/packages/decap-cms-core/src/actions/config.ts
@@ -210,7 +210,7 @@ export function applyDefaults(originalConfig: CmsConfig) {
   return produce(originalConfig, config => {
     config.publish_mode = config.publish_mode || SIMPLE_PUBLISH_MODE;
     config.slug = config.slug || {};
-    config.collections = config.collections || []
+    config.collections = config.collections || [];
 
     if (!config.editor) {
       config.editor = {};
@@ -221,7 +221,7 @@ export function applyDefaults(originalConfig: CmsConfig) {
     }
     if (!('notes' in config.editor)) {
       config.editor.notes = false;
-    };
+    }
 
     // Use `site_url` as default `display_url`.
     if (!config.display_url && config.site_url) {
@@ -370,7 +370,7 @@ export function applyDefaults(originalConfig: CmsConfig) {
       if (config.editor && !collection.editor) {
         collection.editor = {
           preview: config.editor.preview,
-          notes: config.editor.notes
+          notes: config.editor.notes,
         };
       }
     }
diff --git a/packages/decap-cms-core/src/backend.ts b/packages/decap-cms-core/src/backend.ts
index b4fc89e337f3..64bdca7c004b 100644
--- a/packages/decap-cms-core/src/backend.ts
+++ b/packages/decap-cms-core/src/backend.ts
@@ -631,12 +631,12 @@ export class Backend {
   }
 
   reopenIssueForUnpublishedEntry(collection: string, slug: string) {
-  if (typeof this.implementation.reopenIssueForUnpublishedEntry === 'function') {
-    return this.implementation.reopenIssueForUnpublishedEntry(collection, slug);
+    if (typeof this.implementation.reopenIssueForUnpublishedEntry === 'function') {
+      return this.implementation.reopenIssueForUnpublishedEntry(collection, slug);
+    }
+    // If backend doesn't support this, silently skip
+    return Promise.resolve();
   }
-  // If backend doesn't support this, silently skip
-  return Promise.resolve();
-}
 
   async getPRMetadata(
     collection: string,
diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js
index c3efc93fcb85..0338ffcbba5f 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js
@@ -113,7 +113,7 @@ class AddNoteForm extends Component {
     if (!this.state.content.trim()) {
       this.setState({ isFocused: false });
     }
-  }
+  };
 
   render() {
     const { t } = this.props;

From 4b444db946347921c6f705a943c6f40459eb7e8b Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Thu, 25 Sep 2025 15:48:10 -0400
Subject: [PATCH 25/40] chore: added tests for notes on editorialWorkflow specs

---
 .../__tests__/editorialWorkflow.spec.js       | 28 +++----------------
 1 file changed, 4 insertions(+), 24 deletions(-)

diff --git a/packages/decap-cms-core/src/actions/__tests__/editorialWorkflow.spec.js b/packages/decap-cms-core/src/actions/__tests__/editorialWorkflow.spec.js
index b90a4982ed17..1a19e6617355 100644
--- a/packages/decap-cms-core/src/actions/__tests__/editorialWorkflow.spec.js
+++ b/packages/decap-cms-core/src/actions/__tests__/editorialWorkflow.spec.js
@@ -32,7 +32,9 @@ describe('editorialWorkflow actions', () => {
       };
 
       const store = mockStore({
-        config: fromJS({}),
+        config: fromJS({
+          editor: { notes: true },
+        }),
         collections: fromJS({
           posts: { name: 'posts' },
         }),
@@ -107,7 +109,7 @@ describe('editorialWorkflow actions', () => {
 
       return store.dispatch(actions.publishUnpublishedEntry('posts', slug)).then(() => {
         const actions = store.getActions();
-        expect(actions).toHaveLength(11);
+        expect(actions).toHaveLength(8);
 
         expect(actions[0]).toEqual({
           type: 'UNPUBLISHED_ENTRY_PUBLISH_REQUEST',
@@ -164,28 +166,6 @@ describe('editorialWorkflow actions', () => {
             entry,
           },
         });
-
-        expect(actions[8]).toEqual({
-          type: 'NOTES_REQUEST',
-          payload: {
-            collection: 'posts',
-            slug,
-          },
-        });
-        expect(actions[9]).toEqual({
-          type: 'NOTES_SUCCESS',
-          payload: {
-            collection: 'posts',
-            slug,
-            notes: [],
-          },
-        });
-        expect(actions[10]).toEqual({
-          type: 'DRAFT_NOTES_LOAD',
-          payload: {
-            notes: [],
-          },
-        });
       });
     });
 

From a143fde249899a702acba3bc73e390604e2375fd Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Thu, 25 Sep 2025 16:13:06 -0400
Subject: [PATCH 26/40] chore: added tests for Notes Github implementation

---
 .../src/__tests__/implementation.spec.js      | 334 ++++++++++++++++++
 1 file changed, 334 insertions(+)

diff --git a/packages/decap-cms-backend-github/src/__tests__/implementation.spec.js b/packages/decap-cms-backend-github/src/__tests__/implementation.spec.js
index 85e649966f81..b05ea60baab4 100644
--- a/packages/decap-cms-backend-github/src/__tests__/implementation.spec.js
+++ b/packages/decap-cms-backend-github/src/__tests__/implementation.spec.js
@@ -13,6 +13,17 @@ describe('github backend implementation', () => {
     },
   };
 
+  const configWithNotes = {
+    backend: {
+      repo: 'owner/repo',
+      open_authoring: false,
+      api_root: 'https://api.github.com',
+    },
+    editor: {
+      notes: true,
+    },
+  };
+
   const createObjectURL = jest.fn();
   global.URL = {
     createObjectURL,
@@ -358,4 +369,327 @@ describe('github backend implementation', () => {
       });
     });
   });
+  describe('notes implementation', () => {
+    const mockAPI = {
+      getEntryNotes: jest.fn(),
+      addNoteToEntry: jest.fn(),
+      updateEntryNote: jest.fn(),
+      deleteEntryNote: jest.fn(),
+      closeEntryNotesIssue: jest.fn(),
+      closeIssueOnPublish: jest.fn(),
+      reopenIssueOnUnpublish: jest.fn(),
+      readFile: jest.fn(),
+      deleteUnpublishedEntry: jest.fn().mockResolvedValue(undefined),
+      publishUnpublishedEntry: jest.fn().mockResolvedValue(undefined),
+    };
+
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    describe('getNotes', () => {
+      it('should retrieve notes for an entry', async () => {
+        const gitHubImplementation = new GitHubImplementation(configWithNotes);
+        gitHubImplementation.api = mockAPI;
+
+        const mockNotes = [
+          {
+            id: '1',
+            author: 'user1',
+            avatarUrl: 'https://avatar.url',
+            text: 'Test note',
+            timestamp: '2025-01-01T00:00:00Z',
+            resolved: false,
+          },
+        ];
+
+        mockAPI.getEntryNotes.mockResolvedValue(mockNotes);
+
+        const result = await gitHubImplementation.getNotes('posts', 'my-post');
+
+        expect(result).toEqual([
+          {
+            ...mockNotes[0],
+            entrySlug: 'my-post',
+          },
+        ]);
+        expect(mockAPI.getEntryNotes).toHaveBeenCalledWith('posts', 'my-post');
+      });
+
+      it('should return empty array on error', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI;
+
+        mockAPI.getEntryNotes.mockRejectedValue(new Error('API Error'));
+
+        const result = await gitHubImplementation.getNotes('posts', 'my-post');
+
+        expect(result).toEqual([]);
+        expect(console.error).toHaveBeenCalledWith('Failed to get notes:', expect.any(Error));
+      });
+    });
+
+    describe('addNote', () => {
+      it('should add a note to an entry', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI;
+        gitHubImplementation.token = 'test-token';
+        gitHubImplementation.currentUser = jest.fn().mockResolvedValue({
+          login: 'testuser',
+          name: 'Test User',
+          avatar_url: 'https://avatar.url',
+        });
+
+        const noteData = {
+          text: 'New note',
+          timestamp: '2025-01-01T00:00:00Z',
+          resolved: false,
+        };
+
+        mockAPI.addNoteToEntry.mockResolvedValue('comment-123');
+        mockAPI.readFile.mockResolvedValue('title: My Post Title\n\nContent');
+
+        const result = await gitHubImplementation.addNote('posts', 'my-post', noteData);
+
+        expect(result).toMatchObject({
+          text: 'New note',
+          author: 'testuser',
+          avatarUrl: 'https://avatar.url',
+          entrySlug: 'my-post',
+          resolved: false,
+          id: 'comment-123',
+        });
+        expect(mockAPI.addNoteToEntry).toHaveBeenCalledWith(
+          'posts',
+          'my-post',
+          expect.objectContaining({
+            text: 'New note',
+            author: 'testuser',
+          }),
+          'My Post Title',
+        );
+      });
+
+      it('should handle missing entry title gracefully', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI;
+        gitHubImplementation.token = 'test-token';
+        gitHubImplementation.currentUser = jest.fn().mockResolvedValue({
+          login: 'testuser',
+          avatar_url: 'https://avatar.url',
+        });
+
+        const noteData = {
+          text: 'New note',
+          timestamp: '2025-01-01T00:00:00Z',
+        };
+
+        mockAPI.addNoteToEntry.mockResolvedValue('comment-123');
+        mockAPI.readFile.mockRejectedValue(new Error('Not found'));
+
+        const result = await gitHubImplementation.addNote('posts', 'my-post', noteData);
+
+        expect(mockAPI.addNoteToEntry).toHaveBeenCalledWith(
+          'posts',
+          'my-post',
+          expect.any(Object),
+          undefined,
+        );
+        expect(result.id).toBe('comment-123');
+      });
+    });
+
+    describe('updateNote', () => {
+      it('should update an existing note', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI;
+
+        const existingNotes = [
+          {
+            id: 'note-1',
+            author: 'user1',
+            avatarUrl: 'https://avatar.url',
+            text: 'Original text',
+            timestamp: '2025-01-01T00:00:00Z',
+            resolved: false,
+            entrySlug: 'my-post',
+          },
+        ];
+
+        mockAPI.getEntryNotes.mockResolvedValue(existingNotes);
+        mockAPI.updateEntryNote.mockResolvedValue(undefined);
+
+        const updates = { text: 'Updated text', resolved: true };
+        const result = await gitHubImplementation.updateNote('posts', 'my-post', 'note-1', updates);
+
+        expect(result).toEqual({
+          ...existingNotes[0],
+          text: 'Updated text',
+          resolved: true,
+        });
+        expect(mockAPI.updateEntryNote).toHaveBeenCalledWith('note-1', result);
+      });
+
+      it('should throw error if note not found', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI;
+
+        mockAPI.getEntryNotes.mockResolvedValue([]);
+
+        await expect(
+          gitHubImplementation.updateNote('posts', 'my-post', 'non-existent', {}),
+        ).rejects.toThrow('Note with ID non-existent not found');
+      });
+    });
+
+    describe('deleteNote', () => {
+      it('should delete an existing note', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI;
+
+        const existingNotes = [
+          {
+            id: 'note-1',
+            author: 'user1',
+            text: 'Test note',
+            entrySlug: 'my-post',
+          },
+        ];
+
+        mockAPI.getEntryNotes.mockResolvedValue(existingNotes);
+        mockAPI.deleteEntryNote.mockResolvedValue(undefined);
+
+        await gitHubImplementation.deleteNote('posts', 'my-post', 'note-1');
+
+        expect(mockAPI.deleteEntryNote).toHaveBeenCalledWith('note-1');
+      });
+
+      it('should throw error if note not found', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI;
+
+        mockAPI.getEntryNotes.mockResolvedValue([]);
+
+        await expect(
+          gitHubImplementation.deleteNote('posts', 'my-post', 'non-existent'),
+        ).rejects.toThrow('Note with ID non-existent not found');
+      });
+    });
+
+    describe('toggleNoteResolution', () => {
+      it('should toggle note resolved status from false to true', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI;
+
+        const existingNotes = [
+          {
+            id: 'note-1',
+            author: 'user1',
+            avatarUrl: 'https://avatar.url',
+            text: 'Test note',
+            timestamp: '2025-01-01T00:00:00Z',
+            resolved: false,
+            entrySlug: 'my-post',
+          },
+        ];
+
+        mockAPI.getEntryNotes.mockResolvedValue(existingNotes);
+        mockAPI.updateEntryNote.mockResolvedValue(undefined);
+
+        const result = await gitHubImplementation.toggleNoteResolution(
+          'posts',
+          'my-post',
+          'note-1',
+        );
+
+        expect(result.resolved).toBe(true);
+        expect(mockAPI.updateEntryNote).toHaveBeenCalledWith(
+          'note-1',
+          expect.objectContaining({ resolved: true }),
+        );
+      });
+
+      it('should toggle note resolved status from true to false', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI;
+
+        const existingNotes = [
+          {
+            id: 'note-1',
+            resolved: true,
+            entrySlug: 'my-post',
+          },
+        ];
+
+        mockAPI.getEntryNotes.mockResolvedValue(existingNotes);
+        mockAPI.updateEntryNote.mockResolvedValue(undefined);
+
+        const result = await gitHubImplementation.toggleNoteResolution(
+          'posts',
+          'my-post',
+          'note-1',
+        );
+
+        expect(result.resolved).toBe(false);
+      });
+
+      it('should throw error if note not found', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI;
+
+        mockAPI.getEntryNotes.mockResolvedValue([]);
+
+        await expect(
+          gitHubImplementation.toggleNoteResolution('posts', 'my-post', 'non-existent'),
+        ).rejects.toThrow('Note with ID non-existent not found');
+      });
+    });
+
+    describe('reopenIssueForUnpublishedEntry', () => {
+      it('should reopen issue for unpublished entry', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI;
+
+        mockAPI.reopenIssueOnUnpublish.mockResolvedValue(undefined);
+
+        await gitHubImplementation.reopenIssueForUnpublishedEntry('posts', 'my-post');
+
+        expect(mockAPI.reopenIssueOnUnpublish).toHaveBeenCalledWith('posts', 'my-post');
+      });
+    });
+
+    describe('deleteUnpublishedEntry with notes cleanup', () => {
+      it('should delete entry and close associated notes issue', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI; // Just use mockAPI directly
+
+        await gitHubImplementation.deleteUnpublishedEntry('posts', 'my-post');
+
+        expect(mockAPI.deleteUnpublishedEntry).toHaveBeenCalledWith('posts', 'my-post');
+        expect(mockAPI.closeEntryNotesIssue).toHaveBeenCalledWith('posts', 'my-post');
+      });
+
+      it('should continue deletion even if closing issue fails', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI;
+        mockAPI.closeEntryNotesIssue.mockRejectedValue(new Error('Issue close failed'));
+
+        await gitHubImplementation.deleteUnpublishedEntry('posts', 'my-post');
+
+        expect(mockAPI.deleteUnpublishedEntry).toHaveBeenCalledWith('posts', 'my-post');
+      });
+    });
+
+    describe('publishUnpublishedEntry with issue cleanup', () => {
+      it('should publish entry and close issue', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI;
+
+        await gitHubImplementation.publishUnpublishedEntry('posts', 'my-post');
+
+        expect(mockAPI.publishUnpublishedEntry).toHaveBeenCalledWith('posts', 'my-post');
+        expect(mockAPI.closeIssueOnPublish).toHaveBeenCalledWith('posts', 'my-post');
+      });
+    });
+  });
 });

From 28ed3d2acdfc84de1153a146940eb60bef51a3ad Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Thu, 25 Sep 2025 16:34:17 -0400
Subject: [PATCH 27/40] chore: updated config specification test to account for
 the editor.notes option

---
 .../src/actions/__tests__/config.spec.js      | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/packages/decap-cms-core/src/actions/__tests__/config.spec.js b/packages/decap-cms-core/src/actions/__tests__/config.spec.js
index 1892729b2949..3bec8f4b3a22 100644
--- a/packages/decap-cms-core/src/actions/__tests__/config.spec.js
+++ b/packages/decap-cms-core/src/actions/__tests__/config.spec.js
@@ -406,6 +406,7 @@ describe('config', () => {
         it('should set editor preview honoring global config before and specific config after', () => {
           const config = applyDefaults({
             editor: {
+              notes: false,
               preview: false,
             },
             collections: [
@@ -415,6 +416,7 @@ describe('config', () => {
               },
               {
                 editor: {
+                  notes: false,
                   preview: true,
                 },
                 fields: [{ name: 'title' }],
@@ -486,6 +488,10 @@ describe('config', () => {
             view_filters: [],
             view_groups: [],
             identifier_field: 'datetime',
+            editor: {
+              notes: false,
+              preview: true,
+            },
             fields: [
               {
                 name: 'datetime',
@@ -507,6 +513,10 @@ describe('config', () => {
           },
           {
             sortable_fields: [],
+            editor: {
+              notes: false,
+              preview: true,
+            },
             files: [
               {
                 name: 'file',
@@ -537,6 +547,10 @@ describe('config', () => {
             publish: true,
           },
         ],
+        editor: {
+          notes: false,
+          preview: true,
+        },
         public_folder: '/',
         publish_mode: 'simple',
         slug: { clean_accents: false, encoding: 'unicode', sanitize_replacement: '-' },
@@ -947,6 +961,10 @@ describe('config', () => {
       expect(dispatch).toHaveBeenCalledWith({
         type: 'CONFIG_SUCCESS',
         payload: {
+          editor: {
+            notes: false,
+            preview: true,
+          },
           backend: { repo: 'test-repo' },
           collections: [],
           publish_mode: 'simple',
@@ -981,6 +999,10 @@ describe('config', () => {
         type: 'CONFIG_SUCCESS',
         payload: {
           backend: { repo: 'github' },
+          editor: {
+            notes: false,
+            preview: true,
+          },
           collections: [],
           publish_mode: 'simple',
           slug: { encoding: 'unicode', clean_accents: false, sanitize_replacement: '-' },

From b6d5fc52c9d1834ced75793e9af93376010ba8c3 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Thu, 23 Oct 2025 20:56:29 +0100
Subject: [PATCH 28/40] fix: github issues are only created after the first
 note is added

---
 packages/decap-cms-backend-github/src/API.ts | 72 +++++++++++---------
 1 file changed, 38 insertions(+), 34 deletions(-)

diff --git a/packages/decap-cms-backend-github/src/API.ts b/packages/decap-cms-backend-github/src/API.ts
index 2a50e3d057ce..215cd2b14f07 100644
--- a/packages/decap-cms-backend-github/src/API.ts
+++ b/packages/decap-cms-backend-github/src/API.ts
@@ -1570,32 +1570,30 @@ ${note.content}`;
   }
 
   /**
-   * Find existing issue for an entry or create a new one
-   */
-  async getOrCreateEntryIssue(
-    collectionName: string,
-    slug: string,
-    entryTitle?: string,
-  ): Promise<GitHubIssue> {
-    // Search for existing issue
-    const searchQuery = `repo:${this.repo} label:${API.NOTES_LABEL} "${collectionName}/${slug}" in:body`;
+     * Find existing issue for an entry (returns null if not found)
+     */
+    async findEntryIssue(
+      collectionName: string,
+      slug: string,
+    ): Promise<GitHubIssue | null> {
+      // Search for existing issue
+      const searchQuery = `repo:${this.repo} label:${API.NOTES_LABEL} "${collectionName}/${slug}" in:body`;
 
-    try {
-      const searchResponse = await this.request('/search/issues', {
-        params: { q: searchQuery },
-      });
+      try {
+        const searchResponse = await this.request('/search/issues', {
+          params: { q: searchQuery },
+        });
 
-      if (searchResponse.items && searchResponse.items.length > 0) {
-        return searchResponse.items[0];
+        if (searchResponse.items && searchResponse.items.length > 0) {
+          return searchResponse.items[0];
+        }
+        return null;
+      } catch (error) {
+        console.warn('Failed to search for existing notes issue:', error);
+        return null;
       }
-    } catch (error) {
-      console.warn('Failed to search for existing notes issue:', error);
     }
 
-    // Create new issue if none exists
-    return this.createEntryIssue(collectionName, slug, entryTitle);
-  }
-
   /**
    * Get comments from a GitHub issue
    */
@@ -1722,19 +1720,22 @@ ${note.content}`;
     }
   }
 
-  /**
-   * Get all notes for an entry (works for all entries)
-   */
-  async getEntryNotes(collectionName: string, slug: string): Promise<Note[]> {
-    try {
-      const issue = await this.getOrCreateEntryIssue(collectionName, slug);
-      const comments = await this.getIssueComments(issue.number);
-      return comments.map(comment => this.parseCommentToNote(comment));
-    } catch (error) {
-      console.error('Failed to get entry notes:', error);
-      return [];
+    /**
+     * Get all notes for an entry 
+     */
+    async getEntryNotes(collectionName: string, slug: string): Promise<Note[]> {
+      try {
+        const issue = await this.findEntryIssue(collectionName, slug);
+        if (!issue) {
+          return []; // No issue means no notes yet
+        }
+        const comments = await this.getIssueComments(issue.number);
+        return comments.map(comment => this.parseCommentToNote(comment));
+      } catch (error) {
+        console.error('Failed to get entry notes:', error);
+        return [];
+      }
     }
-  }
 
   /**
    * Add a note to any entry
@@ -1746,7 +1747,10 @@ ${note.content}`;
     entryTitle?: string,
   ): Promise<string> {
     try {
-      const issue = await this.getOrCreateEntryIssue(collectionName, slug, entryTitle);
+      let issue = await this.findEntryIssue(collectionName, slug);
+      if (!issue) {
+        issue = await this.createEntryIssue(collectionName, slug, entryTitle);
+      }
       const issueNoteId = await this.createIssueComment(issue.number, note);
       return issueNoteId;
     } catch (error) {

From ef8772ceeb75aeafe2da82b26a4ec24f39075502 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Thu, 23 Oct 2025 21:21:47 +0100
Subject: [PATCH 29/40] fix: notes now show dates in absolute time

---
 .../components/Editor/EditorNotesPane/NoteItem.js | 15 ++-------------
 1 file changed, 2 insertions(+), 13 deletions(-)

diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js
index 3991fb9be341..286cc76477d2 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js
@@ -167,19 +167,8 @@ class NoteItem extends Component {
 
   formatTimestamp = timestamp => {
     const date = new Date(timestamp);
-    const now = new Date();
-    const diffMs = now - date;
-    const diffMins = Math.floor(diffMs / 60000);
-    const diffHours = Math.floor(diffMs / 3600000);
-    const diffDays = Math.floor(diffMs / 86400000);
-
-    if (diffMins < 1) return 'just now';
-    if (diffMins < 60) return `${diffMins}m ago`;
-    if (diffHours < 24) return `${diffHours}h ago`;
-    if (diffDays < 7) return `${diffDays}d ago`;
-
-    return date.toLocaleDateString();
-  };
+    return date.toLocaleString(); 
+};
 
   handleEditStart = () => {
     this.setState({

From 35eaa4fa1f4bd98cb612fd2f10b57fc8fe3cbd25 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Thu, 23 Oct 2025 22:20:34 +0100
Subject: [PATCH 30/40] style: increased padding of NoteList, NoteItem and
 AddNoteForm

---
 .../Editor/EditorNotesPane/AddNoteForm.js          |  2 +-
 .../components/Editor/EditorNotesPane/NoteItem.js  | 14 ++++++++++----
 .../components/Editor/EditorNotesPane/NotesList.js |  2 +-
 3 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js
index 0338ffcbba5f..108a510e1923 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/AddNoteForm.js
@@ -4,7 +4,7 @@ import styled from '@emotion/styled';
 import { colors, transitions } from 'decap-cms-ui-default';
 
 const FormContainer = styled.div`
-  padding: 16px;
+  padding: 16px 28px;
   border-top: 1px solid ${colors.textFieldBorder};
   background-color: ${colors.inputBackground};
 `;
diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js
index 286cc76477d2..e48145727749 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js
@@ -9,7 +9,7 @@ const NoteCard = styled.div`
   border: 1px solid ${props => (props.resolved ? colors.textFieldBorder : colors.textFieldBorder)};
   border-radius: 4px;
   margin-bottom: 8px;
-  padding: 12px;
+  padding: 12px 18px;
   transition: all ${transitions.main};
   opacity: ${props => (props.resolved ? 0.7 : 1)};
 
@@ -166,9 +166,15 @@ class NoteItem extends Component {
   };
 
   formatTimestamp = timestamp => {
-    const date = new Date(timestamp);
-    return date.toLocaleString(); 
-};
+      const date = new Date(timestamp);
+      return date.toLocaleString(undefined, {
+          year: 'numeric',
+          month: 'numeric',
+          day: 'numeric',
+          hour: 'numeric',
+          minute: 'numeric'
+      });
+  };
 
   handleEditStart = () => {
     this.setState({
diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NotesList.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NotesList.js
index 15cfaf2daab0..509d74f43c8e 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NotesList.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NotesList.js
@@ -8,7 +8,7 @@ import NoteItem from './NoteItem';
 const ListContainer = styled.div`
   flex: 1;
   overflow-y: auto;
-  padding: 8px;
+  padding: 8px 30px;
 `;
 
 function NotesList({ notes, onUpdate, onDelete, onToggleResolution, user, t }) {

From f925c434e78f93d75205a471303685554153d549 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Thu, 23 Oct 2025 23:42:03 +0100
Subject: [PATCH 31/40] feat: github notes now have a convenient link to the
 source (github issues)

---
 packages/decap-cms-backend-github/src/API.ts  | 37 +++++----
 .../src/implementation.tsx                    | 14 +++-
 .../Editor/EditorNotesPane/EditorNotesPane.js | 78 +++++++++++++++++--
 .../decap-cms-lib-util/src/implementation.ts  |  1 +
 4 files changed, 104 insertions(+), 26 deletions(-)

diff --git a/packages/decap-cms-backend-github/src/API.ts b/packages/decap-cms-backend-github/src/API.ts
index 215cd2b14f07..27dd2324cafd 100644
--- a/packages/decap-cms-backend-github/src/API.ts
+++ b/packages/decap-cms-backend-github/src/API.ts
@@ -1723,19 +1723,25 @@ ${note.content}`;
     /**
      * Get all notes for an entry 
      */
-    async getEntryNotes(collectionName: string, slug: string): Promise<Note[]> {
-      try {
-        const issue = await this.findEntryIssue(collectionName, slug);
-        if (!issue) {
-          return []; // No issue means no notes yet
-        }
-        const comments = await this.getIssueComments(issue.number);
-        return comments.map(comment => this.parseCommentToNote(comment));
-      } catch (error) {
-        console.error('Failed to get entry notes:', error);
-        return [];
+  async getEntryNotes(collectionName: string, slug: string): Promise<Note[]> {
+    try {
+      const issue = await this.findEntryIssue(collectionName, slug);
+      if (!issue) {
+        return []; // No issue means no notes yet
       }
+      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)
+      }));
+    } catch (error) {
+      console.error('Failed to get entry notes:', error);
+      return [];
     }
+  }
 
   /**
    * Add a note to any entry
@@ -1745,14 +1751,17 @@ ${note.content}`;
     slug: string,
     note: Note,
     entryTitle?: string,
-  ): Promise<string> {
+  ): Promise<{ commentId: string; issueUrl: string }> {
     try {
       let issue = await this.findEntryIssue(collectionName, slug);
       if (!issue) {
         issue = await this.createEntryIssue(collectionName, slug, entryTitle);
       }
-      const issueNoteId = await this.createIssueComment(issue.number, note);
-      return issueNoteId;
+      const commentId = await this.createIssueComment(issue.number, note);
+      return { 
+        commentId, 
+        issueUrl: issue.html_url 
+      };
     } catch (error) {
       console.error('Failed to add note to entry:', error);
       throw new APIError('Failed to create note', error.status || 500, API_NAME);
diff --git a/packages/decap-cms-backend-github/src/implementation.tsx b/packages/decap-cms-backend-github/src/implementation.tsx
index b3899ad2805d..f30866068133 100644
--- a/packages/decap-cms-backend-github/src/implementation.tsx
+++ b/packages/decap-cms-backend-github/src/implementation.tsx
@@ -744,6 +744,7 @@ export default class GitHub implements Implementation {
 
   async addNote(collection: string, slug: string, noteData: Omit<Note, 'id'>): Promise<Note> {
     const currentUser = await this.currentUser({ token: this.token! });
+    
     const note: Note = {
       ...noteData,
       id: 'temp-' + Date.now(),
@@ -752,21 +753,26 @@ export default class GitHub implements Implementation {
       entrySlug: slug,
       timestamp: noteData.timestamp || new Date().toISOString(),
       resolved: noteData.resolved || false,
+      issueUrl: undefined,
     };
 
     // Get entry title for better issue naming
     let entryTitle: string | undefined;
     try {
-      const entryData = await this.getEntry(`${collection}/${slug}.md`); // Adjust path as needed
-      // Extract title from frontmatter if available
+      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 = await this.api!.addNoteToEntry(collection, slug, note, entryTitle);
-    return { ...note, id: commentId };
+    const { commentId, issueUrl } = await this.api!.addNoteToEntry(collection, slug, note, entryTitle);
+    
+    return { 
+      ...note, 
+      id: commentId,
+      issueUrl 
+    };
   }
 
   async updateNote(
diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js
index 69dc967b20ff..b2bcb18dd3fa 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js
@@ -3,7 +3,7 @@ import React, { Component } from 'react';
 import ImmutablePropTypes from 'react-immutable-proptypes';
 import styled from '@emotion/styled';
 import { List } from 'immutable';
-import { colors } from 'decap-cms-ui-default';
+import { colors, Icon } from 'decap-cms-ui-default';
 
 import NotesList from './NotesList';
 import AddNoteForm from './AddNoteForm';
@@ -17,15 +17,20 @@ const NotesContainer = styled.div`
 `;
 
 const NotesHeader = styled.div`
-  padding: 16px;
+  padding: 16px 24px;
   border-bottom: 1px solid ${colors.textFieldBorder};
   background-color: ${colors.inputBackground};
   display: flex;
-  justify-content: space-between;
   align-items: center;
   min-height: 60px;
 `;
 
+const NotesTitleGroup = styled.div`
+  display: flex;
+  align-items: center;
+  gap: 8px;
+`;
+
 const NotesTitle = styled.h3`
   margin: 0;
   font-size: 16px;
@@ -42,6 +47,26 @@ const NotesCount = styled.span`
   font-weight: 500;
 `;
 
+const SourceLink = styled.a`
+  color: ${colors.controlLabel};
+  text-decoration: none;
+  font-size: 14px;
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  
+  &:hover {
+    color: ${colors.text};
+    text-decoration: underline;
+  }
+`;
+
+const SourceIcon = styled(Icon)`
+  width: 16px;
+  height: 16px;
+  color: currentColor;
+`;
+
 const NotesContent = styled.div`
   flex: 1;
   display: flex;
@@ -80,6 +105,7 @@ class EditorNotesPane extends Component {
     collection: ImmutablePropTypes.map.isRequired,
     user: PropTypes.object,
     t: PropTypes.func,
+    sourceUrl: PropTypes.string, // Link to the GitHub issue or source
   };
 
   static defaultProps = {
@@ -116,20 +142,56 @@ class EditorNotesPane extends Component {
 
     this.handleUpdateNote(noteId, { resolved: !currentResolved });
   };
+  // Helper method to get the appropriate link text and icon type based on the source
+  getSourceInfo = url => {
+    // Check if URL is from GitHub
+    if (url.includes('github.com')) {
+      return {
+        text: 'View in GitHub',
+        iconType: 'github', // Using GitHub icon type
+      };
+    }
+    
+    // TODO: Add support for other Git providers
+    // Example for future contributors:
+    // if (url.includes('gitlab.com')) {
+    //   return { text: 'View in GitLab', iconType: 'gitlab' };
+    // }
+    // if (url.includes('bitbucket.org')) {
+    //   return { text: 'View in Bitbucket', iconType: 'bitbucket' };
+    // }
+    
+    // Default fallback
+    return {
+      text: 'View source',
+      iconType: 'link',
+    };
+  };
 
   render() {
     const { notes, t } = this.props;
     const notesList = notes && notes.size !== undefined ? notes : List(notes || []);
     const notesCount = notesList.size;
     const unresolvedCount = notesList.filter(note => !note.get('resolved')).size;
+    
+    const sourceUrl = notesCount > 0 ? notesList.first()?.get('issueUrl') : null;
+    const sourceInfo = sourceUrl ? this.getSourceInfo(sourceUrl) : null;
 
     return (
       <NotesContainer>
         <NotesHeader>
-          <NotesTitle>{t('editor.editorNotesPane.title')}</NotesTitle>
-          {notesCount > 0 && (
-            <NotesCount>{unresolvedCount > 0 ? unresolvedCount : notesCount}</NotesCount>
-          )}
+          <NotesTitleGroup>
+            <NotesTitle>{t('editor.editorNotesPane.title')}</NotesTitle>
+            {notesCount > 0 && (
+              <NotesCount>{unresolvedCount > 0 ? unresolvedCount : notesCount}</NotesCount>
+            )}
+            {sourceInfo && (
+              <SourceLink href={sourceUrl} target="_blank" rel="noopener noreferrer">
+                <span>{sourceInfo.text}</span>
+                <SourceIcon type={sourceInfo.iconType} />
+              </SourceLink>
+            )}
+          </NotesTitleGroup>
         </NotesHeader>
 
         <NotesContent>
@@ -156,4 +218,4 @@ class EditorNotesPane extends Component {
   }
 }
 
-export default EditorNotesPane;
+export default EditorNotesPane;
\ No newline at end of file
diff --git a/packages/decap-cms-lib-util/src/implementation.ts b/packages/decap-cms-lib-util/src/implementation.ts
index 1ca0b79d14cd..2645ddeb43f3 100644
--- a/packages/decap-cms-lib-util/src/implementation.ts
+++ b/packages/decap-cms-lib-util/src/implementation.ts
@@ -71,6 +71,7 @@ export interface Note {
   author: string;
   entrySlug: string;
   resolved: boolean;
+  issueUrl?: string;
 }
 
 export type AssetProxy = {

From d3bc5409c8238a3fe486201e4956190827c52c8e Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Tue, 28 Oct 2025 12:07:14 +0000
Subject: [PATCH 32/40] feat: decapNotes now have a polling system to retrieve
 new notes automatically

---
 packages/decap-cms-backend-github/src/API.ts  |  89 +++-
 .../src/implementation.tsx                    |  83 ++++
 .../decap-cms-backend-github/src/polling.ts   | 392 ++++++++++++++++++
 .../decap-cms-core/src/actions/entries.ts     | 128 +++++-
 packages/decap-cms-core/src/backend.ts        |  41 ++
 .../decap-cms-core/src/reducers/entryDraft.js |   4 +
 .../decap-cms-lib-util/src/implementation.ts  |  41 ++
 packages/decap-cms-lib-util/src/index.ts      |  10 +
 8 files changed, 786 insertions(+), 2 deletions(-)
 create mode 100644 packages/decap-cms-backend-github/src/polling.ts

diff --git a/packages/decap-cms-backend-github/src/API.ts b/packages/decap-cms-backend-github/src/API.ts
index 27dd2324cafd..3bae345eb053 100644
--- a/packages/decap-cms-backend-github/src/API.ts
+++ b/packages/decap-cms-backend-github/src/API.ts
@@ -38,6 +38,8 @@ import type {
   FetchError,
   ApiRequest,
   Note,
+  IssueState, 
+  CommentData
 } from 'decap-cms-lib-util';
 import type { Semaphore } from 'semaphore';
 import type { Octokit } from '@octokit/rest';
@@ -51,6 +53,8 @@ type GitHubPull = Octokit.PullsListResponseItem;
 
 export const API_NAME = 'GitHub';
 
+const { fetchWithTimeout: fetch } = unsentRequest;
+
 export const MOCK_PULL_REQUEST = -1;
 
 export interface Config {
@@ -1521,7 +1525,7 @@ ${note.content}`;
   /**
    * Parse a GitHub comment into a Note object
    */
-  private parseCommentToNote(comment: GitHubIssue): Note {
+  parseCommentToNote(comment: GitHubIssue): Note {
     if (!comment || !comment.body || !comment.user) {
       throw new Error('Invalid comment structure');
     }
@@ -1593,7 +1597,90 @@ ${note.content}`;
         return null;
       }
     }
+  /**
+     * Get issue with ETag support for conditional requests
+     * Returns { status: 304 } if not modified, or { status: 200, data, etag } if modified
+     */
+    async getIssueWithETag(
+      issueNumber: number,
+      etag: string | null
+    ): Promise<
+      | { status: 304; data?: never; etag?: never }
+      | { 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;
+        }
+
+        const response = await fetch(
+          `${this.apiRoot}${this.repoURL}/issues/${issueNumber}`,
+          { headers }
+        );
 
+        if (response.status === 304) {
+          return { status: 304 };
+        }
+
+        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: GitHubIssue[] = await commentsResponse.json();
+
+          const comments: CommentData[] = commentsRaw.map((comment) => ({
+            id: comment.id,
+            body: comment.body,
+            user: comment.user,
+            created_at: comment.created_at,
+            updated_at: comment.updated_at,
+          }));
+
+          const issueState: IssueState = {
+            number: issue.number,
+            title: issue.title,
+            body: issue.body,
+            state: issue.state,
+            updated_at: issue.updated_at,
+            comments,
+            labels: issue.labels,
+            html_url: issue.html_url,
+          };
+
+          return {
+            status: 200,
+            data: issueState,
+            etag: newETag, 
+          };
+        }
+
+        throw new Error(`Unexpected status: ${response.status}`);
+      } catch (error) {
+        if (error.status === 304) {
+          return { status: 304 };
+        }
+        throw error;
+      }
+    }
+
+    /**
+     * Get the current state of an issue (without ETag)
+     */
+    async getIssueState(issueNumber: number): Promise<IssueState> {
+      const response = await this.getIssueWithETag(issueNumber, null);
+      if (response.status === 200 && response.data) {
+        return response.data;
+      }
+      throw new Error('Failed to get issue state');
+    }
   /**
    * Get comments from a GitHub issue
    */
diff --git a/packages/decap-cms-backend-github/src/implementation.tsx b/packages/decap-cms-backend-github/src/implementation.tsx
index f30866068133..8da622de4fbf 100644
--- a/packages/decap-cms-backend-github/src/implementation.tsx
+++ b/packages/decap-cms-backend-github/src/implementation.tsx
@@ -24,6 +24,7 @@ import {
 
 import AuthenticationPage from './AuthenticationPage';
 import API, { API_NAME } from './API';
+import { ETagPollingManager } from './polling'
 import GraphQLAPI from './GraphQLAPI';
 
 import type { Octokit } from '@octokit/rest';
@@ -40,6 +41,7 @@ import type {
   UnpublishedEntryMediaFile,
   Entry,
   Note,
+  IssueChange
 } from 'decap-cms-lib-util';
 import type { Semaphore } from 'semaphore';
 
@@ -91,6 +93,8 @@ export default class GitHub implements Implementation {
     [key: string]: Promise<boolean>;
   };
   _mediaDisplayURLSem?: Semaphore;
+  pollingManager?: ETagPollingManager;
+  unwatchFunctions: Map<string, () => void> = new Map();
 
   constructor(config: Config, options = {}) {
     this.options = {
@@ -375,12 +379,22 @@ export default class GitHub implements Implementation {
     //   }
     // }
 
+    if (this.api && !this.pollingManager) {
+      this.pollingManager = new ETagPollingManager(this.api, 15000);
+    }
     // Authorized user
     return { ...user, token: state.token as string, useOpenAuthoring: this.useOpenAuthoring };
   }
 
   logout() {
     this.token = null;
+    // Clean up polling
+    if (this.pollingManager) {
+      this.pollingManager.destroy();
+      this.pollingManager = undefined;
+    }
+    this.unwatchFunctions.clear();
+
     if (this.api && this.api.reset && typeof this.api.reset === 'function') {
       return this.api.reset();
     }
@@ -823,4 +837,73 @@ export default class GitHub implements Implementation {
   async reopenIssueForUnpublishedEntry(collection: string, slug: string) {
     await this.api!.reopenIssueOnUnpublish(collection, slug);
   }
+  /**
+   * Start watching notes for changes
+   * Called from Redux action
+   */
+  async startNotesPolling(
+    collection: string,
+    slug: string,
+    callbacks: {
+      onUpdate: (notes: Note[], changes: IssueChange[]) => void;
+      onChange?: (change: IssueChange) => void;
+    }
+  ): Promise<void> {
+    if (!this.pollingManager) {
+      console.warn('[Polling] Polling manager not initialized');
+      return;
+    }
+
+    try {
+      // Find the issue for this entry
+      const issue = await this.api!.findEntryIssue(collection, slug);
+      if (!issue) {
+        console.log('[Polling] No issue found for this entry');
+        return;
+      }
+
+      // Get initial state
+      const initialState = await this.api!.getIssueState(issue.number);
+
+      // Start watching with callbacks and store unwatch function
+      const issueKey = `${collection}/${slug}`;
+      const unwatchFn = await this.pollingManager.watchIssue(
+        issue.number,
+        collection,
+        slug,
+        callbacks,
+        initialState
+      );
+
+      // Store unwatch function so we can call it later
+      this.unwatchFunctions.set(issueKey, unwatchFn);
+    } catch (error) {
+      console.error('[Polling] Failed to start polling:', error);
+    }
+  }
+
+  /**
+   * Stop watching notes for changes
+   * Called from Redux action: dispatch(stopNotesPolling(collection, slug))
+   */
+  async stopNotesPolling(collection: string, slug: string): Promise<void> {
+    const issueKey = `${collection}/${slug}`;
+    const unwatchFn = this.unwatchFunctions.get(issueKey);
+    
+    if (unwatchFn) {
+      unwatchFn(); // Stop watching
+      this.unwatchFunctions.delete(issueKey);
+    }
+  }
+
+  /**
+   * Manually refresh notes (force check now)
+   * Called from Redux action: dispatch(refreshNotesNow(collection, slug))
+   */
+  async refreshNotesNow(collection: string, slug: string): Promise<void> {
+    if (!this.pollingManager) {
+      throw new Error('Polling manager not initialized');
+    }
+    await this.pollingManager.checkIssueNow(collection, slug);
+  }
 }
diff --git a/packages/decap-cms-backend-github/src/polling.ts b/packages/decap-cms-backend-github/src/polling.ts
new file mode 100644
index 000000000000..dfedb8927803
--- /dev/null
+++ b/packages/decap-cms-backend-github/src/polling.ts
@@ -0,0 +1,392 @@
+/**
+ * GitHub Notes Polling System
+ * 
+ * ETag-based polling manager that efficiently checks for changes in GitHub Issues
+ * Used for a real-time feel of notes updates without excessive API calls leveraging conditional requests (304) that don't count on Github rate limits.
+ * 
+ * @module polling
+ */
+
+import type { Note, IssueState, CommentData, IssueChange } from 'decap-cms-lib-util';
+
+interface WatchedIssue {
+  issueNumber: number;
+  collection: string;
+  slug: string;
+  etag: string | null;
+  lastState: IssueState | null;
+  onUpdate?: (notes: Note[], changes: IssueChange[]) => void;
+  onChange?: (change: IssueChange) => void;
+}
+
+export interface GitHubNotesAPI {
+  getIssueState(issueNumber: number): Promise<IssueState>;
+  getIssueWithETag(
+    issueNumber: number,
+    etag: string | null
+  ): Promise<
+    | { status: 304; data?: never; etag?: never }
+    | { status: 200; data: IssueState; etag: string | null }
+  >;
+  parseCommentToNote(comment: CommentData): Note;
+}
+
+// Redux action types
+export const NOTES_POLLING_START = 'NOTES_POLLING_START';
+export const NOTES_POLLING_STOP = 'NOTES_POLLING_STOP';
+export const NOTES_POLLING_UPDATE = 'NOTES_POLLING_UPDATE';
+export const NOTES_CHANGE_DETECTED = 'NOTES_CHANGE_DETECTED';
+
+export class ETagPollingManager {
+  private watchedIssues: Map<string, WatchedIssue> = new Map();
+  private pollingInterval = 15000;
+  private intervalId: NodeJS.Timeout | null = null;
+  private isDocumentVisible = true;
+  private api: GitHubNotesAPI;
+  private isPolling = false;
+
+  constructor(api: GitHubNotesAPI, pollingInterval = 15000) {
+    this.api = api;
+    this.pollingInterval = pollingInterval;
+    this.setupVisibilityListener();
+  }
+
+  /**
+   * Setup Page Visibility API listener
+   * Pauses polling when tab is hidden 
+   */
+  private setupVisibilityListener() {
+    if (typeof document !== 'undefined') {
+      document.addEventListener('visibilitychange', () => {
+        this.isDocumentVisible = !document.hidden;
+        
+        if (this.isDocumentVisible) {
+          console.log('[Polling] Tab visible, resuming polling');
+          this.startPolling();
+          this.checkAllIssuesNow();
+        } else {
+          console.log('[Polling] Tab hidden, pausing polling');
+          this.stopPolling();
+        }
+      });
+    }
+  }
+
+  /**
+   * Start watching an issue for changes
+   * 
+   * @param issueNumber - GitHub issue number
+   * @param collection - Collection name
+   * @param slug - Entry slug
+   * @param initialState - Initial issue state (optional)
+   * @returns Function to stop watching
+   */
+  async watchIssue(
+    issueNumber: number,
+    collection: string,
+    slug: string,
+    callbacks: {
+      onUpdate?: (notes: Note[], changes: IssueChange[]) => void;
+      onChange?: (change: IssueChange) => void;
+    },
+    initialState: IssueState | null = null
+  ): Promise<() => void> {
+    const issueKey = this.getIssueKey(collection, slug);
+
+    console.log(`[Polling] Starting to watch issue #${issueNumber} for ${issueKey}`);
+
+    // Get initial state if not provided
+    if (!initialState) {
+      try {
+        initialState = await this.api.getIssueState(issueNumber);
+      } catch (error) {
+        console.error('[Polling] Failed to get initial state:', error);
+      }
+    }
+
+    this.watchedIssues.set(issueKey, {
+      issueNumber,
+      collection,
+      slug,
+      etag: null,
+      lastState: initialState,
+      onUpdate: callbacks.onUpdate,
+      onChange: callbacks.onChange,
+    });
+
+    // Start polling if not already running
+    if (!this.intervalId && this.isDocumentVisible) {
+      this.startPolling();
+    }
+
+    // Do an immediate check
+    this.checkIssue(issueKey);
+
+    // Return unwatch function
+    return () => this.unwatchIssue(issueKey);
+  }
+
+  /**
+   * Stop watching an issue
+   */
+  private unwatchIssue(issueKey: string) {
+    console.log(`[Polling] Stopped watching issue ${issueKey}`);
+    // REMOVE all dispatch-related code
+    this.watchedIssues.delete(issueKey);
+
+    if (this.watchedIssues.size === 0) {
+      this.stopPolling();
+    }
+  }
+
+  /**
+   * Start the polling loop
+   */
+  private startPolling() {
+    if (this.intervalId || !this.isDocumentVisible) return;
+
+    console.log(`[Polling] Starting polling loop (${this.pollingInterval}ms interval)`);
+    
+    this.intervalId = setInterval(() => {
+      this.pollAllIssues();
+    }, this.pollingInterval);
+  }
+
+  /**
+   * Stop the polling loop
+   */
+  private stopPolling() {
+    if (this.intervalId) {
+      console.log('[Polling] Stopping polling loop');
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+  }
+
+  /**
+   * Poll all watched issues
+   */
+  private async pollAllIssues() {
+    if (this.isPolling) {
+      console.log('[Polling] Already polling, skipping cycle');
+      return;
+    }
+
+    this.isPolling = true;
+
+    try {
+      const issues = Array.from(this.watchedIssues.keys());
+      
+      for (const issueKey of issues) {
+        await this.checkIssue(issueKey);
+        // Small delay between checks
+        await this.delay(500);
+      }
+    } finally {
+      this.isPolling = false;
+    }
+  }
+
+  /**
+   * Check a single issue for changes using ETag
+   */
+  private async checkIssue(issueKey: string) {
+    const watched = this.watchedIssues.get(issueKey);
+    if (!watched) return;
+
+    try {
+      console.log(`[Polling] Checking ${issueKey} (ETag: ${watched.etag ? 'yes' : 'no'})`);
+
+      const response = await this.api.getIssueWithETag(
+        watched.issueNumber,
+        watched.etag
+      );
+
+      if (response.status === 304) {
+        console.log(`[Polling] ${issueKey} - No changes (304)`);
+        return;
+      }
+
+      if (response.status === 200) {
+        const newState: IssueState = response.data;
+        const newETag = response.etag;
+
+        console.log(`[Polling] ${issueKey} - Changes detected!`);
+
+        // Update ETag
+        watched.etag = newETag || null;
+
+        // Detect specific changes
+        const changes = this.detectChanges(watched.lastState, newState);
+
+        if (changes.length > 0) {
+          // Convert comments to notes
+          const newNotes = newState.comments.map(comment => ({
+            ...this.api.parseCommentToNote(comment),
+            issueUrl: newState.html_url, 
+            }));
+
+          if (watched.onUpdate) {
+            watched.onUpdate(newNotes, changes)
+          }
+          
+          if (watched.onChange) {
+            changes.forEach(change => {
+              watched.onChange!(change);
+            })
+          }
+        }
+
+        // Update stored state
+        watched.lastState = newState;
+      }
+    } catch (error) {
+      if (error && typeof error === 'object' && 'status' in error && error.status !== 304) {
+        console.error(`[Polling] Error checking ${issueKey}:`, error);
+      }
+    }
+  }
+
+  /**
+   * Immediately check all issues
+   */
+  private async checkAllIssuesNow() {
+    console.log('[Polling] Checking all issues immediately');
+    const issues = Array.from(this.watchedIssues.keys());
+    
+    for (const issueKey of issues) {
+      await this.checkIssue(issueKey);
+      await this.delay(500);
+    }
+  }
+
+  /**
+   * Manually trigger a check for a specific issue
+   */
+  async checkIssueNow(collection: string, slug: string) {
+    const issueKey = this.getIssueKey(collection, slug);
+    console.log(`[Polling] Manual check requested for ${issueKey}`);
+    await this.checkIssue(issueKey);
+  }
+
+  /**
+   * Detect what changed between two states
+   */
+  private detectChanges(
+    previous: IssueState | null,
+    current: IssueState
+  ): IssueChange[] {
+    if (!previous) {
+      return [];
+    }
+
+    const changes: IssueChange[] = [];
+
+    // New comments
+    const newComments = current.comments.filter(
+      comment => !previous.comments.some(prev => prev.id === comment.id)
+    );
+    newComments.forEach(comment => {
+      changes.push({
+        type: 'comment_added',
+        data: comment,
+        timestamp: comment.created_at,
+      });
+    });
+
+    // Updated comments
+    current.comments.forEach(comment => {
+      const prevComment = previous.comments.find(prev => prev.id === comment.id);
+      if (prevComment && prevComment.updated_at !== comment.updated_at) {
+        changes.push({
+          type: 'comment_updated',
+          data: comment,
+          previousData: prevComment,
+          timestamp: comment.updated_at,
+        });
+      }
+    });
+
+    // Deleted comments
+    const deletedComments = previous.comments.filter(
+      prevComment => !current.comments.some(comment => comment.id === prevComment.id)
+    );
+    deletedComments.forEach(comment => {
+      changes.push({
+        type: 'comment_deleted',
+        data: comment,
+        timestamp: new Date().toISOString(),
+      });
+    });
+
+    // Issue state changed
+    if (previous.state !== current.state) {
+      changes.push({
+        type: 'issue_state_changed',
+        data: { from: previous.state, to: current.state },
+        timestamp: current.updated_at,
+      });
+    }
+
+    // Labels changed
+    if (this.hasLabelsChanged(previous.labels, current.labels)) {
+      changes.push({
+        type: 'issue_labels_changed',
+        data: { from: previous.labels, to: current.labels },
+        timestamp: current.updated_at,
+      });
+    }
+
+    return changes;
+  }
+
+  /**
+   * Check if labels changed
+   */
+  private hasLabelsChanged(
+    previous: Array<{ name: string }>,
+    current: Array<{ name: string }>
+  ): boolean {
+    if (previous.length !== current.length) return true;
+    const prevNames = previous.map(l => l.name).sort();
+    const currNames = current.map(l => l.name).sort();
+    return prevNames.join(',') !== currNames.join(',');
+  }
+
+  /**
+   * Get issue key for storage
+   */
+  private getIssueKey(collection: string, slug: string): string {
+    return `${collection}/${slug}`;
+  }
+
+  /**
+   * Utility delay function
+   */
+  private delay(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Get polling status
+   */
+  getStatus() {
+    return {
+      isPolling: this.intervalId !== null,
+      watchedCount: this.watchedIssues.size,
+      pollingInterval: this.pollingInterval,
+      isDocumentVisible: this.isDocumentVisible,
+    };
+  }
+
+  /**
+   * Clean up - stop all polling
+   */
+  destroy() {
+    console.log('[Polling] Destroying polling manager');
+    this.stopPolling();
+    this.watchedIssues.clear();
+  }
+}
+
+export default ETagPollingManager;
\ No newline at end of file
diff --git a/packages/decap-cms-core/src/actions/entries.ts b/packages/decap-cms-core/src/actions/entries.ts
index 5917700fb9c6..b16ae43dd284 100644
--- a/packages/decap-cms-core/src/actions/entries.ts
+++ b/packages/decap-cms-core/src/actions/entries.ts
@@ -22,7 +22,7 @@ import { getProcessSegment } from '../lib/formatters';
 import { hasI18n, duplicateDefaultI18nFields, serializeI18n, I18N, I18N_FIELD } from '../lib/i18n';
 import { addNotification } from './notifications';
 
-import type { ImplementationMediaFile, Note } from 'decap-cms-lib-util';
+import type { ImplementationMediaFile, Note, IssueChange } from 'decap-cms-lib-util';
 import type { AnyAction } from 'redux';
 import type { ThunkDispatch } from 'redux-thunk';
 import type {
@@ -99,6 +99,10 @@ export const NOTE_PERSIST_FAILURE = 'NOTE_PERSIST_FAILURE';
 export const NOTE_DELETE_REQUEST = 'NOTE_DELETE_REQUEST';
 export const NOTE_DELETE_SUCCESS = 'NOTE_DELETE_SUCCESS';
 export const NOTE_DELETE_FAILURE = 'NOTE_DELETE_FAILURE';
+export const NOTES_POLLING_START = 'NOTES_POLLING_START';
+export const NOTES_POLLING_STOP = 'NOTES_POLLING_STOP';
+export const NOTES_POLLING_UPDATE = 'NOTES_POLLING_UPDATE';
+export const NOTES_CHANGE_DETECTED = 'NOTES_CHANGE_DETECTED';
 
 /*
  * Simple Action Creators (Internal)
@@ -1142,6 +1146,7 @@ export function loadNotes(collection: Collection, slug: string) {
 
       dispatch(notesLoaded(collection, slug, notesWithSlug));
       dispatch(loadNotesForEntry(notesWithSlug));
+      dispatch(startNotesPolling(collection, slug));
     } catch (error) {
       dispatch(notesLoadError(error, collection, slug));
       dispatch(loadNotesForEntry([])); // Start with empty notes
@@ -1149,6 +1154,127 @@ export function loadNotes(collection: Collection, slug: string) {
   };
 }
 
+export function pollingStarted(collection: Collection, slug: string) {
+  return {
+    type: NOTES_POLLING_START,
+    payload: {
+      collection: collection.get('name'),
+      slug,
+    },
+  };
+}
+
+export function pollingStopped(collection: Collection, slug: string) {
+  return {
+    type: NOTES_POLLING_STOP,
+    payload: {
+      collection: collection.get('name'),
+      slug,
+    },
+  };
+}
+
+export function notesUpdatedFromPolling(
+  collection: Collection,
+  slug: string,
+  notes: Note[],
+  changes: IssueChange[]
+) {
+  return {
+    type: NOTES_POLLING_UPDATE,
+    payload: {
+      collection: collection.get('name'),
+      slug,
+      notes,
+      changes,
+    },
+  };
+}
+
+export function changeDetected(collection: Collection, slug: string, change: IssueChange) {
+  return {
+    type: NOTES_CHANGE_DETECTED,
+    payload: {
+      collection: collection.get('name'),
+      slug,
+      change,
+    },
+  };
+}
+
+  export function startNotesPolling(collection: Collection, slug: string) {
+    return async (dispatch: ThunkDispatch<State, {}, AnyAction>, getState: () => State) => {
+      try {
+        const state = getState();
+        const backend = currentBackend(state.config);
+        
+        if (!backend.startNotesPolling) { 
+          console.warn('[Polling] Backend does not support notes polling');
+          return;
+        }
+
+        const callbacks = {
+          onUpdate: (notes: Note[], changes: IssueChange[]) => {
+            dispatch(notesUpdatedFromPolling(collection, slug, notes, changes));
+            dispatch(loadNotesForEntry(notes));
+          },
+          onChange: (change: IssueChange) => {
+            // Dispatch action for individual change notifications
+            dispatch(changeDetected(collection, slug, change));
+          },
+        };
+
+        await backend.startNotesPolling(collection.get('name'), slug, callbacks);
+        
+        dispatch(pollingStarted(collection, slug));
+      } catch (error) {
+        console.error('[Polling] Failed to start notes polling:', error);
+      }
+    };
+  }
+/**
+ * Stop watching notes for an entry
+ */
+export function stopNotesPolling(collection: Collection, slug: string) {
+  return async (dispatch: ThunkDispatch<State, {}, AnyAction>, getState: () => State) => {
+    try {
+      const state = getState();
+      const backend = currentBackend(state.config);
+
+      if (!backend.stopNotesPolling) {  
+        return;
+      }
+
+      await backend.stopNotesPolling(collection.get('name'), slug); 
+
+      dispatch(pollingStopped(collection, slug));
+    } catch (error) {
+      console.error('[Polling] Failed to stop notes polling:', error);
+    }
+  };
+}
+
+/**
+ * Manually refresh notes 
+ */
+export function refreshNotesNow(collection: Collection, slug: string) {
+  return async (dispatch: ThunkDispatch<State, {}, AnyAction>, getState: () => State) => {
+    try {
+      const state = getState();
+      const backend = currentBackend(state.config);
+
+      if (!backend.refreshNotesNow) {
+        return dispatch(loadNotes(collection, slug));
+      }
+
+      await backend.refreshNotesNow(collection.get('name'), slug);
+    } catch (error) {
+      console.error('[Polling] Failed to refresh notes:', error);
+    }
+  };
+}
+
+
 export function persistNote(collection: Collection, slug: string, note: Omit<Note, 'id'>) {
   return async (dispatch: ThunkDispatch<State, {}, AnyAction>, getState: () => State) => {
     const backend = currentBackend(getState().config);
diff --git a/packages/decap-cms-core/src/backend.ts b/packages/decap-cms-core/src/backend.ts
index 64bdca7c004b..6e4dc994838b 100644
--- a/packages/decap-cms-core/src/backend.ts
+++ b/packages/decap-cms-core/src/backend.ts
@@ -82,6 +82,7 @@ import type {
   DataFile,
   UnpublishedEntryDiff,
   Note,
+  IssueChange
 } from 'decap-cms-lib-util';
 import type { Map } from 'immutable';
 
@@ -296,6 +297,17 @@ interface ImplementationInitOptions {
 
 type Implementation = BackendImplementation & {
   init: (config: CmsConfig, options: ImplementationInitOptions) => Implementation;
+
+  startNotesPolling?: (
+    collection: string,
+    slug: string,
+    callbacks: {
+      onUpdate?: (notes: Note[], changes: IssueChange[]) => void;
+      onChange?: (change: IssueChange) => void;
+    }
+  ) => Promise <void>;
+  stopNotesPolling?: (collection: string, slug: string) => Promise<void>;
+  refreshNotesNow?: (collection: string, slug: string) => Promise<void>;
 };
 
 function prepareMetaPath(path: string, collection: Collection) {
@@ -630,6 +642,35 @@ export class Backend {
     throw new Error(`Backend '${this.backendName}' does not support toggling note resolution`);
   }
 
+  async startNotesPolling(
+    collection: string,
+    slug: string,
+    callbacks: {
+      onUpdate?: (notes: Note[], changes: IssueChange[]) => void;
+      onChange?: (change: IssueChange) => void;
+    }
+  ): Promise<void> {
+    if (!this.implementation.startNotesPolling) {
+      console.warn('Backend does not support notes polling');
+      return;
+    }
+    return this.implementation.startNotesPolling(collection, slug, callbacks);
+  }
+
+  async stopNotesPolling(collection: string, slug: string): Promise<void> {
+    if (typeof this.implementation.stopNotesPolling === 'function') {
+      return this.implementation.stopNotesPolling(collection, slug);
+    }
+  }
+
+  async refreshNotesNow(collection: string, slug: string): Promise<void> {
+    if (typeof this.implementation.refreshNotesNow === 'function') {
+      return this.implementation.refreshNotesNow(collection, slug);
+    }
+    // Fallback: just reload notes without polling
+    console.warn(`Backend '${this.backendName}' does not support manual refresh`);
+  }
+
   reopenIssueForUnpublishedEntry(collection: string, slug: string) {
     if (typeof this.implementation.reopenIssueForUnpublishedEntry === 'function') {
       return this.implementation.reopenIssueForUnpublishedEntry(collection, slug);
diff --git a/packages/decap-cms-core/src/reducers/entryDraft.js b/packages/decap-cms-core/src/reducers/entryDraft.js
index 8493e1939108..03889fc5cc56 100644
--- a/packages/decap-cms-core/src/reducers/entryDraft.js
+++ b/packages/decap-cms-core/src/reducers/entryDraft.js
@@ -23,6 +23,7 @@ import {
   DRAFT_NOTE_ADD,
   DRAFT_NOTE_UPDATE,
   DRAFT_NOTE_DELETE,
+  NOTES_POLLING_UPDATE,
 } from '../actions/entries';
 import {
   UNPUBLISHED_ENTRY_PERSIST_REQUEST,
@@ -225,6 +226,9 @@ function entryDraftReducer(state = Map(), action) {
       return state.update('notes', notes =>
         notes.filterNot(note => note.get('id') === action.payload.id),
       );
+    
+    case NOTES_POLLING_UPDATE:  
+      return state.set('notes', fromJS(action.payload.notes));
 
     default:
       return state;
diff --git a/packages/decap-cms-lib-util/src/implementation.ts b/packages/decap-cms-lib-util/src/implementation.ts
index 2645ddeb43f3..4cd55ef5e897 100644
--- a/packages/decap-cms-lib-util/src/implementation.ts
+++ b/packages/decap-cms-lib-util/src/implementation.ts
@@ -74,6 +74,47 @@ export interface Note {
   issueUrl?: string;
 }
 
+export interface IssueState {
+  number: number;
+  title: string;
+  body: string;
+  state: 'open' | 'closed';
+  updated_at: string;
+  comments: CommentData[];
+  labels: Array<{ name: string; color: string }>;
+  html_url: string;
+}
+
+export interface CommentData {
+  id: number | string;
+  body: string;
+  user: {
+    login: string;
+    avatar_url: string;
+  } | null;
+  created_at: string;
+  updated_at: string;
+}
+
+export type ChangeType =
+  | 'comment_added'
+  | 'comment_updated'
+  | 'comment_deleted'
+  | 'issue_state_changed'
+  | 'issue_labels_changed';
+
+export type IssueChangeData =
+  | CommentData
+  | { from: 'open' | 'closed'; to: 'open' | 'closed' }
+  | { from: Array<{ name: string; color: string }>; to: Array<{ name: string; color: string }> };
+
+export interface IssueChange {
+  type: ChangeType;
+  data: IssueChangeData;
+  previousData?: CommentData;
+  timestamp: string;
+}
+
 export type AssetProxy = {
   path: string;
   fileObj?: File;
diff --git a/packages/decap-cms-lib-util/src/index.ts b/packages/decap-cms-lib-util/src/index.ts
index a9763b0dc04b..31fdabb71c2e 100644
--- a/packages/decap-cms-lib-util/src/index.ts
+++ b/packages/decap-cms-lib-util/src/index.ts
@@ -77,6 +77,11 @@ import type {
   UnpublishedEntryMediaFile as UEMF,
   DataFile as DF,
   Note as NT,
+  IssueState as IS,
+  CommentData as CD,
+  ChangeType as CT,
+  IssueChangeData as ICD,
+  IssueChange as IC,
 } from './implementation';
 import type { AsyncLock as AL } from './asyncLock';
 
@@ -101,6 +106,11 @@ export type FetchError = FE;
 export type PointerFile = PF;
 export type DataFile = DF;
 export type Note = NT;
+export type IssueState = IS;
+export type CommentData = CD;
+export type IssueChangeData = ICD;
+export type IssueChange = IC;
+export type ChangeType = CT;
 
 export const DecapCmsLibUtil = {
   APIError,

From 26c6e765c81516a5e5b728964f3264e6311e5179 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Thu, 30 Oct 2025 13:26:24 +0000
Subject: [PATCH 33/40] fix: notes polling system now works well with
 first-ever Note

---
 .../src/implementation.tsx                    |  48 ++--
 .../decap-cms-backend-github/src/polling.ts   | 240 ++++++++++++------
 .../decap-cms-core/src/actions/entries.ts     |  21 +-
 3 files changed, 202 insertions(+), 107 deletions(-)

diff --git a/packages/decap-cms-backend-github/src/implementation.tsx b/packages/decap-cms-backend-github/src/implementation.tsx
index 8da622de4fbf..23feb08ce666 100644
--- a/packages/decap-cms-backend-github/src/implementation.tsx
+++ b/packages/decap-cms-backend-github/src/implementation.tsx
@@ -841,7 +841,7 @@ export default class GitHub implements Implementation {
    * Start watching notes for changes
    * Called from Redux action
    */
-  async startNotesPolling(
+ async startNotesPolling(
     collection: string,
     slug: string,
     callbacks: {
@@ -850,49 +850,55 @@ export default class GitHub implements Implementation {
     }
   ): Promise<void> {
     if (!this.pollingManager) {
-      console.warn('[Polling] Polling manager not initialized');
+      console.warn('[DecapNotes Polling] Polling manager not initialized');
       return;
     }
 
-    try {
-      // Find the issue for this entry
-      const issue = await this.api!.findEntryIssue(collection, slug);
-      if (!issue) {
-        console.log('[Polling] No issue found for this entry');
-        return;
-      }
+    const issueKey = `${collection}/${slug}`;
 
-      // Get initial state
-      const initialState = await this.api!.getIssueState(issue.number);
+    // Check if already watching this exact entry - if so, skip
+    if (this.pollingManager.getStatus().currentWatch === issueKey) {
+      return;
+    }
+    
+    // First, ensure any previous polling for this entry is completely stopped
+    const existingUnwatch = this.unwatchFunctions.get(issueKey);
+    if (existingUnwatch) {
+      existingUnwatch();
+      this.unwatchFunctions.delete(issueKey);
+    }
 
-      // Start watching with callbacks and store unwatch function
-      const issueKey = `${collection}/${slug}`;
-      const unwatchFn = await this.pollingManager.watchIssue(
-        issue.number,
+    try {
+      const unwatchFn = await this.pollingManager.watchIssueWithRetry(
         collection,
         slug,
         callbacks,
-        initialState
+        5, // maxRetries - will try up to 5 times
+        2000 // retryDelay - 2 seconds between attempts
       );
 
-      // Store unwatch function so we can call it later
+      // Store the new unwatch function
       this.unwatchFunctions.set(issueKey, unwatchFn);
     } catch (error) {
-      console.error('[Polling] Failed to start polling:', error);
+      console.error('[DecapNotes Polling] Failed to start polling after retries:', error);
     }
   }
 
   /**
-   * Stop watching notes for changes
+   * Stop watching notes for changes 
    * Called from Redux action: dispatch(stopNotesPolling(collection, slug))
+   * 
+   * Ensures complete cleanup of polling for this entry
    */
   async stopNotesPolling(collection: string, slug: string): Promise<void> {
     const issueKey = `${collection}/${slug}`;
     const unwatchFn = this.unwatchFunctions.get(issueKey);
     
     if (unwatchFn) {
-      unwatchFn(); // Stop watching
+      unwatchFn(); 
       this.unwatchFunctions.delete(issueKey);
+    } else {
+      console.log(`[DecapNotes Polling] No active polling found for ${issueKey}`);
     }
   }
 
@@ -906,4 +912,4 @@ export default class GitHub implements Implementation {
     }
     await this.pollingManager.checkIssueNow(collection, slug);
   }
-}
+}
\ No newline at end of file
diff --git a/packages/decap-cms-backend-github/src/polling.ts b/packages/decap-cms-backend-github/src/polling.ts
index dfedb8927803..705a35722a19 100644
--- a/packages/decap-cms-backend-github/src/polling.ts
+++ b/packages/decap-cms-backend-github/src/polling.ts
@@ -17,6 +17,8 @@ interface WatchedIssue {
   lastState: IssueState | null;
   onUpdate?: (notes: Note[], changes: IssueChange[]) => void;
   onChange?: (change: IssueChange) => void;
+  retryCount?: number;
+  maxRetries?: number;
 }
 
 export interface GitHubNotesAPI {
@@ -29,6 +31,7 @@ export interface GitHubNotesAPI {
     | { status: 200; data: IssueState; etag: string | null }
   >;
   parseCommentToNote(comment: CommentData): Note;
+  findEntryIssue(collection: string, slug: string): Promise<{ number: number } | null>;
 }
 
 // Redux action types
@@ -38,12 +41,14 @@ export const NOTES_POLLING_UPDATE = 'NOTES_POLLING_UPDATE';
 export const NOTES_CHANGE_DETECTED = 'NOTES_CHANGE_DETECTED';
 
 export class ETagPollingManager {
-  private watchedIssues: Map<string, WatchedIssue> = new Map();
+  private currentWatch: WatchedIssue | null = null;
+  private currentIssueKey: string | null = null;
   private pollingInterval = 15000;
   private intervalId: NodeJS.Timeout | null = null;
   private isDocumentVisible = true;
   private api: GitHubNotesAPI;
   private isPolling = false;
+  private pendingRetryTimeout: NodeJS.Timeout | null = null;
 
   constructor(api: GitHubNotesAPI, pollingInterval = 15000) {
     this.api = api;
@@ -61,11 +66,9 @@ export class ETagPollingManager {
         this.isDocumentVisible = !document.hidden;
         
         if (this.isDocumentVisible) {
-          console.log('[Polling] Tab visible, resuming polling');
           this.startPolling();
           this.checkAllIssuesNow();
         } else {
-          console.log('[Polling] Tab hidden, pausing polling');
           this.stopPolling();
         }
       });
@@ -74,11 +77,11 @@ export class ETagPollingManager {
 
   /**
    * Start watching an issue for changes
+   * This will automatically stop watching any previously watched issue
    * 
    * @param issueNumber - GitHub issue number
    * @param collection - Collection name
    * @param slug - Entry slug
-   * @param initialState - Initial issue state (optional)
    * @returns Function to stop watching
    */
   async watchIssue(
@@ -93,18 +96,21 @@ export class ETagPollingManager {
   ): Promise<() => void> {
     const issueKey = this.getIssueKey(collection, slug);
 
-    console.log(`[Polling] Starting to watch issue #${issueNumber} for ${issueKey}`);
+    // STOP ANY EXISTING WATCH FIRST
+    if (this.currentWatch) {
+      this.stopCurrentWatch();
+    }
 
     // Get initial state if not provided
     if (!initialState) {
       try {
         initialState = await this.api.getIssueState(issueNumber);
       } catch (error) {
-        console.error('[Polling] Failed to get initial state:', error);
+        console.error('[DecapNotes Polling] Failed to get initial state:', error);
       }
     }
 
-    this.watchedIssues.set(issueKey, {
+    this.currentWatch = {
       issueNumber,
       collection,
       slug,
@@ -112,7 +118,11 @@ export class ETagPollingManager {
       lastState: initialState,
       onUpdate: callbacks.onUpdate,
       onChange: callbacks.onChange,
-    });
+      retryCount: 0,
+      maxRetries: 5,
+    };
+
+    this.currentIssueKey = issueKey;
 
     // Start polling if not already running
     if (!this.intervalId && this.isDocumentVisible) {
@@ -120,32 +130,112 @@ export class ETagPollingManager {
     }
 
     // Do an immediate check
-    this.checkIssue(issueKey);
+    this.checkCurrentIssue();
 
     // Return unwatch function
-    return () => this.unwatchIssue(issueKey);
+    return () => this.stopCurrentWatch();
   }
 
   /**
-   * Stop watching an issue
+   * Watch issue with retry logic for newly created issues
    */
-  private unwatchIssue(issueKey: string) {
-    console.log(`[Polling] Stopped watching issue ${issueKey}`);
-    // REMOVE all dispatch-related code
-    this.watchedIssues.delete(issueKey);
+  async watchIssueWithRetry(
+    collection: string,
+    slug: string,
+    callbacks: {
+      onUpdate?: (notes: Note[], changes: IssueChange[]) => void;
+      onChange?: (change: IssueChange) => void;
+    },
+    maxRetries = 5,
+    retryDelay = 2000
+  ): Promise<() => void> {
+    const issueKey = this.getIssueKey(collection, slug);
+    
+    // STOP ANY EXISTING WATCH FIRST
+    if (this.currentWatch) {
+      this.stopCurrentWatch();
+    }
 
-    if (this.watchedIssues.size === 0) {
-      this.stopPolling();
+    const attemptWatch = async (attempt: number): Promise<() => void> => {
+      try {
+        const issue = await this.api.findEntryIssue(collection, slug);
+        
+        if (issue) {
+          return await this.watchIssue(issue.number, collection, slug, callbacks);
+        }
+        
+        if (attempt < maxRetries) {
+        
+          return new Promise((resolve, reject) => {
+            this.pendingRetryTimeout = setTimeout(async () => {
+              this.pendingRetryTimeout = null;
+              try {
+                const unwatchFn = await attemptWatch(attempt + 1);
+                resolve(unwatchFn);
+              } catch (error) {
+                reject(error);
+              }
+            }, retryDelay);
+          });
+        }
+        
+        console.log(`[DecapNotes Polling] No issue found for ${issueKey} after ${maxRetries} attempts`);
+        // Return a no-op unwatch function
+        return () => { /* no-op */ };
+        
+      } catch (error) {
+        console.error(`[DecapNotes Polling] Error finding issue for ${issueKey}:`, error);
+        
+        if (attempt < maxRetries) {
+          return new Promise((resolve, reject) => {
+            this.pendingRetryTimeout = setTimeout(async () => {
+              this.pendingRetryTimeout = null;
+              try {
+                const unwatchFn = await attemptWatch(attempt + 1);
+                resolve(unwatchFn);
+              } catch (err) {
+                reject(err);
+              }
+            }, retryDelay);
+          });
+        }
+        
+        throw error;
+      }
+    };
+
+    return attemptWatch(1);
+  }
+
+  /**
+   * Stop watching the current issue - complete cleanup
+   */
+  private stopCurrentWatch() {
+    if (!this.currentWatch) {
+      return;
+    }
+    
+    // Clear any pending retry timeout
+    if (this.pendingRetryTimeout) {
+      clearTimeout(this.pendingRetryTimeout);
+      this.pendingRetryTimeout = null;
     }
+    
+    // Clear current watch
+    this.currentWatch = null;
+    this.currentIssueKey = null;
+
+    // Stop polling since there's nothing to watch
+    this.stopPolling();
   }
 
   /**
    * Start the polling loop
    */
   private startPolling() {
-    if (this.intervalId || !this.isDocumentVisible) return;
+    if (this.intervalId || !this.isDocumentVisible || !this.currentWatch) return;
 
-    console.log(`[Polling] Starting polling loop (${this.pollingInterval}ms interval)`);
+    console.log(`[DecapNotes Polling] Starting polling loop (${this.pollingInterval}ms interval) for ${this.currentIssueKey}`);
     
     this.intervalId = setInterval(() => {
       this.pollAllIssues();
@@ -157,53 +247,42 @@ export class ETagPollingManager {
    */
   private stopPolling() {
     if (this.intervalId) {
-      console.log('[Polling] Stopping polling loop');
+      console.log('[DecapNotes Polling] Stopping polling loop');
       clearInterval(this.intervalId);
       this.intervalId = null;
     }
   }
 
   /**
-   * Poll all watched issues
+   * Poll current watched issue
    */
   private async pollAllIssues() {
-    if (this.isPolling) {
-      console.log('[Polling] Already polling, skipping cycle');
+    await this.checkCurrentIssue();
+  }
+
+  /**
+   * Check current issue for changes using ETag
+   */
+  private async checkCurrentIssue() {
+    if (!this.currentWatch) {
       return;
     }
 
-    this.isPolling = true;
-
-    try {
-      const issues = Array.from(this.watchedIssues.keys());
-      
-      for (const issueKey of issues) {
-        await this.checkIssue(issueKey);
-        // Small delay between checks
-        await this.delay(500);
-      }
-    } finally {
-      this.isPolling = false;
+    if (this.isPolling) {
+      return;
     }
-  }
 
-  /**
-   * Check a single issue for changes using ETag
-   */
-  private async checkIssue(issueKey: string) {
-    const watched = this.watchedIssues.get(issueKey);
-    if (!watched) return;
+    this.isPolling = true;
 
     try {
-      console.log(`[Polling] Checking ${issueKey} (ETag: ${watched.etag ? 'yes' : 'no'})`);
+      const watch = this.currentWatch;
 
       const response = await this.api.getIssueWithETag(
-        watched.issueNumber,
-        watched.etag
+        watch.issueNumber,
+        watch.etag
       );
 
       if (response.status === 304) {
-        console.log(`[Polling] ${issueKey} - No changes (304)`);
         return;
       }
 
@@ -211,62 +290,61 @@ export class ETagPollingManager {
         const newState: IssueState = response.data;
         const newETag = response.etag;
 
-        console.log(`[Polling] ${issueKey} - Changes detected!`);
-
         // Update ETag
-        watched.etag = newETag || null;
+        watch.etag = newETag || null;
 
         // Detect specific changes
-        const changes = this.detectChanges(watched.lastState, newState);
+        const changes = this.detectChanges(watch.lastState, newState);
 
         if (changes.length > 0) {
           // Convert comments to notes
           const newNotes = newState.comments.map(comment => ({
             ...this.api.parseCommentToNote(comment),
             issueUrl: newState.html_url, 
-            }));
+          }));
 
-          if (watched.onUpdate) {
-            watched.onUpdate(newNotes, changes)
+          if (watch.onUpdate) {
+            watch.onUpdate(newNotes, changes);
           }
           
-          if (watched.onChange) {
+          if (watch.onChange) {
             changes.forEach(change => {
-              watched.onChange!(change);
-            })
+              watch.onChange!(change);
+            });
           }
         }
 
         // Update stored state
-        watched.lastState = newState;
+        watch.lastState = newState;
       }
     } catch (error) {
       if (error && typeof error === 'object' && 'status' in error && error.status !== 304) {
-        console.error(`[Polling] Error checking ${issueKey}:`, error);
+        console.error(`[DecapNotes Polling] Error checking ${this.currentIssueKey}:`, error);
       }
+    } finally {
+      this.isPolling = false;
     }
   }
 
   /**
-   * Immediately check all issues
+   * Immediately check current issue
    */
   private async checkAllIssuesNow() {
-    console.log('[Polling] Checking all issues immediately');
-    const issues = Array.from(this.watchedIssues.keys());
-    
-    for (const issueKey of issues) {
-      await this.checkIssue(issueKey);
-      await this.delay(500);
-    }
+    await this.checkCurrentIssue();
   }
 
   /**
-   * Manually trigger a check for a specific issue
+   * Manually trigger a check - only works if this is the current entry
    */
   async checkIssueNow(collection: string, slug: string) {
     const issueKey = this.getIssueKey(collection, slug);
-    console.log(`[Polling] Manual check requested for ${issueKey}`);
-    await this.checkIssue(issueKey);
+    
+    if (this.currentIssueKey !== issueKey) {
+      console.warn(`[DecapNotes Polling] Cannot check ${issueKey} - currently watching ${this.currentIssueKey}`);
+      return;
+    }
+    
+    await this.checkCurrentIssue();
   }
 
   /**
@@ -360,22 +438,17 @@ export class ETagPollingManager {
     return `${collection}/${slug}`;
   }
 
-  /**
-   * Utility delay function
-   */
-  private delay(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-
   /**
    * Get polling status
    */
   getStatus() {
     return {
       isPolling: this.intervalId !== null,
-      watchedCount: this.watchedIssues.size,
+      currentWatch: this.currentIssueKey,
+      watchedCount: this.currentWatch ? 1 : 0,
       pollingInterval: this.pollingInterval,
       isDocumentVisible: this.isDocumentVisible,
+      hasPendingRetry: this.pendingRetryTimeout !== null,
     };
   }
 
@@ -383,9 +456,16 @@ export class ETagPollingManager {
    * Clean up - stop all polling
    */
   destroy() {
-    console.log('[Polling] Destroying polling manager');
-    this.stopPolling();
-    this.watchedIssues.clear();
+    console.log('[DecapNotes Polling] Destroying polling manager');
+    
+    // Clear pending retry
+    if (this.pendingRetryTimeout) {
+      clearTimeout(this.pendingRetryTimeout);
+      this.pendingRetryTimeout = null;
+    }
+    
+    // Stop current watch
+    this.stopCurrentWatch();
   }
 }
 
diff --git a/packages/decap-cms-core/src/actions/entries.ts b/packages/decap-cms-core/src/actions/entries.ts
index b16ae43dd284..b5c387d53bf3 100644
--- a/packages/decap-cms-core/src/actions/entries.ts
+++ b/packages/decap-cms-core/src/actions/entries.ts
@@ -571,7 +571,7 @@ export function loadEntry(collection: Collection, slug: string) {
       dispatch(entryLoaded(collection, loadedEntry));
       dispatch(createDraftFromEntry(loadedEntry));
       const state = getState();
-      const isNotesEnabled = state.config.editor?.notes ?? false;
+      const isNotesEnabled = state.config.editor?.notes ?? false; 
       if (isNotesEnabled) {
         await dispatch(loadNotes(collection, slug));
       }
@@ -1209,7 +1209,7 @@ export function changeDetected(collection: Collection, slug: string, change: Iss
         const backend = currentBackend(state.config);
         
         if (!backend.startNotesPolling) { 
-          console.warn('[Polling] Backend does not support notes polling');
+          console.warn('[DecapNotes Polling] Backend does not support notes polling');
           return;
         }
 
@@ -1228,7 +1228,7 @@ export function changeDetected(collection: Collection, slug: string, change: Iss
         
         dispatch(pollingStarted(collection, slug));
       } catch (error) {
-        console.error('[Polling] Failed to start notes polling:', error);
+        console.error('[DecapNotes Polling] Failed to start notes polling:', error);
       }
     };
   }
@@ -1249,7 +1249,7 @@ export function stopNotesPolling(collection: Collection, slug: string) {
 
       dispatch(pollingStopped(collection, slug));
     } catch (error) {
-      console.error('[Polling] Failed to stop notes polling:', error);
+      console.error('[Redux] Failed to stop notes polling:', error);
     }
   };
 }
@@ -1269,7 +1269,7 @@ export function refreshNotesNow(collection: Collection, slug: string) {
 
       await backend.refreshNotesNow(collection.get('name'), slug);
     } catch (error) {
-      console.error('[Polling] Failed to refresh notes:', error);
+      console.error('[DecapNotes Polling] Failed to refresh notes:', error);
     }
   };
 }
@@ -1282,7 +1282,7 @@ export function persistNote(collection: Collection, slug: string, note: Omit<Not
     try {
       const savedNote = await backend.addNote(collection.get('name'), slug, note);
       dispatch(notePersisted(collection, slug, savedNote));
-      dispatch(addNote(savedNote));
+      dispatch(addNote(savedNote)); 
       dispatch(
         addNotification({
           message: {
@@ -1292,6 +1292,15 @@ export function persistNote(collection: Collection, slug: string, note: Omit<Not
           dismissAfter: 4000,
         }),
       );
+      // After adding a note, polling gets restarted. In case the note is the first ever note persisted (which is the moment a Github Issue is created for example) this will help the Polling system to pickup the source of the Notes.
+      const state = getState();
+      const isNotesEnabled = state.config.editor?.notes ?? false;
+      
+      if (isNotesEnabled) {
+        // Small delay to let the issue creation propagate
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        await dispatch(startNotesPolling(collection, slug));
+      }
       return savedNote;
     } catch (error) {
       dispatch(notePersistFail(collection, slug, note as Note, error));

From ed7003755f832c3080109ad22d7973a115e9e732 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Thu, 30 Oct 2025 13:28:26 +0000
Subject: [PATCH 34/40] chore: adding more context to console.log of decapNotes
 functionality when no notes exist yet

---
 packages/decap-cms-backend-github/src/polling.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/decap-cms-backend-github/src/polling.ts b/packages/decap-cms-backend-github/src/polling.ts
index 705a35722a19..a43158c0ec3e 100644
--- a/packages/decap-cms-backend-github/src/polling.ts
+++ b/packages/decap-cms-backend-github/src/polling.ts
@@ -179,7 +179,7 @@ export class ETagPollingManager {
           });
         }
         
-        console.log(`[DecapNotes Polling] No issue found for ${issueKey} after ${maxRetries} attempts`);
+        console.log(`[DecapNotes Polling] No issue found for ${issueKey} after ${maxRetries} attempts. This is expected if there are no notes for this entry yet.`);
         // Return a no-op unwatch function
         return () => { /* no-op */ };
         

From d9b4276ad90a3d50ba2ea5ee74581ce998f34bb4 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Thu, 30 Oct 2025 13:32:00 +0000
Subject: [PATCH 35/40] chore: formatting

---
 packages/decap-cms-backend-github/src/API.ts  | 200 +++++++++---------
 .../src/implementation.tsx                    |  39 ++--
 .../decap-cms-backend-github/src/polling.ts   |  82 +++----
 .../decap-cms-core/src/actions/entries.ts     |  71 +++----
 packages/decap-cms-core/src/backend.ts        |   8 +-
 .../Editor/EditorNotesPane/EditorNotesPane.js |  10 +-
 .../Editor/EditorNotesPane/NoteItem.js        |  16 +-
 .../decap-cms-core/src/reducers/entryDraft.js |   4 +-
 8 files changed, 215 insertions(+), 215 deletions(-)

diff --git a/packages/decap-cms-backend-github/src/API.ts b/packages/decap-cms-backend-github/src/API.ts
index 3bae345eb053..36707154aad3 100644
--- a/packages/decap-cms-backend-github/src/API.ts
+++ b/packages/decap-cms-backend-github/src/API.ts
@@ -38,8 +38,8 @@ import type {
   FetchError,
   ApiRequest,
   Note,
-  IssueState, 
-  CommentData
+  IssueState,
+  CommentData,
 } from 'decap-cms-lib-util';
 import type { Semaphore } from 'semaphore';
 import type { Octokit } from '@octokit/rest';
@@ -1574,113 +1574,109 @@ ${note.content}`;
   }
 
   /**
-     * Find existing issue for an entry (returns null if not found)
-     */
-    async findEntryIssue(
-      collectionName: string,
-      slug: string,
-    ): Promise<GitHubIssue | null> {
-      // Search for existing issue
-      const searchQuery = `repo:${this.repo} label:${API.NOTES_LABEL} "${collectionName}/${slug}" in:body`;
+   * Find existing issue for an entry (returns null if not found)
+   */
+  async findEntryIssue(collectionName: string, slug: string): Promise<GitHubIssue | null> {
+    // Search for existing issue
+    const searchQuery = `repo:${this.repo} label:${API.NOTES_LABEL} "${collectionName}/${slug}" in:body`;
 
-      try {
-        const searchResponse = await this.request('/search/issues', {
-          params: { q: searchQuery },
-        });
+    try {
+      const searchResponse = await this.request('/search/issues', {
+        params: { q: searchQuery },
+      });
 
-        if (searchResponse.items && searchResponse.items.length > 0) {
-          return searchResponse.items[0];
-        }
-        return null;
-      } catch (error) {
-        console.warn('Failed to search for existing notes issue:', error);
-        return null;
+      if (searchResponse.items && searchResponse.items.length > 0) {
+        return searchResponse.items[0];
       }
+      return null;
+    } catch (error) {
+      console.warn('Failed to search for existing notes issue:', error);
+      return null;
     }
+  }
   /**
-     * Get issue with ETag support for conditional requests
-     * Returns { status: 304 } if not modified, or { status: 200, data, etag } if modified
-     */
-    async getIssueWithETag(
-      issueNumber: number,
-      etag: string | null
-    ): Promise<
-      | { status: 304; data?: never; etag?: never }
-      | { status: 200; data: IssueState; etag: string | null }
-    > {
-      try {
-        const headers: Record<string, string> = {
-          Authorization: `${this.tokenKeyword} ${this.token}`,
-        };
+   * Get issue with ETag support for conditional requests
+   * Returns { status: 304 } if not modified, or { status: 200, data, etag } if modified
+   */
+  async getIssueWithETag(
+    issueNumber: number,
+    etag: string | null,
+  ): Promise<
+    | { status: 304; data?: never; etag?: never }
+    | { 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;
-        }
+      if (etag) {
+        headers['If-None-Match'] = etag;
+      }
 
-        const response = await fetch(
-          `${this.apiRoot}${this.repoURL}/issues/${issueNumber}`,
-          { headers }
-        );
+      const response = await fetch(`${this.apiRoot}${this.repoURL}/issues/${issueNumber}`, {
+        headers,
+      });
 
-        if (response.status === 304) {
-          return { status: 304 };
-        }
+      if (response.status === 304) {
+        return { status: 304 };
+      }
 
-        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: GitHubIssue[] = await commentsResponse.json();
-
-          const comments: CommentData[] = commentsRaw.map((comment) => ({
-            id: comment.id,
-            body: comment.body,
-            user: comment.user,
-            created_at: comment.created_at,
-            updated_at: comment.updated_at,
-          }));
-
-          const issueState: IssueState = {
-            number: issue.number,
-            title: issue.title,
-            body: issue.body,
-            state: issue.state,
-            updated_at: issue.updated_at,
-            comments,
-            labels: issue.labels,
-            html_url: issue.html_url,
-          };
-
-          return {
-            status: 200,
-            data: issueState,
-            etag: newETag, 
-          };
-        }
+      if (response.status === 200) {
+        const issue = await response.json();
+        const newETag = response.headers.get('ETag');
 
-        throw new Error(`Unexpected status: ${response.status}`);
-      } catch (error) {
-        if (error.status === 304) {
-          return { status: 304 };
-        }
-        throw error;
+        const commentsResponse = await fetch(
+          `${this.apiRoot}${this.repoURL}/issues/${issueNumber}/comments`,
+          { headers },
+        );
+        const commentsRaw: GitHubIssue[] = await commentsResponse.json();
+
+        const comments: CommentData[] = commentsRaw.map(comment => ({
+          id: comment.id,
+          body: comment.body,
+          user: comment.user,
+          created_at: comment.created_at,
+          updated_at: comment.updated_at,
+        }));
+
+        const issueState: IssueState = {
+          number: issue.number,
+          title: issue.title,
+          body: issue.body,
+          state: issue.state,
+          updated_at: issue.updated_at,
+          comments,
+          labels: issue.labels,
+          html_url: issue.html_url,
+        };
+
+        return {
+          status: 200,
+          data: issueState,
+          etag: newETag,
+        };
       }
-    }
 
-    /**
-     * Get the current state of an issue (without ETag)
-     */
-    async getIssueState(issueNumber: number): Promise<IssueState> {
-      const response = await this.getIssueWithETag(issueNumber, null);
-      if (response.status === 200 && response.data) {
-        return response.data;
+      throw new Error(`Unexpected status: ${response.status}`);
+    } catch (error) {
+      if (error.status === 304) {
+        return { status: 304 };
       }
-      throw new Error('Failed to get issue state');
+      throw error;
     }
+  }
+
+  /**
+   * Get the current state of an issue (without ETag)
+   */
+  async getIssueState(issueNumber: number): Promise<IssueState> {
+    const response = await this.getIssueWithETag(issueNumber, null);
+    if (response.status === 200 && response.data) {
+      return response.data;
+    }
+    throw new Error('Failed to get issue state');
+  }
   /**
    * Get comments from a GitHub issue
    */
@@ -1807,9 +1803,9 @@ ${note.content}`;
     }
   }
 
-    /**
-     * Get all notes for an entry 
-     */
+  /**
+   * Get all notes for an entry
+   */
   async getEntryNotes(collectionName: string, slug: string): Promise<Note[]> {
     try {
       const issue = await this.findEntryIssue(collectionName, slug);
@@ -1818,7 +1814,7 @@ ${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),
@@ -1845,9 +1841,9 @@ ${note.content}`;
         issue = await this.createEntryIssue(collectionName, slug, entryTitle);
       }
       const commentId = await this.createIssueComment(issue.number, note);
-      return { 
-        commentId, 
-        issueUrl: issue.html_url 
+      return {
+        commentId,
+        issueUrl: issue.html_url,
       };
     } catch (error) {
       console.error('Failed to add note to entry:', error);
diff --git a/packages/decap-cms-backend-github/src/implementation.tsx b/packages/decap-cms-backend-github/src/implementation.tsx
index 23feb08ce666..457169a19b6d 100644
--- a/packages/decap-cms-backend-github/src/implementation.tsx
+++ b/packages/decap-cms-backend-github/src/implementation.tsx
@@ -24,7 +24,7 @@ import {
 
 import AuthenticationPage from './AuthenticationPage';
 import API, { API_NAME } from './API';
-import { ETagPollingManager } from './polling'
+import { ETagPollingManager } from './polling';
 import GraphQLAPI from './GraphQLAPI';
 
 import type { Octokit } from '@octokit/rest';
@@ -41,7 +41,7 @@ import type {
   UnpublishedEntryMediaFile,
   Entry,
   Note,
-  IssueChange
+  IssueChange,
 } from 'decap-cms-lib-util';
 import type { Semaphore } from 'semaphore';
 
@@ -758,7 +758,7 @@ export default class GitHub implements Implementation {
 
   async addNote(collection: string, slug: string, noteData: Omit<Note, 'id'>): Promise<Note> {
     const currentUser = await this.currentUser({ token: this.token! });
-    
+
     const note: Note = {
       ...noteData,
       id: 'temp-' + Date.now(),
@@ -780,12 +780,17 @@ export default class GitHub implements Implementation {
       // Entry not found or error reading, use undefined title
     }
 
-    const { commentId, issueUrl } = await this.api!.addNoteToEntry(collection, slug, note, entryTitle);
-    
-    return { 
-      ...note, 
+    const { commentId, issueUrl } = await this.api!.addNoteToEntry(
+      collection,
+      slug,
+      note,
+      entryTitle,
+    );
+
+    return {
+      ...note,
       id: commentId,
-      issueUrl 
+      issueUrl,
     };
   }
 
@@ -841,13 +846,13 @@ export default class GitHub implements Implementation {
    * Start watching notes for changes
    * Called from Redux action
    */
- async startNotesPolling(
+  async startNotesPolling(
     collection: string,
     slug: string,
     callbacks: {
       onUpdate: (notes: Note[], changes: IssueChange[]) => void;
       onChange?: (change: IssueChange) => void;
-    }
+    },
   ): Promise<void> {
     if (!this.pollingManager) {
       console.warn('[DecapNotes Polling] Polling manager not initialized');
@@ -860,7 +865,7 @@ export default class GitHub implements Implementation {
     if (this.pollingManager.getStatus().currentWatch === issueKey) {
       return;
     }
-    
+
     // First, ensure any previous polling for this entry is completely stopped
     const existingUnwatch = this.unwatchFunctions.get(issueKey);
     if (existingUnwatch) {
@@ -874,7 +879,7 @@ export default class GitHub implements Implementation {
         slug,
         callbacks,
         5, // maxRetries - will try up to 5 times
-        2000 // retryDelay - 2 seconds between attempts
+        2000, // retryDelay - 2 seconds between attempts
       );
 
       // Store the new unwatch function
@@ -885,17 +890,17 @@ export default class GitHub implements Implementation {
   }
 
   /**
-   * Stop watching notes for changes 
+   * Stop watching notes for changes
    * Called from Redux action: dispatch(stopNotesPolling(collection, slug))
-   * 
+   *
    * Ensures complete cleanup of polling for this entry
    */
   async stopNotesPolling(collection: string, slug: string): Promise<void> {
     const issueKey = `${collection}/${slug}`;
     const unwatchFn = this.unwatchFunctions.get(issueKey);
-    
+
     if (unwatchFn) {
-      unwatchFn(); 
+      unwatchFn();
       this.unwatchFunctions.delete(issueKey);
     } else {
       console.log(`[DecapNotes Polling] No active polling found for ${issueKey}`);
@@ -912,4 +917,4 @@ export default class GitHub implements Implementation {
     }
     await this.pollingManager.checkIssueNow(collection, slug);
   }
-}
\ No newline at end of file
+}
diff --git a/packages/decap-cms-backend-github/src/polling.ts b/packages/decap-cms-backend-github/src/polling.ts
index a43158c0ec3e..aea1c59f9a0c 100644
--- a/packages/decap-cms-backend-github/src/polling.ts
+++ b/packages/decap-cms-backend-github/src/polling.ts
@@ -1,9 +1,9 @@
 /**
  * GitHub Notes Polling System
- * 
+ *
  * ETag-based polling manager that efficiently checks for changes in GitHub Issues
  * Used for a real-time feel of notes updates without excessive API calls leveraging conditional requests (304) that don't count on Github rate limits.
- * 
+ *
  * @module polling
  */
 
@@ -25,7 +25,7 @@ export interface GitHubNotesAPI {
   getIssueState(issueNumber: number): Promise<IssueState>;
   getIssueWithETag(
     issueNumber: number,
-    etag: string | null
+    etag: string | null,
   ): Promise<
     | { status: 304; data?: never; etag?: never }
     | { status: 200; data: IssueState; etag: string | null }
@@ -58,13 +58,13 @@ export class ETagPollingManager {
 
   /**
    * Setup Page Visibility API listener
-   * Pauses polling when tab is hidden 
+   * Pauses polling when tab is hidden
    */
   private setupVisibilityListener() {
     if (typeof document !== 'undefined') {
       document.addEventListener('visibilitychange', () => {
         this.isDocumentVisible = !document.hidden;
-        
+
         if (this.isDocumentVisible) {
           this.startPolling();
           this.checkAllIssuesNow();
@@ -78,7 +78,7 @@ export class ETagPollingManager {
   /**
    * Start watching an issue for changes
    * This will automatically stop watching any previously watched issue
-   * 
+   *
    * @param issueNumber - GitHub issue number
    * @param collection - Collection name
    * @param slug - Entry slug
@@ -92,7 +92,7 @@ export class ETagPollingManager {
       onUpdate?: (notes: Note[], changes: IssueChange[]) => void;
       onChange?: (change: IssueChange) => void;
     },
-    initialState: IssueState | null = null
+    initialState: IssueState | null = null,
   ): Promise<() => void> {
     const issueKey = this.getIssueKey(collection, slug);
 
@@ -147,10 +147,10 @@ export class ETagPollingManager {
       onChange?: (change: IssueChange) => void;
     },
     maxRetries = 5,
-    retryDelay = 2000
+    retryDelay = 2000,
   ): Promise<() => void> {
     const issueKey = this.getIssueKey(collection, slug);
-    
+
     // STOP ANY EXISTING WATCH FIRST
     if (this.currentWatch) {
       this.stopCurrentWatch();
@@ -159,13 +159,12 @@ export class ETagPollingManager {
     const attemptWatch = async (attempt: number): Promise<() => void> => {
       try {
         const issue = await this.api.findEntryIssue(collection, slug);
-        
+
         if (issue) {
           return await this.watchIssue(issue.number, collection, slug, callbacks);
         }
-        
+
         if (attempt < maxRetries) {
-        
           return new Promise((resolve, reject) => {
             this.pendingRetryTimeout = setTimeout(async () => {
               this.pendingRetryTimeout = null;
@@ -178,14 +177,17 @@ export class ETagPollingManager {
             }, retryDelay);
           });
         }
-        
-        console.log(`[DecapNotes Polling] No issue found for ${issueKey} after ${maxRetries} attempts. This is expected if there are no notes for this entry yet.`);
+
+        console.log(
+          `[DecapNotes Polling] No issue found for ${issueKey} after ${maxRetries} attempts. This is expected if there are no notes for this entry yet.`,
+        );
         // Return a no-op unwatch function
-        return () => { /* no-op */ };
-        
+        return () => {
+          /* no-op */
+        };
       } catch (error) {
         console.error(`[DecapNotes Polling] Error finding issue for ${issueKey}:`, error);
-        
+
         if (attempt < maxRetries) {
           return new Promise((resolve, reject) => {
             this.pendingRetryTimeout = setTimeout(async () => {
@@ -199,7 +201,7 @@ export class ETagPollingManager {
             }, retryDelay);
           });
         }
-        
+
         throw error;
       }
     };
@@ -214,13 +216,13 @@ export class ETagPollingManager {
     if (!this.currentWatch) {
       return;
     }
-    
+
     // Clear any pending retry timeout
     if (this.pendingRetryTimeout) {
       clearTimeout(this.pendingRetryTimeout);
       this.pendingRetryTimeout = null;
     }
-    
+
     // Clear current watch
     this.currentWatch = null;
     this.currentIssueKey = null;
@@ -235,8 +237,10 @@ export class ETagPollingManager {
   private startPolling() {
     if (this.intervalId || !this.isDocumentVisible || !this.currentWatch) return;
 
-    console.log(`[DecapNotes Polling] Starting polling loop (${this.pollingInterval}ms interval) for ${this.currentIssueKey}`);
-    
+    console.log(
+      `[DecapNotes Polling] Starting polling loop (${this.pollingInterval}ms interval) for ${this.currentIssueKey}`,
+    );
+
     this.intervalId = setInterval(() => {
       this.pollAllIssues();
     }, this.pollingInterval);
@@ -277,10 +281,7 @@ export class ETagPollingManager {
     try {
       const watch = this.currentWatch;
 
-      const response = await this.api.getIssueWithETag(
-        watch.issueNumber,
-        watch.etag
-      );
+      const response = await this.api.getIssueWithETag(watch.issueNumber, watch.etag);
 
       if (response.status === 304) {
         return;
@@ -300,13 +301,13 @@ export class ETagPollingManager {
           // Convert comments to notes
           const newNotes = newState.comments.map(comment => ({
             ...this.api.parseCommentToNote(comment),
-            issueUrl: newState.html_url, 
+            issueUrl: newState.html_url,
           }));
 
           if (watch.onUpdate) {
             watch.onUpdate(newNotes, changes);
           }
-          
+
           if (watch.onChange) {
             changes.forEach(change => {
               watch.onChange!(change);
@@ -338,22 +339,21 @@ export class ETagPollingManager {
    */
   async checkIssueNow(collection: string, slug: string) {
     const issueKey = this.getIssueKey(collection, slug);
-    
+
     if (this.currentIssueKey !== issueKey) {
-      console.warn(`[DecapNotes Polling] Cannot check ${issueKey} - currently watching ${this.currentIssueKey}`);
+      console.warn(
+        `[DecapNotes Polling] Cannot check ${issueKey} - currently watching ${this.currentIssueKey}`,
+      );
       return;
     }
-    
+
     await this.checkCurrentIssue();
   }
 
   /**
    * Detect what changed between two states
    */
-  private detectChanges(
-    previous: IssueState | null,
-    current: IssueState
-  ): IssueChange[] {
+  private detectChanges(previous: IssueState | null, current: IssueState): IssueChange[] {
     if (!previous) {
       return [];
     }
@@ -362,7 +362,7 @@ export class ETagPollingManager {
 
     // New comments
     const newComments = current.comments.filter(
-      comment => !previous.comments.some(prev => prev.id === comment.id)
+      comment => !previous.comments.some(prev => prev.id === comment.id),
     );
     newComments.forEach(comment => {
       changes.push({
@@ -387,7 +387,7 @@ export class ETagPollingManager {
 
     // Deleted comments
     const deletedComments = previous.comments.filter(
-      prevComment => !current.comments.some(comment => comment.id === prevComment.id)
+      prevComment => !current.comments.some(comment => comment.id === prevComment.id),
     );
     deletedComments.forEach(comment => {
       changes.push({
@@ -423,7 +423,7 @@ export class ETagPollingManager {
    */
   private hasLabelsChanged(
     previous: Array<{ name: string }>,
-    current: Array<{ name: string }>
+    current: Array<{ name: string }>,
   ): boolean {
     if (previous.length !== current.length) return true;
     const prevNames = previous.map(l => l.name).sort();
@@ -457,16 +457,16 @@ export class ETagPollingManager {
    */
   destroy() {
     console.log('[DecapNotes Polling] Destroying polling manager');
-    
+
     // Clear pending retry
     if (this.pendingRetryTimeout) {
       clearTimeout(this.pendingRetryTimeout);
       this.pendingRetryTimeout = null;
     }
-    
+
     // Stop current watch
     this.stopCurrentWatch();
   }
 }
 
-export default ETagPollingManager;
\ No newline at end of file
+export default ETagPollingManager;
diff --git a/packages/decap-cms-core/src/actions/entries.ts b/packages/decap-cms-core/src/actions/entries.ts
index b5c387d53bf3..91ade1bde191 100644
--- a/packages/decap-cms-core/src/actions/entries.ts
+++ b/packages/decap-cms-core/src/actions/entries.ts
@@ -571,7 +571,7 @@ export function loadEntry(collection: Collection, slug: string) {
       dispatch(entryLoaded(collection, loadedEntry));
       dispatch(createDraftFromEntry(loadedEntry));
       const state = getState();
-      const isNotesEnabled = state.config.editor?.notes ?? false; 
+      const isNotesEnabled = state.config.editor?.notes ?? false;
       if (isNotesEnabled) {
         await dispatch(loadNotes(collection, slug));
       }
@@ -1178,7 +1178,7 @@ export function notesUpdatedFromPolling(
   collection: Collection,
   slug: string,
   notes: Note[],
-  changes: IssueChange[]
+  changes: IssueChange[],
 ) {
   return {
     type: NOTES_POLLING_UPDATE,
@@ -1202,36 +1202,36 @@ export function changeDetected(collection: Collection, slug: string, change: Iss
   };
 }
 
-  export function startNotesPolling(collection: Collection, slug: string) {
-    return async (dispatch: ThunkDispatch<State, {}, AnyAction>, getState: () => State) => {
-      try {
-        const state = getState();
-        const backend = currentBackend(state.config);
-        
-        if (!backend.startNotesPolling) { 
-          console.warn('[DecapNotes Polling] Backend does not support notes polling');
-          return;
-        }
-
-        const callbacks = {
-          onUpdate: (notes: Note[], changes: IssueChange[]) => {
-            dispatch(notesUpdatedFromPolling(collection, slug, notes, changes));
-            dispatch(loadNotesForEntry(notes));
-          },
-          onChange: (change: IssueChange) => {
-            // Dispatch action for individual change notifications
-            dispatch(changeDetected(collection, slug, change));
-          },
-        };
+export function startNotesPolling(collection: Collection, slug: string) {
+  return async (dispatch: ThunkDispatch<State, {}, AnyAction>, getState: () => State) => {
+    try {
+      const state = getState();
+      const backend = currentBackend(state.config);
 
-        await backend.startNotesPolling(collection.get('name'), slug, callbacks);
-        
-        dispatch(pollingStarted(collection, slug));
-      } catch (error) {
-        console.error('[DecapNotes Polling] Failed to start notes polling:', error);
+      if (!backend.startNotesPolling) {
+        console.warn('[DecapNotes Polling] Backend does not support notes polling');
+        return;
       }
-    };
-  }
+
+      const callbacks = {
+        onUpdate: (notes: Note[], changes: IssueChange[]) => {
+          dispatch(notesUpdatedFromPolling(collection, slug, notes, changes));
+          dispatch(loadNotesForEntry(notes));
+        },
+        onChange: (change: IssueChange) => {
+          // Dispatch action for individual change notifications
+          dispatch(changeDetected(collection, slug, change));
+        },
+      };
+
+      await backend.startNotesPolling(collection.get('name'), slug, callbacks);
+
+      dispatch(pollingStarted(collection, slug));
+    } catch (error) {
+      console.error('[DecapNotes Polling] Failed to start notes polling:', error);
+    }
+  };
+}
 /**
  * Stop watching notes for an entry
  */
@@ -1241,11 +1241,11 @@ export function stopNotesPolling(collection: Collection, slug: string) {
       const state = getState();
       const backend = currentBackend(state.config);
 
-      if (!backend.stopNotesPolling) {  
+      if (!backend.stopNotesPolling) {
         return;
       }
 
-      await backend.stopNotesPolling(collection.get('name'), slug); 
+      await backend.stopNotesPolling(collection.get('name'), slug);
 
       dispatch(pollingStopped(collection, slug));
     } catch (error) {
@@ -1255,7 +1255,7 @@ export function stopNotesPolling(collection: Collection, slug: string) {
 }
 
 /**
- * Manually refresh notes 
+ * Manually refresh notes
  */
 export function refreshNotesNow(collection: Collection, slug: string) {
   return async (dispatch: ThunkDispatch<State, {}, AnyAction>, getState: () => State) => {
@@ -1274,7 +1274,6 @@ export function refreshNotesNow(collection: Collection, slug: string) {
   };
 }
 
-
 export function persistNote(collection: Collection, slug: string, note: Omit<Note, 'id'>) {
   return async (dispatch: ThunkDispatch<State, {}, AnyAction>, getState: () => State) => {
     const backend = currentBackend(getState().config);
@@ -1282,7 +1281,7 @@ export function persistNote(collection: Collection, slug: string, note: Omit<Not
     try {
       const savedNote = await backend.addNote(collection.get('name'), slug, note);
       dispatch(notePersisted(collection, slug, savedNote));
-      dispatch(addNote(savedNote)); 
+      dispatch(addNote(savedNote));
       dispatch(
         addNotification({
           message: {
@@ -1295,7 +1294,7 @@ export function persistNote(collection: Collection, slug: string, note: Omit<Not
       // After adding a note, polling gets restarted. In case the note is the first ever note persisted (which is the moment a Github Issue is created for example) this will help the Polling system to pickup the source of the Notes.
       const state = getState();
       const isNotesEnabled = state.config.editor?.notes ?? false;
-      
+
       if (isNotesEnabled) {
         // Small delay to let the issue creation propagate
         await new Promise(resolve => setTimeout(resolve, 1000));
diff --git a/packages/decap-cms-core/src/backend.ts b/packages/decap-cms-core/src/backend.ts
index 6e4dc994838b..6a40cd05c1c4 100644
--- a/packages/decap-cms-core/src/backend.ts
+++ b/packages/decap-cms-core/src/backend.ts
@@ -82,7 +82,7 @@ import type {
   DataFile,
   UnpublishedEntryDiff,
   Note,
-  IssueChange
+  IssueChange,
 } from 'decap-cms-lib-util';
 import type { Map } from 'immutable';
 
@@ -304,8 +304,8 @@ type Implementation = BackendImplementation & {
     callbacks: {
       onUpdate?: (notes: Note[], changes: IssueChange[]) => void;
       onChange?: (change: IssueChange) => void;
-    }
-  ) => Promise <void>;
+    },
+  ) => Promise<void>;
   stopNotesPolling?: (collection: string, slug: string) => Promise<void>;
   refreshNotesNow?: (collection: string, slug: string) => Promise<void>;
 };
@@ -648,7 +648,7 @@ export class Backend {
     callbacks: {
       onUpdate?: (notes: Note[], changes: IssueChange[]) => void;
       onChange?: (change: IssueChange) => void;
-    }
+    },
   ): Promise<void> {
     if (!this.implementation.startNotesPolling) {
       console.warn('Backend does not support notes polling');
diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js
index b2bcb18dd3fa..3f4fff570965 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/EditorNotesPane.js
@@ -54,7 +54,7 @@ const SourceLink = styled.a`
   display: flex;
   align-items: center;
   gap: 6px;
-  
+
   &:hover {
     color: ${colors.text};
     text-decoration: underline;
@@ -151,7 +151,7 @@ class EditorNotesPane extends Component {
         iconType: 'github', // Using GitHub icon type
       };
     }
-    
+
     // TODO: Add support for other Git providers
     // Example for future contributors:
     // if (url.includes('gitlab.com')) {
@@ -160,7 +160,7 @@ class EditorNotesPane extends Component {
     // if (url.includes('bitbucket.org')) {
     //   return { text: 'View in Bitbucket', iconType: 'bitbucket' };
     // }
-    
+
     // Default fallback
     return {
       text: 'View source',
@@ -173,7 +173,7 @@ class EditorNotesPane extends Component {
     const notesList = notes && notes.size !== undefined ? notes : List(notes || []);
     const notesCount = notesList.size;
     const unresolvedCount = notesList.filter(note => !note.get('resolved')).size;
-    
+
     const sourceUrl = notesCount > 0 ? notesList.first()?.get('issueUrl') : null;
     const sourceInfo = sourceUrl ? this.getSourceInfo(sourceUrl) : null;
 
@@ -218,4 +218,4 @@ class EditorNotesPane extends Component {
   }
 }
 
-export default EditorNotesPane;
\ No newline at end of file
+export default EditorNotesPane;
diff --git a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js
index e48145727749..db7fa4066fca 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorNotesPane/NoteItem.js
@@ -166,14 +166,14 @@ class NoteItem extends Component {
   };
 
   formatTimestamp = timestamp => {
-      const date = new Date(timestamp);
-      return date.toLocaleString(undefined, {
-          year: 'numeric',
-          month: 'numeric',
-          day: 'numeric',
-          hour: 'numeric',
-          minute: 'numeric'
-      });
+    const date = new Date(timestamp);
+    return date.toLocaleString(undefined, {
+      year: 'numeric',
+      month: 'numeric',
+      day: 'numeric',
+      hour: 'numeric',
+      minute: 'numeric',
+    });
   };
 
   handleEditStart = () => {
diff --git a/packages/decap-cms-core/src/reducers/entryDraft.js b/packages/decap-cms-core/src/reducers/entryDraft.js
index 03889fc5cc56..fd5f045a5def 100644
--- a/packages/decap-cms-core/src/reducers/entryDraft.js
+++ b/packages/decap-cms-core/src/reducers/entryDraft.js
@@ -226,8 +226,8 @@ function entryDraftReducer(state = Map(), action) {
       return state.update('notes', notes =>
         notes.filterNot(note => note.get('id') === action.payload.id),
       );
-    
-    case NOTES_POLLING_UPDATE:  
+
+    case NOTES_POLLING_UPDATE:
       return state.set('notes', fromJS(action.payload.notes));
 
     default:

From dfda2fa3be8c9340c636520314a136605c068e14 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Sat, 1 Nov 2025 21:52:20 +0000
Subject: [PATCH 36/40] chore: fixed with correct data structure in DecapNotes
 test

---
 .../src/__tests__/implementation.spec.js               | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/packages/decap-cms-backend-github/src/__tests__/implementation.spec.js b/packages/decap-cms-backend-github/src/__tests__/implementation.spec.js
index b05ea60baab4..91a79a053360 100644
--- a/packages/decap-cms-backend-github/src/__tests__/implementation.spec.js
+++ b/packages/decap-cms-backend-github/src/__tests__/implementation.spec.js
@@ -446,7 +446,10 @@ describe('github backend implementation', () => {
           resolved: false,
         };
 
-        mockAPI.addNoteToEntry.mockResolvedValue('comment-123');
+        mockAPI.addNoteToEntry.mockResolvedValue({
+          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);
@@ -484,7 +487,10 @@ describe('github backend implementation', () => {
           timestamp: '2025-01-01T00:00:00Z',
         };
 
-        mockAPI.addNoteToEntry.mockResolvedValue('comment-123');
+        mockAPI.addNoteToEntry.mockResolvedValue({
+          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);

From 6813ad6095e55093eb7627b78622bacf7ee753dd Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Sat, 1 Nov 2025 22:15:38 +0000
Subject: [PATCH 37/40] chore: added tests for decapNotes polling system

---
 .../src/__tests__/implementation.spec.js      | 147 ++++++++++++++++++
 1 file changed, 147 insertions(+)

diff --git a/packages/decap-cms-backend-github/src/__tests__/implementation.spec.js b/packages/decap-cms-backend-github/src/__tests__/implementation.spec.js
index 91a79a053360..df8122d69736 100644
--- a/packages/decap-cms-backend-github/src/__tests__/implementation.spec.js
+++ b/packages/decap-cms-backend-github/src/__tests__/implementation.spec.js
@@ -697,5 +697,152 @@ describe('github backend implementation', () => {
         expect(mockAPI.closeIssueOnPublish).toHaveBeenCalledWith('posts', 'my-post');
       });
     });
+    describe('notes polling', () => {
+      beforeEach(() => {
+        jest.clearAllMocks();
+      });
+
+      it('should start notes polling', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.pollingManager = {
+          watchIssueWithRetry: jest.fn().mockResolvedValue(() => {}),
+          getStatus: jest.fn().mockReturnValue({ currentWatch: null }),
+        };
+
+        const callbacks = {
+          onUpdate: jest.fn(),
+          onChange: jest.fn(),
+        };
+
+        await gitHubImplementation.startNotesPolling('posts', 'my-post', callbacks);
+
+        expect(gitHubImplementation.pollingManager.watchIssueWithRetry).toHaveBeenCalledWith(
+          'posts',
+          'my-post',
+          callbacks,
+          5,
+          2000,
+        );
+      });
+
+      it('should not start polling if already watching same entry', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.pollingManager = {
+          watchIssueWithRetry: jest.fn().mockResolvedValue(() => {}),
+          getStatus: jest.fn().mockReturnValue({ currentWatch: 'posts/my-post' }),
+        };
+
+        const callbacks = { onUpdate: jest.fn() };
+
+        await gitHubImplementation.startNotesPolling('posts', 'my-post', callbacks);
+
+        expect(gitHubImplementation.pollingManager.watchIssueWithRetry).not.toHaveBeenCalled();
+      });
+
+      it('should stop notes polling', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        const unwatchFn = jest.fn();
+        gitHubImplementation.unwatchFunctions.set('posts/my-post', unwatchFn);
+
+        await gitHubImplementation.stopNotesPolling('posts', 'my-post');
+
+        expect(unwatchFn).toHaveBeenCalledTimes(1);
+        expect(gitHubImplementation.unwatchFunctions.has('posts/my-post')).toBe(false);
+      });
+
+      it('should handle stopping polling when not active', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+
+        await expect(
+          gitHubImplementation.stopNotesPolling('posts', 'my-post'),
+        ).resolves.not.toThrow();
+      });
+
+      it('should refresh notes immediately', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.pollingManager = {
+          checkIssueNow: jest.fn().mockResolvedValue(undefined),
+        };
+
+        await gitHubImplementation.refreshNotesNow('posts', 'my-post');
+
+        expect(gitHubImplementation.pollingManager.checkIssueNow).toHaveBeenCalledWith(
+          'posts',
+          'my-post',
+        );
+      });
+
+      it('should throw error when refreshing without polling manager', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.pollingManager = undefined;
+
+        await expect(gitHubImplementation.refreshNotesNow('posts', 'my-post')).rejects.toThrow(
+          'Polling manager not initialized',
+        );
+      });
+      it('should start polling and store unwatch function', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        const unwatchFn = jest.fn();
+
+        gitHubImplementation.pollingManager = {
+          watchIssueWithRetry: jest.fn().mockResolvedValue(unwatchFn),
+          getStatus: jest.fn().mockReturnValue({ currentWatch: null }),
+        };
+
+        const callbacks = {
+          onUpdate: jest.fn(),
+          onChange: jest.fn(),
+        };
+
+        await gitHubImplementation.startNotesPolling('posts', 'my-post', callbacks);
+
+        expect(gitHubImplementation.pollingManager.watchIssueWithRetry).toHaveBeenCalledWith(
+          'posts',
+          'my-post',
+          callbacks,
+          5,
+          2000,
+        );
+        expect(gitHubImplementation.unwatchFunctions.get('posts/my-post')).toBe(unwatchFn);
+      });
+
+      it('should stop existing polling before starting new one', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        const oldUnwatchFn = jest.fn();
+        const newUnwatchFn = jest.fn();
+
+        gitHubImplementation.unwatchFunctions.set('posts/my-post', oldUnwatchFn);
+        gitHubImplementation.pollingManager = {
+          watchIssueWithRetry: jest.fn().mockResolvedValue(newUnwatchFn),
+          getStatus: jest.fn().mockReturnValue({ currentWatch: 'posts/other-post' }),
+        };
+
+        const callbacks = { onUpdate: jest.fn() };
+
+        await gitHubImplementation.startNotesPolling('posts', 'my-post', callbacks);
+
+        expect(oldUnwatchFn).toHaveBeenCalledTimes(1);
+        expect(gitHubImplementation.unwatchFunctions.get('posts/my-post')).toBe(newUnwatchFn);
+      });
+
+      it('should handle polling manager error gracefully', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+
+        gitHubImplementation.pollingManager = {
+          watchIssueWithRetry: jest.fn().mockRejectedValue(new Error('Failed to find issue')),
+          getStatus: jest.fn().mockReturnValue({ currentWatch: null }),
+        };
+
+        const callbacks = { onUpdate: jest.fn() };
+
+        await gitHubImplementation.startNotesPolling('posts', 'my-post', callbacks);
+
+        // Should not throw, just log error
+        expect(console.error).toHaveBeenCalledWith(
+          '[DecapNotes Polling] Failed to start polling after retries:',
+          expect.any(Error),
+        );
+      });
+    });
   });
 });

From 2dc50a1c8a4412e7207aaaf2fe93844eef120426 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Sun, 22 Feb 2026 17:27:37 +0000
Subject: [PATCH 38/40] fix: changed Notes icon

---
 .../decap-cms-core/src/components/Editor/EditorInterface.js     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/decap-cms-core/src/components/Editor/EditorInterface.js b/packages/decap-cms-core/src/components/Editor/EditorInterface.js
index 685bc693578a..254bbfa5df4b 100644
--- a/packages/decap-cms-core/src/components/Editor/EditorInterface.js
+++ b/packages/decap-cms-core/src/components/Editor/EditorInterface.js
@@ -466,7 +466,7 @@ class EditorInterface extends Component {
                 isActive={notesVisible}
                 onClick={this.handleToggleNotes}
                 size="large"
-                type="quote"
+                type="write"
                 title={t('editor.editorInterface.toggleNotes')}
               />
             )}

From 9d9389439201b9af62ae607f3f3d03ac74ce2d13 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Sun, 22 Feb 2026 17:28:03 +0000
Subject: [PATCH 39/40] chore: add error for Note adding failure

---
 packages/decap-cms-locales/src/en/index.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/packages/decap-cms-locales/src/en/index.js b/packages/decap-cms-locales/src/en/index.js
index 116a58751067..a3db4df4a3ab 100644
--- a/packages/decap-cms-locales/src/en/index.js
+++ b/packages/decap-cms-locales/src/en/index.js
@@ -310,6 +310,7 @@ const en = {
       entryUpdated: 'Entry status updated',
       onDeleteUnpublishedChanges: 'Unpublished changes deleted',
       noteAdded: 'Note added',
+      onFailToAddNote: 'Failed to add note: %{details}',
       noteUpdated: 'Note updated',
       onFailToUpdateNote: 'Failed to update note: %{details}',
       noteDeleted: 'Note deleted',

From fb0792fb084a0bf5a9e0e7f6d984b3a0de729053 Mon Sep 17 00:00:00 2001
From: EstoesMoises <contactomoises1@gmail.com>
Date: Mon, 23 Feb 2026 15:33:15 +0000
Subject: [PATCH 40/40] fix: note.author defaults to empty string

---
 packages/decap-cms-backend-github/src/implementation.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/decap-cms-backend-github/src/implementation.tsx b/packages/decap-cms-backend-github/src/implementation.tsx
index ffe4e7953cee..f23db7d9adb4 100644
--- a/packages/decap-cms-backend-github/src/implementation.tsx
+++ b/packages/decap-cms-backend-github/src/implementation.tsx
@@ -769,7 +769,7 @@ export default class GitHub implements Implementation {
     const note: Note = {
       ...noteData,
       id: 'temp-' + Date.now(),
-      author: currentUser.login || currentUser.name,
+      author: currentUser.login || currentUser.name || '',
       avatarUrl: currentUser.avatar_url,
       entrySlug: slug,
       timestamp: noteData.timestamp || new Date().toISOString(),