@@ -220,6 +220,35 @@ export function loadExistingEntriesFromString(content: string): {
   return { entries, coveredUrls }
 }
 
+export function isSameNoteEntry(a: NoteEntry, b: NoteEntry): boolean {
+  return (
+    a.sourceUrl === b.sourceUrl &&
+    a.heading === b.heading &&
+    a.notes.length === b.notes.length &&
+    a.notes.every((n, idx) => n === b.notes[idx])
+  )
+}
+
+// Mutate in place because the Ctrl+C flush closure holds a reference to this array.
+// With no new entries, keep the existing ones so a failed regeneration does not delete a note.
+// Returns how many unique entries were added, since agent output can repeat an entry.
+export function replaceEntriesForSource(
+  entries: NoteEntry[],
+  sourceUrl: string,
+  newEntries: NoteEntry[],
+): number {
+  if (newEntries.length === 0) return 0
+  for (let i = entries.length - 1; i >= 0; i--) {
+    if (entries[i].sourceUrl === sourceUrl) entries.splice(i, 1)
+  }
+  const unique: NoteEntry[] = []
+  for (const entry of newEntries) {
+    if (!unique.some((u) => isSameNoteEntry(u, entry))) unique.push(entry)
+  }
+  entries.push(...unique)
+  return unique.length
+}
+
 export function appendNoteLines(lines: string[], noteEntries: NoteEntry[], indent: string): void {
   for (const entry of noteEntries) {
     lines.push(`${indent}# ${entry.sourceUrl}`)
 
@@ -21,6 +21,8 @@ import {
   extractPreservedBlocks,
   buildReleaseNotesYaml,
   appendNoteLines,
+  isSameNoteEntry,
+  replaceEntriesForSource,
 } from '@/ghes-releases/lib/parse-release-notes'
 import {
   type IssueState,
@@ -577,14 +579,12 @@ program
         preserved = extractPreservedBlocks(existingContent) ?? undefined
         const existing = loadExistingEntriesFromString(existingContent)
         if (existing.entries.length > 0) {
-          // Regenerate a single issue by dropping its previous source URL entry first.
+          // Keep the issue's current entry until the agent produces a replacement.
           if (singleIssue) {
-            const issueUrl = `https://github.com/github/releases/issues/${singleIssue}`
-            const kept = existing.entries.filter((e) => e.sourceUrl !== issueUrl)
-            allEntries.push(...kept)
-            existing.coveredUrls.delete(issueUrl)
-            existingCoveredUrls = existing.coveredUrls
-            console.log(`  Loaded ${kept.length} existing note(s), will regenerate #${singleIssue}`)
+            allEntries.push(...existing.entries)
+            console.log(
+              `  Loaded ${existing.entries.length} existing note(s), will regenerate #${singleIssue}`,
+            )
           } else {
             allEntries.push(...existing.entries)
             existingCoveredUrls = existing.coveredUrls
@@ -622,12 +622,14 @@ program
 
       const failures: { issue: ReleaseIssue; error: string }[] = []
       const existingEntryCount = allEntries.length
+      let newCount = 0
 
       const featureHeadings = loadFeatureHeadings()
 
       // Flush after each success and on Ctrl+C so long runs keep completed notes.
       const writeCurrentOutput = () => {
-        if (stdout || allEntries.length === 0) return
+        // Skip when nothing is new because rebuilding drops known issues, the date, and stacked source URL comments.
+        if (stdout || newCount === 0) return
         try {
           if (!fs.existsSync(outputDir)) {
             fs.mkdirSync(outputDir, { recursive: true })
@@ -688,17 +690,16 @@ program
             }
           }
 
-          // Avoid duplicates when an existing file already contributed the same issue note.
-          for (const entry of entries) {
-            const isDuplicate = allEntries.some(
-              (existing) =>
-                existing.sourceUrl === entry.sourceUrl &&
-                existing.heading === entry.heading &&
-                existing.notes.length === entry.notes.length &&
-                existing.notes.every((n, idx) => n === entry.notes[idx]),
-            )
-            if (!isDuplicate) {
-              allEntries.push(entry)
+          if (singleIssue) {
+            newCount += replaceEntriesForSource(allEntries, issue.url, entries)
+          } else {
+            // Avoid duplicates when an existing file already contributed the same issue note.
+            for (const entry of entries) {
+              const isDuplicate = allEntries.some((existing) => isSameNoteEntry(existing, entry))
+              if (!isDuplicate) {
+                allEntries.push(entry)
+                newCount++
+              }
             }
           }
           const retryNote = result.attempts > 1 ? ` (attempt ${result.attempts})` : ''
@@ -734,10 +735,9 @@ program
       }
 
       flushBeforeExit = null
-      const newCount = allEntries.length - existingEntryCount
       if (existingEntryCount > 0) {
         console.log(
-          `\nTotal: ${allEntries.length} note(s) (${existingEntryCount} existing + ${newCount} new from ${issues.length} issues)`,
+          `\nTotal: ${allEntries.length} note(s) (${allEntries.length - newCount} existing + ${newCount} new from ${issues.length} issues)`,
         )
       } else {
         console.log(`\nGenerated ${allEntries.length} note(s) from ${issues.length} issues`)
@@ -774,11 +774,11 @@ program
           console.log('\n--- Generated YAML ---\n')
           console.log(yamlOutput)
         }
-      } else if (allEntries.length > 0) {
+      } else if (newCount > 0) {
         writeCurrentOutput()
         console.log(`\n✅ Written to: ${path.relative(process.cwd(), outputPath)}`)
       } else {
-        console.log('\nNo entries generated — no file written.')
+        console.log('\nNo new notes generated. No file written.')
       }
 
       // Clean up stdin raw mode so the process can exit gracefully.
 
@@ -8,6 +8,7 @@ import {
   loadExistingEntriesFromString,
   extractPreservedBlocks,
   buildReleaseNotesYaml,
+  replaceEntriesForSource,
 } from '@/ghes-releases/lib/parse-release-notes'
 
 const handEditedFile = `date: '2026-05-12'
@@ -534,3 +535,64 @@ sections:
     ])
   })
 })
+
+describe('replaceEntriesForSource', () => {
+  const urlA = 'https://github.com/github/releases/issues/1'
+  const urlB = 'https://github.com/github/releases/issues/2'
+
+  test('replaces entries for the source URL and keeps other entries and array identity', () => {
+    const entries = [
+      { heading: 'Repositories', notes: ['Old A note.'], sourceUrl: urlA },
+      { heading: 'APIs', notes: ['B note.'], sourceUrl: urlB },
+      { heading: 'Changes', notes: ['Old A change.'], sourceUrl: urlA },
+    ]
+    const original = entries
+    const added = replaceEntriesForSource(entries, urlA, [
+      { heading: 'Repositories', notes: ['New A note.'], sourceUrl: urlA },
+    ])
+
+    expect(added).toBe(1)
+    expect(entries).toBe(original)
+    expect(entries).toEqual([
+      { heading: 'APIs', notes: ['B note.'], sourceUrl: urlB },
+      { heading: 'Repositories', notes: ['New A note.'], sourceUrl: urlA },
+    ])
+  })
+
+  test('appends new entries when no existing entry matches the source URL', () => {
+    const entries = [{ heading: 'APIs', notes: ['B note.'], sourceUrl: urlB }]
+    replaceEntriesForSource(entries, urlA, [
+      { heading: 'Repositories', notes: ['A note.'], sourceUrl: urlA },
+    ])
+
+    expect(entries).toEqual([
+      { heading: 'APIs', notes: ['B note.'], sourceUrl: urlB },
+      { heading: 'Repositories', notes: ['A note.'], sourceUrl: urlA },
+    ])
+  })
+
+  test('keeps existing entries when there are no new entries', () => {
+    const entries = [
+      { heading: 'Repositories', notes: ['Old A note.'], sourceUrl: urlA },
+      { heading: 'APIs', notes: ['B note.'], sourceUrl: urlB },
+    ]
+    expect(replaceEntriesForSource(entries, urlA, [])).toBe(0)
+
+    expect(entries).toEqual([
+      { heading: 'Repositories', notes: ['Old A note.'], sourceUrl: urlA },
+      { heading: 'APIs', notes: ['B note.'], sourceUrl: urlB },
+    ])
+    const yaml = buildReleaseNotesYaml(entries, false, ['Repositories', 'APIs'])
+    expect(yaml).toContain(`# ${urlA}`)
+    expect(yaml).toContain('Old A note.')
+  })
+
+  test('adds identical new entries only once', () => {
+    const entries = [{ heading: 'Repositories', notes: ['Old A note.'], sourceUrl: urlA }]
+    const repeated = { heading: 'Repositories', notes: ['New A note.'], sourceUrl: urlA }
+    const added = replaceEntriesForSource(entries, urlA, [repeated, { ...repeated }])
+
+    expect(added).toBe(1)
+    expect(entries).toEqual([repeated])
+  })
+})