@diagrammo/dgmo 0.2.26 → 0.2.28

package/src/initiative-status/parser.ts

@@ -26,16 +26,20 @@ export function looksLikeInitiativeStatus(content: string): boolean {
   const lines = content.split('\n');
   let hasArrow = false;
   let hasStatus = false;
+  let hasIndentedArrow = false;
   for (const line of lines) {
     const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('//')) continue;
+    if (!trimmed || trimmed.startsWith('//')) continue;
     if (trimmed.match(/^chart\s*:/i)) continue;
     if (trimmed.match(/^title\s*:/i)) continue;
     if (trimmed.includes('->')) hasArrow = true;
     if (/\|\s*(done|wip|todo|na)\s*$/i.test(trimmed)) hasStatus = true;
+    // Indented arrow is a strong signal — only initiative-status uses this
+    const isIndented = line.length > 0 && line !== trimmed && /^\s/.test(line);
+    if (isIndented && (trimmed.startsWith('->') || /^-[^>].*->/.test(trimmed))) hasIndentedArrow = true;
     if (hasArrow && hasStatus) return true;
   }
-  return false;
+  return hasIndentedArrow;
 }
 
 // ============================================================
@@ -44,7 +48,7 @@ export function looksLikeInitiativeStatus(content: string): boolean {
 
 function parseStatus(raw: string, line: number, diagnostics: DgmoError[]): InitiativeStatus {
   const trimmed = raw.trim().toLowerCase();
-  if (!trimmed) return null;
+  if (!trimmed) return 'na';
   if (VALID_STATUSES.includes(trimmed)) return trimmed as InitiativeStatus;
 
   // Unknown status — emit warning with suggestion
@@ -64,12 +68,13 @@ export function parseInitiativeStatus(content: string): ParsedInitiativeStatus {
     groups: [],
     options: {},
     diagnostics: [],
-    error: undefined,
+    error: null,
   };
 
   const lines = content.split('\n');
   const nodeLabels = new Set<string>();
   let currentGroup: ISGroup | null = null;
+  let lastNodeLabel: string | null = null;
 
   for (let i = 0; i < lines.length; i++) {
     const lineNum = i + 1; // 1-based
@@ -77,7 +82,7 @@ export function parseInitiativeStatus(content: string): ParsedInitiativeStatus {
     const trimmed = raw.trim();
 
     // Skip blanks and comments
-    if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('//')) continue;
+    if (!trimmed || trimmed.startsWith('//')) continue;
 
     // chart: header
     const chartMatch = trimmed.match(/^chart\s*:\s*(.+)/i);
@@ -118,9 +123,20 @@ export function parseInitiativeStatus(content: string): ParsedInitiativeStatus {
       currentGroup = null;
     }
 
-    // Edge: contains `->`
+    // Edge: contains `->` or labeled form `-label->`
     if (trimmed.includes('->')) {
-      const edge = parseEdgeLine(trimmed, lineNum, result.diagnostics);
+      let edgeText = trimmed;
+      // Indented `-> Target` or `-label-> Target` shorthand
+      if (trimmed.startsWith('->') || /^-[^>].*->/.test(trimmed)) {
+        if (!lastNodeLabel) {
+          result.diagnostics.push(
+            makeDgmoError(lineNum, 'Indented edge has no preceding node to use as source', 'warning')
+          );
+          continue;
+        }
+        edgeText = `${lastNodeLabel} ${trimmed}`;
+      }
+      const edge = parseEdgeLine(edgeText, lineNum, result.diagnostics);
       if (edge) result.edges.push(edge);
       continue;
     }
@@ -128,6 +144,7 @@ export function parseInitiativeStatus(content: string): ParsedInitiativeStatus {
     // Node: everything else
     const node = parseNodeLine(trimmed, lineNum, result.diagnostics);
     if (node) {
+      lastNodeLabel = node.label;
       if (nodeLabels.has(node.label)) {
         result.diagnostics.push(
           makeDgmoError(lineNum, `Duplicate node "${node.label}"`, 'warning')
@@ -156,7 +173,7 @@ export function parseInitiativeStatus(content: string): ParsedInitiativeStatus {
       );
       // Auto-create an implicit node
       if (!result.nodes.some((n) => n.label === edge.source)) {
-        result.nodes.push({ label: edge.source, status: null, shape: inferParticipantType(edge.source), lineNumber: edge.lineNumber });
+        result.nodes.push({ label: edge.source, status: 'na', shape: inferParticipantType(edge.source), lineNumber: edge.lineNumber });
         nodeLabels.add(edge.source);
       }
     }
@@ -165,7 +182,7 @@ export function parseInitiativeStatus(content: string): ParsedInitiativeStatus {
         makeDgmoError(edge.lineNumber, `Edge target "${edge.target}" is not a declared node`, 'warning')
       );
       if (!result.nodes.some((n) => n.label === edge.target)) {
-        result.nodes.push({ label: edge.target, status: null, shape: inferParticipantType(edge.target), lineNumber: edge.lineNumber });
+        result.nodes.push({ label: edge.target, status: 'na', shape: inferParticipantType(edge.target), lineNumber: edge.lineNumber });
         nodeLabels.add(edge.target);
       }
     }
@@ -193,7 +210,7 @@ function parseNodeLine(
     const status = parseStatus(statusRaw, lineNum, diagnostics);
     return { label, status, shape: inferParticipantType(label), lineNumber: lineNum };
   }
-  return { label: trimmed, status: null, shape: inferParticipantType(trimmed), lineNumber: lineNum };
+  return { label: trimmed, status: 'na', shape: inferParticipantType(trimmed), lineNumber: lineNum };
 }
 
 function parseEdgeLine(
@@ -205,6 +222,35 @@ function parseEdgeLine(
   // or:     <source> -> <target> | <status>
   // or:     <source> -> <target>: <label>
   // or:     <source> -> <target>
+  // or:     <source> -<label>-> <target> [| <status>]
+
+  // Check for labeled arrow form: SOURCE -LABEL-> TARGET [| status]
+  const labeledMatch = trimmed.match(/^(\S+)\s+-(.+)->\s+(.+)$/);
+  if (labeledMatch) {
+    const source = labeledMatch[1];
+    const label = labeledMatch[2].trim();
+    let targetRest = labeledMatch[3].trim();
+
+    if (label) {
+      // Extract status from end (after last |)
+      let status: InitiativeStatus = 'na';
+      const lastPipe = targetRest.lastIndexOf('|');
+      if (lastPipe >= 0) {
+        const statusRaw = targetRest.slice(lastPipe + 1).trim();
+        status = parseStatus(statusRaw, lineNum, diagnostics);
+        targetRest = targetRest.slice(0, lastPipe).trim();
+      }
+
+      const target = targetRest.trim();
+      if (!target) {
+        diagnostics.push(makeDgmoError(lineNum, 'Edge is missing target'));
+        return null;
+      }
+
+      return { source, target, label, status, lineNumber: lineNum };
+    }
+    // Empty label — fall through to plain arrow parsing
+  }
 
   const arrowIdx = trimmed.indexOf('->');
   if (arrowIdx < 0) return null;
@@ -218,7 +264,7 @@ function parseEdgeLine(
   }
 
   // Extract status from end (after last |)
-  let status: InitiativeStatus = null;
+  let status: InitiativeStatus = 'na';
   const lastPipe = rest.lastIndexOf('|');
   if (lastPipe >= 0) {
     const statusRaw = rest.slice(lastPipe + 1).trim();

package/src/initiative-status/types.ts

@@ -39,5 +39,5 @@ export interface ParsedInitiativeStatus {
   groups: ISGroup[];
   options: Record<string, string>;
   diagnostics: DgmoError[];
-  error?: string;
+  error: string | null;
 }

package/src/kanban/parser.ts

@@ -1,7 +1,14 @@
-import { resolveColor } from '../colors';
 import type { PaletteColors } from '../palettes';
 import type { DgmoError } from '../diagnostics';
 import { makeDgmoError, formatDgmoError, suggest } from '../diagnostics';
+import { matchTagBlockHeading } from '../utils/tag-groups';
+import {
+  measureIndent,
+  extractColor,
+  CHART_TYPE_RE,
+  TITLE_RE,
+  OPTION_RE,
+} from '../utils/parsing';
 import type {
   ParsedKanban,
   KanbanColumn,
@@ -14,40 +21,7 @@ import type {
 // Regex patterns
 // ============================================================
 
-const CHART_TYPE_RE = /^chart\s*:\s*(.+)/i;
-const TITLE_RE = /^title\s*:\s*(.+)/i;
-const OPTION_RE = /^([a-z][a-z0-9-]*)\s*:\s*(.+)$/i;
-const GROUP_HEADING_RE =
-  /^##\s+(.+?)(?:\s+alias\s+(\w+))?(?:\s*\(([^)]+)\))?\s*$/;
 const COLUMN_RE = /^==\s+(.+?)\s*(?:\[wip:\s*(\d+)\])?\s*==$/;
-const COLOR_SUFFIX_RE = /\(([^)]+)\)\s*$/;
-
-// ============================================================
-// Helpers
-// ============================================================
-
-function measureIndent(line: string): number {
-  let indent = 0;
-  for (const ch of line) {
-    if (ch === ' ') indent++;
-    else if (ch === '\t') indent += 4;
-    else break;
-  }
-  return indent;
-}
-
-function extractColor(
-  label: string,
-  palette?: PaletteColors
-): { label: string; color?: string } {
-  const m = label.match(COLOR_SUFFIX_RE);
-  if (!m) return { label };
-  const colorName = m[1].trim();
-  return {
-    label: label.substring(0, m.index!).trim(),
-    color: resolveColor(colorName, palette),
-  };
-}
 
 // ============================================================
 // Parser
@@ -63,6 +37,7 @@ export function parseKanban(
     tagGroups: [],
     options: {},
     diagnostics: [],
+    error: null,
   };
 
   const fail = (line: number, message: string): ParsedKanban => {
@@ -146,10 +121,32 @@ export function parseKanban(
       }
     }
 
+    // Tag group heading — `tag: Name` (new) or `## Name` (deprecated)
+    // Must be checked BEFORE OPTION_RE to prevent `tag: Rank` being swallowed as option
+    if (!contentStarted) {
+      const tagBlockMatch = matchTagBlockHeading(trimmed);
+      if (tagBlockMatch) {
+        if (tagBlockMatch.deprecated) {
+          warn(lineNumber, `'## ${tagBlockMatch.name}' is deprecated for tag groups — use 'tag: ${tagBlockMatch.name}' instead`);
+        }
+        currentTagGroup = {
+          name: tagBlockMatch.name,
+          alias: tagBlockMatch.alias,
+          entries: [],
+          lineNumber,
+        };
+        if (tagBlockMatch.alias) {
+          aliasMap.set(tagBlockMatch.alias.toLowerCase(), tagBlockMatch.name.toLowerCase());
+        }
+        result.tagGroups.push(currentTagGroup);
+        continue;
+      }
+    }
+
     // Generic header options (key: value before content/tag groups)
     if (!contentStarted && !currentTagGroup && measureIndent(line) === 0) {
       const optMatch = trimmed.match(OPTION_RE);
-      if (optMatch && !trimmed.startsWith('##') && !COLUMN_RE.test(trimmed)) {
+      if (optMatch && !COLUMN_RE.test(trimmed)) {
         const key = optMatch[1].trim().toLowerCase();
         if (key !== 'chart' && key !== 'title') {
           result.options[key] = optMatch[2].trim();
@@ -158,24 +155,6 @@ export function parseKanban(
       }
     }
 
-    // ## Tag group heading
-    const groupMatch = trimmed.match(GROUP_HEADING_RE);
-    if (groupMatch && !contentStarted) {
-      const groupName = groupMatch[1].trim();
-      const alias = groupMatch[2] || undefined;
-      currentTagGroup = {
-        name: groupName,
-        alias,
-        entries: [],
-        lineNumber,
-      };
-      if (alias) {
-        aliasMap.set(alias.toLowerCase(), groupName.toLowerCase());
-      }
-      result.tagGroups.push(currentTagGroup);
-      continue;
-    }
-
     // Tag group entries (indented Value(color) [default] under ## heading)
     if (currentTagGroup && !contentStarted) {
       const indent = measureIndent(line);

package/src/kanban/renderer.ts

@@ -5,6 +5,7 @@
 import * as d3Selection from 'd3-selection';
 import { FONT_FAMILY } from '../fonts';
 import type { PaletteColors } from '../palettes';
+import { renderInlineText } from '../utils/inline-markdown';
 import type { ParsedKanban, KanbanColumn, KanbanCard, KanbanTagGroup } from './types';
 import { parseKanban } from './parser';
 import { isArchiveColumn } from './mutations';
@@ -498,14 +499,14 @@ export function renderKanban(
         .attr('stroke', cardStroke)
         .attr('stroke-width', CARD_STROKE_WIDTH);
 
-      // Card title
-      cg.append('text')
+      // Card title (inline markdown)
+      const titleEl = cg.append('text')
         .attr('x', cx + CARD_PADDING_X)
         .attr('y', cy + CARD_PADDING_Y + CARD_TITLE_FONT_SIZE)
         .attr('font-size', CARD_TITLE_FONT_SIZE)
         .attr('font-weight', '500')
-        .attr('fill', palette.text)
-        .text(card.title);
+        .attr('fill', palette.text);
+      renderInlineText(titleEl, card.title, palette, CARD_TITLE_FONT_SIZE);
 
       // Separator + metadata
       if (hasMeta) {
@@ -542,14 +543,14 @@ export function renderKanban(
           metaY += CARD_META_LINE_HEIGHT;
         }
 
-        // Detail lines
+        // Detail lines (inline markdown)
         for (const detail of card.details) {
-          cg.append('text')
+          const detailEl = cg.append('text')
             .attr('x', cx + CARD_PADDING_X)
             .attr('y', metaY)
             .attr('font-size', CARD_META_FONT_SIZE)
-            .attr('fill', palette.textMuted)
-            .text(detail);
+            .attr('fill', palette.textMuted);
+          renderInlineText(detailEl, detail, palette, CARD_META_FONT_SIZE);
 
           metaY += CARD_META_LINE_HEIGHT;
         }

package/src/kanban/types.ts

@@ -1,18 +1,10 @@
 import type { DgmoError } from '../diagnostics';
+import type { TagGroup, TagEntry } from '../utils/tag-groups';
 
-export interface KanbanTagEntry {
-  value: string;
-  color: string;
-  lineNumber: number;
-}
-
-export interface KanbanTagGroup {
-  name: string;
-  alias?: string;
-  entries: KanbanTagEntry[];
-  defaultValue?: string;
-  lineNumber: number;
-}
+/** @deprecated Use `TagEntry` from `utils/tag-groups` */
+export type KanbanTagEntry = TagEntry;
+/** @deprecated Use `TagGroup` from `utils/tag-groups` */
+export type KanbanTagGroup = TagGroup;
 
 export interface KanbanCard {
   id: string;
@@ -41,5 +33,5 @@ export interface ParsedKanban {
   tagGroups: KanbanTagGroup[];
   options: Record<string, string>;
   diagnostics: DgmoError[];
-  error?: string;
+  error: string | null;
 }

package/src/org/parser.ts

@@ -1,26 +1,25 @@
-import { resolveColor } from '../colors';
 import type { PaletteColors } from '../palettes';
 import type { DgmoError } from '../diagnostics';
 import { makeDgmoError, formatDgmoError, suggest } from '../diagnostics';
+import type { TagGroup, TagEntry } from '../utils/tag-groups';
+import { isTagBlockHeading, matchTagBlockHeading } from '../utils/tag-groups';
+import {
+  measureIndent,
+  extractColor,
+  parsePipeMetadata,
+  CHART_TYPE_RE,
+  TITLE_RE,
+  OPTION_RE,
+} from '../utils/parsing';
 
 // ============================================================
 // Types
 // ============================================================
 
-export interface OrgTagEntry {
-  value: string;
-  color: string;
-  lineNumber: number;
-}
-
-export interface OrgTagGroup {
-  name: string;
-  alias?: string;
-  entries: OrgTagEntry[];
-  /** Value of the entry marked `default` (nodes without metadata get this) */
-  defaultValue?: string;
-  lineNumber: number;
-}
+/** @deprecated Use `TagEntry` from `utils/tag-groups` */
+export type OrgTagEntry = TagEntry;
+/** @deprecated Use `TagGroup` from `utils/tag-groups` */
+export type OrgTagGroup = TagGroup;
 
 export interface OrgNode {
   id: string;
@@ -47,48 +46,19 @@ export interface ParsedOrg {
 // Helpers
 // ============================================================
 
-function measureIndent(line: string): number {
-  let indent = 0;
-  for (const ch of line) {
-    if (ch === ' ') indent++;
-    else if (ch === '\t') indent += 4;
-    else break;
-  }
-  return indent;
-}
-
-const COLOR_SUFFIX_RE = /\(([^)]+)\)\s*$/;
-
-function extractColor(
-  label: string,
-  palette?: PaletteColors
-): { label: string; color?: string } {
-  const m = label.match(COLOR_SUFFIX_RE);
-  if (!m) return { label };
-  const colorName = m[1].trim();
-  return {
-    label: label.substring(0, m.index!).trim(),
-    color: resolveColor(colorName, palette),
-  };
-}
-
-const GROUP_HEADING_RE = /^##\s+(.+?)(?:\s+alias\s+(\w+))?(?:\s*\(([^)]+)\))?\s*$/;
 const CONTAINER_RE = /^\[([^\]]+)\]$/;
 const METADATA_RE = /^([^:]+):\s*(.+)$/;
-const CHART_TYPE_RE = /^chart\s*:\s*(.+)/i;
-const TITLE_RE = /^title\s*:\s*(.+)/i;
-const OPTION_RE = /^([a-z][a-z0-9-]*)\s*:\s*(.+)$/i;
 
 // ============================================================
 // Inference
 // ============================================================
 
-/** Returns true if content contains tag group headings (`## ...`), suggesting an org chart. */
+/** Returns true if content contains tag group headings (`tag: …` or `## …`), suggesting an org chart. */
 export function looksLikeOrg(content: string): boolean {
   for (const line of content.split('\n')) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith('//')) continue;
-    if (GROUP_HEADING_RE.test(trimmed)) return true;
+    if (isTagBlockHeading(trimmed)) return true;
   }
   return false;
 }
@@ -125,6 +95,11 @@ export function parseOrg(
     if (!result.error) result.error = formatDgmoError(diag);
   };
 
+  /** Push a non-fatal warning (does not set result.error). */
+  const pushWarning = (line: number, message: string): void => {
+    result.diagnostics.push(makeDgmoError(line, message, 'warning'));
+  };
+
   if (!content || !content.trim()) {
     return fail(0, 'No content provided');
   }
@@ -189,41 +164,43 @@ export function parseOrg(
       }
     }
 
-    // Generic header options (key: value lines before content/tag groups)
-    // Only match non-indented lines with simple hyphenated keys
-    if (!contentStarted && !currentTagGroup && measureIndent(line) === 0) {
-      const optMatch = trimmed.match(OPTION_RE);
-      if (optMatch && !trimmed.startsWith('##')) {
-        const key = optMatch[1].trim().toLowerCase();
-        if (key !== 'chart' && key !== 'title') {
-          result.options[key] = optMatch[2].trim();
-          continue;
-        }
-      }
-    }
-
-    // ## Tag group heading
-    const groupMatch = trimmed.match(GROUP_HEADING_RE);
-    if (groupMatch) {
+    // Tag group heading — `tag: Name` (new) or `## Name` (deprecated)
+    // Must be checked BEFORE OPTION_RE to prevent `tag: Rank` being swallowed as option `tag=Rank`
+    const tagBlockMatch = matchTagBlockHeading(trimmed);
+    if (tagBlockMatch) {
       if (contentStarted) {
-        pushError(lineNumber, 'Tag groups (##) must appear before org content');
+        pushError(lineNumber, 'Tag groups must appear before org content');
         continue;
       }
-      const groupName = groupMatch[1].trim();
-      const alias = groupMatch[2] || undefined;
+      if (tagBlockMatch.deprecated) {
+        pushWarning(lineNumber, `'## ${tagBlockMatch.name}' is deprecated for tag groups — use 'tag: ${tagBlockMatch.name}' instead`);
+      }
       currentTagGroup = {
-        name: groupName,
-        alias,
+        name: tagBlockMatch.name,
+        alias: tagBlockMatch.alias,
         entries: [],
         lineNumber,
       };
-      if (alias) {
-        aliasMap.set(alias.toLowerCase(), groupName.toLowerCase());
+      if (tagBlockMatch.alias) {
+        aliasMap.set(tagBlockMatch.alias.toLowerCase(), tagBlockMatch.name.toLowerCase());
       }
       result.tagGroups.push(currentTagGroup);
       continue;
     }
 
+    // Generic header options (key: value lines before content/tag groups)
+    // Only match non-indented lines with simple hyphenated keys
+    if (!contentStarted && !currentTagGroup && measureIndent(line) === 0) {
+      const optMatch = trimmed.match(OPTION_RE);
+      if (optMatch) {
+        const key = optMatch[1].trim().toLowerCase();
+        if (key !== 'chart' && key !== 'title') {
+          result.options[key] = optMatch[2].trim();
+          continue;
+        }
+      }
+    }
+
     // Tag group entries (indented Value(color) [default] under ## heading)
     if (currentTagGroup && !contentStarted) {
       const indent = measureIndent(line);
@@ -342,24 +319,7 @@ function parseNodeLabel(
   let rawLabel = segments[0];
   const { label, color } = extractColor(rawLabel, palette);
 
-  const metadata: Record<string, string> = {};
-  // Collect all metadata parts: split pipe segments further on commas
-  const metaParts: string[] = [];
-  for (let j = 1; j < segments.length; j++) {
-    for (const part of segments[j].split(',')) {
-      const trimmedPart = part.trim();
-      if (trimmedPart) metaParts.push(trimmedPart);
-    }
-  }
-  for (const part of metaParts) {
-    const colonIdx = part.indexOf(':');
-    if (colonIdx > 0) {
-      const rawKey = part.substring(0, colonIdx).trim().toLowerCase();
-      const key = aliasMap.get(rawKey) ?? rawKey;
-      const value = part.substring(colonIdx + 1).trim();
-      metadata[key] = value;
-    }
-  }
+  const metadata = parsePipeMetadata(segments, aliasMap);
 
   return {
     id: `node-${counter}`,

package/src/org/resolver.ts

@@ -1,5 +1,6 @@
 import type { DgmoError } from '../diagnostics';
 import { makeDgmoError } from '../diagnostics';
+import { isTagBlockHeading, matchTagBlockHeading } from '../utils/tag-groups';
 
 // ============================================================
 // Types
@@ -25,7 +26,6 @@ const IMPORT_RE = /^(\s+)import:\s+(.+\.dgmo)\s*$/i;
 const TAGS_RE = /^tags:\s+(.+\.dgmo)\s*$/i;
 const HEADER_RE = /^(chart|title)\s*:/i;
 const OPTION_RE = /^[a-z][a-z0-9-]*\s*:/i;
-const GROUP_HEADING_RE = /^##\s+/;
 
 // ============================================================
 // Path Helpers (pure string ops — no Node `path` dependency)
@@ -67,10 +67,9 @@ function extractTagGroups(lines: string[]): TagGroupBlock[] {
 
   for (const line of lines) {
     const trimmed = line.trim();
-    if (GROUP_HEADING_RE.test(trimmed)) {
-      // Extract group name (everything after "## " up to optional alias/color)
-      const nameMatch = trimmed.match(/^##\s+(.+?)(?:\s+alias\s+\w+)?(?:\s*\([^)]+\))?\s*$/);
-      const name = nameMatch ? nameMatch[1].trim().toLowerCase() : trimmed.substring(3).trim().toLowerCase();
+    const headingMatch = matchTagBlockHeading(trimmed);
+    if (headingMatch) {
+      const name = headingMatch.name.toLowerCase();
       current = { name, lines: [line] };
       blocks.push(current);
     } else if (current) {
@@ -144,7 +143,7 @@ function parseFileHeader(lines: string[]): ParsedHeader {
       }
 
       // Other option-like header lines (non-indented key: value)
-      if (OPTION_RE.test(trimmed) && !trimmed.startsWith('##') && !lines[i].match(/^\s/)) {
+      if (OPTION_RE.test(trimmed) && !isTagBlockHeading(trimmed) && !lines[i].match(/^\s/)) {
         // Check it's not a content line (node with metadata)
         const key = trimmed.split(':')[0].trim().toLowerCase();
         if (key !== 'chart' && key !== 'title' && !trimmed.includes('|')) {
@@ -207,7 +206,7 @@ async function resolveFile(
       headerLines.push(lines[i]);
       continue;
     }
-    if (GROUP_HEADING_RE.test(trimmed)) continue; // skip inline tag group headings
+    if (isTagBlockHeading(trimmed)) continue; // skip inline tag group headings
     if (lines[i] !== trimmed) continue; // skip tag group entries (indented lines)
 
     const tagsMatch = trimmed.match(TAGS_RE);
@@ -248,7 +247,7 @@ async function resolveFile(
     if (!importMatch) {
       // Pass through — skip inline tag group lines (already extracted above)
       const trimmed = line.trim();
-      if (GROUP_HEADING_RE.test(trimmed) || (inlineTagGroups.length > 0 && isTagGroupEntry(line, bodyLines, i))) {
+      if (isTagBlockHeading(trimmed) || (inlineTagGroups.length > 0 && isTagGroupEntry(line, bodyLines, i))) {
         continue;
       }
       resolvedBodyLines.push(line);
@@ -386,7 +385,7 @@ function findBodyStart(lines: string[]): number {
     }
 
     // Tag group heading
-    if (GROUP_HEADING_RE.test(trimmed)) {
+    if (isTagBlockHeading(trimmed)) {
       inTagGroup = true;
       continue;
     }
@@ -405,7 +404,7 @@ function findBodyStart(lines: string[]): number {
     if (TAGS_RE.test(trimmed)) continue;
 
     // Option-like lines (non-indented key: value before content)
-    if (OPTION_RE.test(trimmed) && !lines[i].match(/^\s/) && !trimmed.includes('|')) {
+    if (OPTION_RE.test(trimmed) && !isTagBlockHeading(trimmed) && !lines[i].match(/^\s/) && !trimmed.includes('|')) {
       const key = trimmed.split(':')[0].trim().toLowerCase();
       if (key !== 'chart' && key !== 'title') {
         continue;
@@ -420,7 +419,7 @@ function findBodyStart(lines: string[]): number {
 }
 
 /**
- * Check if a line is a tag group entry (indented line under a ## heading).
+ * Check if a line is a tag group entry (indented line under a tag block heading).
  */
 function isTagGroupEntry(line: string, allLines: string[], index: number): boolean {
   if (!line.match(/^\s+/)) return false;
@@ -428,7 +427,7 @@ function isTagGroupEntry(line: string, allLines: string[], index: number): boole
   for (let i = index - 1; i >= 0; i--) {
     const prev = allLines[i].trim();
     if (prev === '' || prev.startsWith('//')) continue;
-    if (GROUP_HEADING_RE.test(prev)) return true;
+    if (isTagBlockHeading(prev)) return true;
     if (allLines[i].match(/^\s+/)) continue; // another entry
     return false;
   }