@@ -816,6 +816,9 @@ export type FrontMatterDocumentObject = { attributes: { [string]: string }, body
  * @returns {Object} - the frontmatter object (or empty object if none)
  */
 export function getSanitizedFmParts(noteText: string, removeTemplateTagsInFM?: boolean = false): FrontMatterDocumentObject {
+  const doubleDashFm = tryExtractLeadingDoubleDashFm(noteText || '')
+  if (doubleDashFm) return doubleDashFm
+
   let fmData = { attributes: {}, body: noteText, frontmatter: '' } //default
 
   // we need to pre-process the text to sanitize it instead of running fm because we need to
@@ -1468,6 +1471,12 @@ export async function getValuesForFrontmatterTag(
 
 /**
  * Analyze a template's structure to determine various characteristics
+ *
+ * **Output (new-note) frontmatter** may appear in `--` … `--` or `---` … `---` pairs only when the pair opens on
+ * the **first line of the template body** (the first line after the template’s own YAML frontmatter, if any).
+ * If the fenced region contains no valid YAML-like lines, it is **not** treated as frontmatter: the fences and
+ * everything between stay ordinary note content (e.g. horizontal rules and headings).
+ *
  * @param {string} templateData - The template content to analyze
  * @returns {Object} Analysis results with the following properties:
  *   - hasNewNoteTitle: boolean - Whether template has 'newNoteTitle' in frontmatter
@@ -1629,24 +1638,28 @@ export function analyzeTemplateStructure(templateData: string): {
 }
 
 /**
- * Helper function to find separator positions in an array of lines
- * Looks for both -- and --- separators
- * @param {Array<string>} lines - Array of lines to search
- * @param {number} startIndex - Index to start searching from (default: 0)
- * @returns {{startIndex: number, endIndex: number}} - Object with start and end indices, or {-1, -1} if not found
+ * Find the closing pair for an output-frontmatter fence starting at startIndex.
+ * Uses the **opening line’s** delimiter: `---` pairs with the next `---` only; `--` pairs with the next `--` only.
+ * (Searching for `--` first broke `---` bodies that contained a standalone `--` line.)
+ * @param {Array<string>} lines - Lines to search
+ * @param {number} startIndex - Line index of the opening `--` or `---`
+ * @returns {{startIndex: number, endIndex: number}}
  */
 function findSeparatorPositions(lines: Array<string>, startIndex: number = 0): { startIndex: number, endIndex: number } {
-  // First try to find -- separators
-  let startPos = lines.indexOf('--', startIndex)
-  let endPos = startPos >= 0 ? lines.indexOf('--', startPos + 1) : -1
-
-  // If no -- separators found, try to find --- separators
-  if (startPos === -1) {
-    startPos = lines.indexOf('---', startIndex)
-    endPos = startPos >= 0 ? lines.indexOf('---', startPos + 1) : -1
+  const first = (lines[startIndex] || '').trim()
+  if (first === '---') {
+    const startPos = startIndex
+    const rel = lines.slice(startPos + 1).findIndex((l) => l.trim() === '---')
+    if (rel < 0) return { startIndex: -1, endIndex: -1 }
+    return { startIndex: startPos, endIndex: startPos + 1 + rel }
   }
-
-  return { startIndex: startPos, endIndex: endPos }
+  if (first === '--') {
+    const startPos = startIndex
+    const rel = lines.slice(startPos + 1).findIndex((l) => l.trim() === '--')
+    if (rel < 0) return { startIndex: -1, endIndex: -1 }
+    return { startIndex: startPos, endIndex: startPos + 1 + rel }
+  }
+  return { startIndex: -1, endIndex: -1 }
 }
 
 /**
@@ -1694,6 +1707,27 @@ function extractAndParseFrontmatter(lines: Array<string>, startIndex: number, en
   return { attributes: {}, isValid: false }
 }
 
+/**
+ * `front-matter` does not recognize `--` fences. When the document starts with `--` … `--` and the inner region is
+ * YAML-like output frontmatter, parse it here so render/new-note logic matches `---` behavior.
+ * If the inner region is not valid YAML-like content, return null so the whole string stays body text.
+ * @param {string} noteText - Full template or fragment
+ * @returns {FrontMatterDocumentObject | null}
+ */
+function tryExtractLeadingDoubleDashFm(noteText: string): FrontMatterDocumentObject | null {
+  const lines = (noteText || '').split('\n')
+  if (lines.length < 2 || lines[0].trim() !== '--') return null
+
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].trim() !== '--') continue
+    const { attributes, isValid } = extractAndParseFrontmatter(lines, 0, i)
+    if (!isValid) return null
+    const body = lines.slice(i + 1).join('\n')
+    return { attributes, body, frontmatter: '' }
+  }
+  return null
+}
+
 /**
  * Helper function to get the folder path array from a note's filename
  * @param {string} filename - The note's filename
@@ -2006,6 +2040,8 @@ export function getNoteTitleFromRenderedContent(renderedContent: string): string
 
 /**
  * Check if content between --- markers is valid YAML-like content
+ * Headings like `## Event:**` contain a colon and used to match the `key:` heuristic; a note body
+ * wrapped in `---` / `---` (horizontal rules) was then mistaken for YAML, producing an empty body after parse.
  * @param {string} content - The content to validate
  * @returns {boolean} - Whether the content is valid YAML-like frontmatter
  */
@@ -2022,6 +2058,9 @@ export function isValidYamlContent(content: string): boolean {
     const trimmedLine = line.trim()
     if (trimmedLine === '') continue // Skip empty lines
 
+    // Markdown ATX headings (# … ###### ) can include colons (e.g. "## Event:**"); do not treat as YAML.
+    if (/^#{1,6}\s/.test(trimmedLine)) continue
+
     // Check for valid YAML patterns:
     // 1. key: value (with optional spaces) - allows hyphens and spaces in key names
     // 2. key: (empty value) - allows hyphens and spaces in key names
 
@@ -699,6 +699,66 @@ Some content here`
     })
   })
 
+  describe('output frontmatter: -- and --- only when first body line + valid YAML', () => {
+    test('treats --- … --- at body start as content when inner is not YAML (e.g. headings / HR)', () => {
+      const template = `---
+title: Template FM
+---
+---
+## Event:** note
+
+### Agenda
+-
+---
+After`
+      const result = analyzeTemplateStructure(template)
+
+      expect(result.hasOutputFrontmatter).toBe(false)
+      expect(result.outputFrontmatter).toEqual({})
+      expect(result.bodyContent).toContain('## Event:** note')
+      expect(result.bodyContent).toContain('After')
+    })
+
+    test('parses valid new-note frontmatter in -- … -- when first body line opens the fence', () => {
+      const template = `---
+title: Template FM
+---
+--
+noteTitle: From output FM
+type: project
+--
+# Hello`
+
+      const result = analyzeTemplateStructure(template)
+
+      expect(result.hasOutputFrontmatter).toBe(true)
+      expect(result.outputFrontmatter.noteTitle).toBe('From output FM')
+      expect(result.outputFrontmatter.type).toBe('project')
+      expect(result.bodyContent).toContain('noteTitle: From output FM')
+      expect(result.bodyContent).toContain('# Hello')
+    })
+
+    test('pairs closing --- with next --- even if body contains a standalone -- line', () => {
+      const template = `---
+t: 1
+---
+---
+middle: kept
+--
+not-closing-triple
+---
+end body`
+
+      const result = analyzeTemplateStructure(template)
+
+      expect(result.hasOutputFrontmatter).toBe(true)
+      expect(result.outputFrontmatter.middle).toBe('kept')
+      expect(result.bodyContent).toContain('--')
+      expect(result.bodyContent).toContain('not-closing-triple')
+      expect(result.bodyContent).toContain('end body')
+    })
+  })
+
   describe('template vs rendered content handling', () => {
     test('should detect inline title from template content with EJS tags (current behavior)', () => {
       const templateWithEJS = `---
 
@@ -161,6 +161,34 @@ describe(`${PLUGIN_NAME}`, () => {
         expect(result).toBe(false)
       })
 
+      test('should return false when only YAML-looking lines are markdown headings with colons (e.g. ## Event:**)', () => {
+        const markdownBetweenDashes = `## Event:**  <%- calendarItemLink %>
+
+### Agenda
+-
+### Meeting Minutes
+-
+### Action Items
+*`
+        const result = f.isValidYamlContent(markdownBetweenDashes)
+        expect(result).toBe(false)
+      })
+
+      test('getSanitizedFmParts strips leading -- fence when inner is valid YAML', () => {
+        const doc = `--\ntitle: Double Dash FM\ntype: test\n--\nRest`
+        const result = f.getSanitizedFmParts(doc)
+        expect(result.attributes.title).toBe('Double Dash FM')
+        expect(result.attributes.type).toBe('test')
+        expect(result.body).toBe('Rest')
+      })
+
+      test('getSanitizedFmParts leaves full text as body when leading -- fence inner is not YAML', () => {
+        const doc = `--\n## Nope:**\n--\nTail`
+        const result = f.getSanitizedFmParts(doc)
+        expect(result.attributes).toEqual({})
+        expect(result.body).toBe(doc)
+      })
+
       test('should return true for complex real-world examples', () => {
         const yamlContent = `title: Meeting Note
 note-tag: #meeting
 
@@ -6,6 +6,22 @@ See Plugin [Documentation](https://noteplan.co/templates/docs) for details on av
 
 DBW: REMEMBER THAT IF YOU ADDED ANY HELPERS IMPORTS, ADD THEM TO THE HELPER MODULE TO GIVE SCRIPTS ACCESS TO THEM ALSO
 
+## [2.4.2] 2026-05-14 @dwertheimer
+
+### Fixed
+
+- **`isValidYamlContent` vs markdown headings:** Headings such as `## Event:**` include a colon and were counted as YAML key lines. A template body framed with `---` horizontal rules (start and end) was then misclassified as a frontmatter block, `parse` returned an empty body, and Meeting Notes / renders produced no output. Markdown ATX heading lines (`#` … `######` followed by whitespace) are ignored for YAML detection so `---` around normal note text is not treated as frontmatter.
+
+### Changed
+
+- **New-note / output frontmatter rules:** Fences at the **first line of the template body** (after the template’s own YAML frontmatter) may use `--` or `---`. The enclosed region is treated as output frontmatter **only** if it is YAML-like (`isValidYamlContent`); otherwise the fences and text between stay normal content. Closing delimiter pairs match the opener (`---` with the next `---`, not an intervening `--` line). Leading `--` blocks are parsed in `getSanitizedFmParts` because `front-matter` ignores `--` fences. `FrontmatterModule.isFrontmatterTemplate` accepts both `--` and `---` openers with the same YAML gate.
+
+### Edited in this release
+
+- `helpers/NPFrontMatter.js`, `helpers/__tests__/NPFrontMatter/NPFrontMatterMisc.test.js`, `helpers/__tests__/NPFrontMatter/NPFrontMatter.analyzeTemplateStructure.test.js`
+- `np.Templating/lib/support/modules/FrontmatterModule.js`
+- `np.Templating/CHANGELOG.md`, `np.Templating/plugin.json` — version **2.4.2**
+
 ## [2.4.1] 2026-05-03 @dwertheimer
 
 ### Fixed
 
@@ -30,20 +30,35 @@ export default class FrontmatterModule {
     }
   }
 
+  /**
+   * Whether the string begins with a `--` or `---` fence whose inner lines are YAML-like (see `isValidYamlContent`).
+   * If the inner region is not YAML (e.g. markdown / HRs only), returns false so the text is treated as body content.
+   * @param {string} templateData - Note or template fragment (often starts at the first line).
+   * @returns {boolean}
+   */
   isFrontmatterTemplate(templateData: string): boolean {
-    // First check if the template has the frontmatter structure (starts with --- and has another ---)
-    if (!templateData.startsWith('---')) return false
-    const lines = templateData.split('\n')
-    if (lines.length >= 2 && lines[0].trim() === '---') {
-      // Find the second --- separator
+    // Opening fence must be first line: `---` … `---` or `--` … `--` (output FM / template FM).
+    // Inner region must be YAML-like; otherwise the whole thing is plain content (e.g. HRs around markdown).
+    const lines = (templateData || '').split('\n')
+    if (lines.length < 2) return false
+    const head = lines[0]?.trim() || ''
+    if (head === '---') {
       for (let i = 1; i < lines.length; i++) {
         if (lines[i].trim() === '---') {
-          // Now validate that the content between the --- markers is actually YAML-like
-          // Extract the content between the first and second ---
-          const frontmatterContent = lines.slice(1, i).join('\n')
-          return isValidYamlContent(frontmatterContent)
+          const inner = lines.slice(1, i).join('\n')
+          return isValidYamlContent(inner)
+        }
+      }
+      return false
+    }
+    if (head === '--') {
+      for (let i = 1; i < lines.length; i++) {
+        if (lines[i].trim() === '--') {
+          const inner = lines.slice(1, i).join('\n')
+          return isValidYamlContent(inner)
         }
       }
+      return false
     }
     return false
   }
 
@@ -3,9 +3,9 @@
   "noteplan.minAppVersion": "3.21",
   "plugin.id": "np.Templating",
   "plugin.name": "📒 Templating",
-  "plugin.version": "2.4.1",
+  "plugin.version": "2.4.2",
   "plugin.releaseStatus": "beta",
-  "plugin.lastUpdateInfo": "2.4.1: Fix TemplateRunner replaceHeading with <current> so location: replace + replaceHeading: true removes the target heading.\n2.4.0: TemplateRunner getNoteTitled calendar targets — rendered dates (YYYY-MM-DD, YYYY-MM, YYYY-Qn, YYYY) and new relative tokens; preserves YAML false/0 in frontmatter parsing.\n2.3.2: Frontmatter onePromptAtATime / batchPrompts false — disable auto Command Bar batching per template.\n2.3.1: promptForm({ ... }) — explicit single-tag Command Bar form; docs on PromptCommandBarForms / PromptCommands.\n2.3.0: Minor release — min NotePlan 3.21; Command Bar multi-field forms for batched prompts. Docs: https://noteplan.co/templates/docs\n2.2.10: templateRunner run-from-code for newNoteTitle; return null when nothing executed so Forms shows error.\n2.2.9: Add triggerTemplateRunner command to automatically run templates when notes are opened\n- New hidden command triggerTemplateRunner checks for runTemplateOnOpen frontmatter attribute\n- When a note with runTemplateOnOpen is opened, the specified template is automatically executed\n- Use triggers: onOpen => np.Templating.triggerTemplateRunner in note frontmatter to enable\n2.2.7: templateRunnerExecute now returns AI analysis errors from all code paths\n- Modified templateRunnerExecute to return Promise<string | void> instead of Promise<void>\n- Added hasAiAnalysisError helper function to detect AI analysis error marker\n- Updated all handler functions (handleCurrentNote, handleRegularNote, handleTodayNote, handleWeeklyNote) to return errors\n- Updated handleNewNoteCreation to return rendered content if it contains AI analysis error\n- All early return paths in templateRunnerExecute now check for and return AI analysis errors\n- This allows Forms plugin to capture and display template rendering errors to users\n2.2.6: (previous version)\n2.2.5: fix messaging in templateNew when templates not found\n- Support template:ignore code blocks in templates\n2.2.4: fix <default> templateLocale setting to allow for locale-specific date/time formatting\n2.2.3: add new weather formatting fields (location.*, :formatted: etc.",
+  "plugin.lastUpdateInfo": "2.4.2: Output frontmatter only when body starts with --/--- and inner is YAML-like; --- pairs ignore embedded -- lines; getSanitizedFmParts parses leading -- fences; isValidYamlContent skips ATX headings (--- HR around markdown).\n2.4.1: Fix TemplateRunner replaceHeading with <current> so location: replace + replaceHeading: true removes the target heading; TemplateRunner debug logging for large bodies.\n2.4.0: TemplateRunner getNoteTitled calendar targets — rendered dates (YYYY-MM-DD, YYYY-MM, YYYY-Qn, YYYY) and new relative tokens; preserves YAML false/0 in frontmatter parsing.\n2.3.2: Frontmatter onePromptAtATime / batchPrompts false — disable auto Command Bar batching per template.\n2.3.1: promptForm({ ... }) — explicit single-tag Command Bar form; docs on PromptCommandBarForms / PromptCommands.\n2.3.0: Minor release — min NotePlan 3.21; Command Bar multi-field forms for batched prompts. Docs: https://noteplan.co/templates/docs\n2.2.10: templateRunner run-from-code for newNoteTitle; return null when nothing executed so Forms shows error.\n2.2.9: Add triggerTemplateRunner command to automatically run templates when notes are opened\n- New hidden command triggerTemplateRunner checks for runTemplateOnOpen frontmatter attribute\n- When a note with runTemplateOnOpen is opened, the specified template is automatically executed\n- Use triggers: onOpen => np.Templating.triggerTemplateRunner in note frontmatter to enable\n2.2.7: templateRunnerExecute now returns AI analysis errors from all code paths\n- Modified templateRunnerExecute to return Promise<string | void> instead of Promise<void>\n- Added hasAiAnalysisError helper function to detect AI analysis error marker\n- Updated all handler functions (handleCurrentNote, handleRegularNote, handleTodayNote, handleWeeklyNote) to return errors\n- Updated handleNewNoteCreation to return rendered content if it contains AI analysis error\n- All early return paths in templateRunnerExecute now check for and return AI analysis errors\n- This allows Forms plugin to capture and display template rendering errors to users\n2.2.6: (previous version)\n2.2.5: fix messaging in templateNew when templates not found\n- Support template:ignore code blocks in templates\n2.2.4: fix <default> templateLocale setting to allow for locale-specific date/time formatting\n2.2.3: add new weather formatting fields (location.*, :formatted: etc.",
   "plugin.description": "Templating Plugin for NotePlan",
   "plugin.author": "Mike Erickson (@codedungeon) and David Wertheimer (@dwertheimer)",
   "plugin.dependencies": [],