xdrs-core 0.22.0 → 0.23.0

package/.xdrs/_core/adrs/principles/004-article-standards.md

@@ -32,7 +32,7 @@ Articles are Markdown documents placed inside a subject folder alongside decisio
 - Sub-directories inside this `.assets/` folder are allowed only when it already has more than 10 files. Otherwise, keep files flat.
 - Always use lowercase file names.
 - Never use emojis in article content.
-- Articles should be kept under 5000 words. Move detailed content to referenced XDRs or Skills.
+- Articles should be kept under 5000 words. Move or point to detailed contents referenced in XDRs decisions, researches, plans or skills.
 
 **Folder layout**
 

package/lib/lint.js

@@ -28,6 +28,11 @@ const SKILL_PACKAGE_OPTIONAL_DIRS = new Set(['scripts', 'references', RESOURCE_D
 const XDR_ALLOWED_FRONTMATTER_KEYS = new Set(['name', 'description', 'apply-to', 'valid-from', 'license', 'metadata']);
 const SKILL_ALLOWED_FRONTMATTER_KEYS = new Set(['name', 'description', 'license', 'metadata', 'compatibility', 'allowed-tools']);
 const IMAGE_EXTENSIONS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.bmp']);
+const EMOJI_RE = /\p{Extended_Pictographic}/u;
+const XDR_MAX_WORDS = 2600;
+const ARTICLE_MAX_WORDS = 5000;
+const RESEARCH_MAX_WORDS = 5000;
+const SKILL_MAX_WORDS = 6500;
 
 function runLintCli(args) {
   if (args.includes('--help') || args.includes('-h')) {
@@ -331,6 +336,8 @@ function lintXdrFile(xdrsRoot, scopeName, typeName, filePath, xdrNumbers, errors
     || `${scopeName}-${TYPE_TO_ID[typeName]}-${number}-${match[2]}`;
   lintXdrFrontmatter(content, expectedName, filePath, errors);
   lintRequiredSections(content, filePath, XDR_REQUIRED_SECTIONS, 'XDR', errors);
+  lintNoEmojis(content, filePath, 'XDR', errors);
+  lintWordCount(content, filePath, 'XDR', XDR_MAX_WORDS, errors);
   lintDocumentLinks(filePath, xdrsRoot, scopeName, errors, externalScopes);
 }
 
@@ -367,11 +374,18 @@ function lintXdrFrontmatter(content, expectedName, filePath, errors) {
   }
   if (!fm.name) {
     errors.push(`XDR frontmatter must include a non-empty name field: ${toDisplayPath(filePath)}`);
-  } else if (fm.name !== expectedName) {
-    errors.push(`XDR frontmatter name must be "${expectedName}": ${toDisplayPath(filePath)}`);
+  } else {
+    if (fm.name !== expectedName) {
+      errors.push(`XDR frontmatter name must be "${expectedName}": ${toDisplayPath(filePath)}`);
+    }
+    if (fm.name.length > 64) {
+      errors.push(`XDR frontmatter name must be 64 characters or fewer: ${toDisplayPath(filePath)}`);
+    }
   }
   if (!fm.description) {
     errors.push(`XDR frontmatter must include a non-empty description field: ${toDisplayPath(filePath)}`);
+  } else if (fm.descriptionText && fm.descriptionText.length > 1024) {
+    errors.push(`XDR frontmatter description must be 1024 characters or fewer: ${toDisplayPath(filePath)}`);
   }
   if (fm.validFrom !== undefined) {
     if (!isIsoDate(fm.validFrom)) {
@@ -455,11 +469,18 @@ function lintSkillsDirectory(xdrsRoot, scopeName, typeName, subjectName, skillsP
     } else {
       if (!skillFm.name) {
         errors.push(`SKILL.md frontmatter must include a non-empty name field: ${toDisplayPath(skillFilePath)}`);
-      } else if (skillFm.name !== entry.name) {
-        errors.push(`Skill frontmatter name must match package directory "${entry.name}": ${toDisplayPath(skillFilePath)}`);
+      } else {
+        if (skillFm.name !== entry.name) {
+          errors.push(`Skill frontmatter name must match package directory "${entry.name}": ${toDisplayPath(skillFilePath)}`);
+        }
+        if (skillFm.name.length > 64) {
+          errors.push(`SKILL.md frontmatter name must be 64 characters or fewer: ${toDisplayPath(skillFilePath)}`);
+        }
       }
       if (!skillFm.description) {
         errors.push(`SKILL.md frontmatter must include a non-empty description field: ${toDisplayPath(skillFilePath)}`);
+      } else if (skillFm.descriptionText && skillFm.descriptionText.length > 1024) {
+        errors.push(`SKILL.md frontmatter description must be 1024 characters or fewer: ${toDisplayPath(skillFilePath)}`);
       }
       for (const key of skillFm.topLevelKeys) {
         if (!SKILL_ALLOWED_FRONTMATTER_KEYS.has(key)) {
@@ -468,6 +489,8 @@ function lintSkillsDirectory(xdrsRoot, scopeName, typeName, subjectName, skillsP
       }
     }
 
+    lintNoEmojis(skillContent, skillFilePath, 'Skill', errors);
+    lintWordCount(skillContent, skillFilePath, 'Skill', SKILL_MAX_WORDS, errors);
     lintDocumentLinks(skillFilePath, xdrsRoot, scopeName, errors, externalScopes);
     lintOrphanAssets(path.join(entryPath, RESOURCE_DIR_NAME), [skillFilePath], xdrsRoot, errors);
   }
@@ -519,6 +542,8 @@ function lintArticlesDirectory(xdrsRoot, scopeName, typeName, subjectName, artic
     }
 
     lintRequiredSections(content, entryPath, ARTICLE_REQUIRED_SECTIONS, 'Article', errors);
+    lintNoEmojis(content, entryPath, 'Article', errors);
+    lintWordCount(content, entryPath, 'Article', ARTICLE_MAX_WORDS, errors);
     lintDocumentLinks(entryPath, xdrsRoot, scopeName, errors, externalScopes);
   }
 
@@ -571,6 +596,9 @@ function lintResearchDirectory(xdrsRoot, scopeName, typeName, subjectName, resea
     }
 
     lintRequiredSections(content, entryPath, RESEARCH_REQUIRED_SECTIONS, 'Research', errors);
+    lintResearchIntroductionQuestion(content, entryPath, errors);
+    lintNoEmojis(content, entryPath, 'Research', errors);
+    lintWordCount(content, entryPath, 'Research', RESEARCH_MAX_WORDS, errors);
     lintDocumentLinks(entryPath, xdrsRoot, scopeName, errors, externalScopes);
   }
 
@@ -624,6 +652,7 @@ function lintPlansDirectory(xdrsRoot, scopeName, typeName, subjectName, plansPat
 
     lintRequiredSections(content, entryPath, PLAN_REQUIRED_SECTIONS, 'Plan', errors);
     lintPlanExpectedEndDate(content, entryPath, errors);
+    lintNoEmojis(content, entryPath, 'Plan', errors);
     lintDocumentLinks(entryPath, xdrsRoot, scopeName, errors, externalScopes);
   }
 
@@ -632,6 +661,52 @@ function lintPlansDirectory(xdrsRoot, scopeName, typeName, subjectName, plansPat
   return artifacts;
 }
 
+function lintNoEmojis(content, filePath, docType, errors) {
+  const lines = content.split(/\r?\n/);
+  const ignoredLines = findIgnoredMarkdownLines(lines);
+  for (let i = 0; i < lines.length; i++) {
+    if (ignoredLines[i]) continue;
+    if (EMOJI_RE.test(lines[i])) {
+      errors.push(`${docType} must not contain emojis: ${toDisplayPath(filePath)}:${i + 1}`);
+    }
+  }
+}
+
+function lintWordCount(content, filePath, docType, maxWords, errors) {
+  const body = stripFrontmatter(content);
+  const wordCount = countWords(body);
+  if (wordCount > maxWords) {
+    errors.push(`${docType} exceeds maximum word count of ${maxWords} (${wordCount} words): ${toDisplayPath(filePath)}`);
+  }
+}
+
+function lintResearchIntroductionQuestion(content, filePath, errors) {
+  const lines = content.split(/\r?\n/);
+  const ignoredLines = findIgnoredMarkdownLines(lines);
+  const introStart = findHeadingLine(lines, ignoredLines, '## Introduction');
+  if (introStart === -1) return; // Already caught by lintRequiredSections
+
+  let introEnd = lines.length;
+  for (let i = introStart + 1; i < lines.length; i++) {
+    if (!ignoredLines[i] && /^## /.test(lines[i].trim())) {
+      introEnd = i;
+      break;
+    }
+  }
+
+  let hasQuestion = false;
+  for (let i = introStart + 1; i < introEnd; i++) {
+    if (!ignoredLines[i] && lines[i].trim().startsWith('Question:')) {
+      hasQuestion = true;
+      break;
+    }
+  }
+
+  if (!hasQuestion) {
+    errors.push(`Research ## Introduction must contain a "Question:" line: ${toDisplayPath(filePath)}`);
+  }
+}
+
 const XDR_REQUIRED_SECTIONS = ['## Context and Problem Statement', '## Decision Outcome'];
 const ARTICLE_REQUIRED_SECTIONS = ['## Overview', '## Content', '## References'];
 const RESEARCH_REQUIRED_SECTIONS = ['## Abstract', '## Introduction', '## Methods', '## Results', '## Discussion', '## Conclusion', '## References'];
@@ -882,10 +957,33 @@ function shouldValidateResourceLink(rawTarget) {
     || IMAGE_EXTENSIONS.has(extension);
 }
 
+function extractDescriptionText(block) {
+  const lines = block.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const m = lines[i].match(/^description:\s*(.*)$/);
+    if (!m) continue;
+    const inlineValue = m[1].trim();
+    if (inlineValue && inlineValue !== '>' && inlineValue !== '|') {
+      return inlineValue;
+    }
+    // Block scalar: collect following indented lines
+    const bodyLines = [];
+    for (let j = i + 1; j < lines.length; j++) {
+      if (lines[j] === '' || /^\s+/.test(lines[j])) {
+        bodyLines.push(lines[j].trim());
+      } else {
+        break;
+      }
+    }
+    return bodyLines.join(' ').trim() || null;
+  }
+  return null;
+}
+
 function extractFrontmatter(content) {
   const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---(\r?\n|$)/);
   if (!match) {
-    return { present: false, name: null, description: false, validFrom: undefined, appliedTo: undefined, topLevelKeys: [] };
+    return { present: false, name: null, description: false, descriptionText: null, validFrom: undefined, appliedTo: undefined, topLevelKeys: [] };
   }
   const block = match[1];
   const nameMatch = block.match(/^name:\s*(.+)$/m);
@@ -896,10 +994,12 @@ function extractFrontmatter(content) {
     const keyMatch = line.match(/^([a-zA-Z][a-zA-Z0-9_-]*):\s*/);
     if (keyMatch) topLevelKeys.push(keyMatch[1]);
   }
+  const descriptionText = extractDescriptionText(block);
   return {
     present: true,
     name: nameMatch ? nameMatch[1].trim() || null : null,
     description: /^description:\s*\S/m.test(block),
+    descriptionText,
     validFrom: validFromMatch ? validFromMatch[1].trim() : undefined,
     appliedTo: appliedToMatch ? appliedToMatch[1].trim() : undefined,
     topLevelKeys,

package/lib/lint.test.js

@@ -919,4 +919,401 @@ test('falls back to .xdrs subdirectory when given path has no index.md', () => {
 
   expect(result.errors).toHaveLength(0);
   expect(result.xdrsRoot).toBe(path.join(workspaceRoot, '.xdrs'));
-});
+});
+
+// ─── Emoji checks ─────────────────────────────────────────────────────────────
+
+test('reports emoji in XDR document body', () => {
+  const workspaceRoot = createWorkspace('xdr-emoji-body', {
+    '.xdrs/index.md': rootIndex(),
+    '.xdrs/_local/adrs/index.md': localAdrIndex([
+      '- [001-main](principles/001-main.md) - Main decision'
+    ]),
+    '.xdrs/_local/adrs/principles/001-main.md': xdrDocument('This is great \uD83C\uDF89'),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).toContain('XDR must not contain emojis');
+});
+
+test('does not report emoji inside a code block in XDR documents', () => {
+  const workspaceRoot = createWorkspace('xdr-emoji-in-code-block', {
+    '.xdrs/index.md': rootIndex(),
+    '.xdrs/_local/adrs/index.md': localAdrIndex([
+      '- [001-main](principles/001-main.md) - Main decision'
+    ]),
+    '.xdrs/_local/adrs/principles/001-main.md': xdrDocument('```\necho "hello \uD83C\uDF89"\n```'),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).not.toContain('must not contain emojis');
+});
+
+test('reports emoji in SKILL.md', () => {
+  const workspaceRoot = createWorkspace('skill-emoji', {
+    '.xdrs/index.md': rootIndex(),
+    '.xdrs/_local/adrs/index.md': localAdrIndex([
+      '- [001-check-links](principles/skills/001-check-links/SKILL.md) - Check links'
+    ]),
+    '.xdrs/_local/adrs/principles/skills/001-check-links/SKILL.md': skillDocument('Step 1: do something \u2705'),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).toContain('Skill must not contain emojis');
+});
+
+test('reports emoji in article document', () => {
+  const workspaceRoot = createWorkspace('article-emoji', {
+    '.xdrs/index.md': rootIndex(),
+    '.xdrs/_local/adrs/index.md': localAdrIndex([
+      '- [001-guide](principles/articles/001-guide.md) - Guide'
+    ]),
+    '.xdrs/_local/adrs/principles/articles/001-guide.md': articleDocument('Nice overview \uD83D\uDE80'),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).toContain('Article must not contain emojis');
+});
+
+test('reports emoji in research document', () => {
+  const workspaceRoot = createWorkspace('research-emoji', {
+    '.xdrs/index.md': rootIndex(),
+    '.xdrs/_local/adrs/index.md': localAdrIndex([
+      '- [001-study](principles/researches/001-study.md) - Study'
+    ]),
+    '.xdrs/_local/adrs/principles/researches/001-study.md': researchDocument('Some finding \uD83D\uDD2C', 'Question: Is this right?'),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).toContain('Research must not contain emojis');
+});
+
+test('reports emoji in plan document', () => {
+  const workspaceRoot = createWorkspace('plan-emoji', {
+    '.xdrs/index.md': rootIndex(),
+    '.xdrs/_local/adrs/index.md': localAdrIndex([
+      '- [001-myplan](principles/plans/001-myplan.md) - My plan'
+    ]),
+    '.xdrs/_local/adrs/principles/plans/001-myplan.md': planDocument('Great plan \uD83C\uDFAF'),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).toContain('Plan must not contain emojis');
+});
+
+// ─── Name / description length ────────────────────────────────────────────────
+
+test('reports XDR frontmatter name exceeding 64 characters', () => {
+  const longName = '_local-adr-001-' + 'a'.repeat(50);
+  const workspaceRoot = createWorkspace('xdr-name-too-long', {
+    '.xdrs/index.md': rootIndex(),
+    '.xdrs/_local/adrs/index.md': localAdrIndex([
+      '- [001-main](principles/001-main.md) - Main decision'
+    ]),
+    '.xdrs/_local/adrs/principles/001-main.md': [
+      '---',
+      `name: ${longName}`,
+      'description: Test XDR document',
+      '---',
+      '',
+      '# _local-adr-001: Main decision',
+      '',
+      '## Context and Problem Statement',
+      '',
+      'Test body.',
+      '',
+      '## Decision Outcome',
+      '',
+      'Test decision outcome.',
+      ''
+    ].join('\n'),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).toContain('XDR frontmatter name must be 64 characters or fewer');
+});
+
+test('reports XDR frontmatter description exceeding 1024 characters', () => {
+  const workspaceRoot = createWorkspace('xdr-description-too-long', {
+    '.xdrs/index.md': rootIndex(),
+    '.xdrs/_local/adrs/index.md': localAdrIndex([
+      '- [001-main](principles/001-main.md) - Main decision'
+    ]),
+    '.xdrs/_local/adrs/principles/001-main.md': [
+      '---',
+      'name: _local-adr-001-main',
+      `description: ${'x'.repeat(1025)}`,
+      '---',
+      '',
+      '# _local-adr-001: Main decision',
+      '',
+      '## Context and Problem Statement',
+      '',
+      'Test body.',
+      '',
+      '## Decision Outcome',
+      '',
+      'Test decision outcome.',
+      ''
+    ].join('\n'),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).toContain('XDR frontmatter description must be 1024 characters or fewer');
+});
+
+test('reports SKILL.md frontmatter name exceeding 64 characters', () => {
+  const longName = '001-check-links-' + 'a'.repeat(50);
+  const workspaceRoot = createWorkspace('skill-name-too-long', {
+    '.xdrs/index.md': rootIndex(),
+    '.xdrs/_local/adrs/index.md': localAdrIndex([
+      '- [001-check-links](principles/skills/001-check-links/SKILL.md) - Check links'
+    ]),
+    '.xdrs/_local/adrs/principles/skills/001-check-links/SKILL.md': [
+      '---',
+      `name: ${longName}`,
+      'description: Test skill document',
+      '---',
+      '',
+      '## Overview',
+      '',
+      'Overview.',
+      '',
+      '## Instructions',
+      '',
+      'Instructions.',
+      ''
+    ].join('\n'),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).toContain('SKILL.md frontmatter name must be 64 characters or fewer');
+});
+
+test('reports SKILL.md frontmatter description exceeding 1024 characters', () => {
+  const workspaceRoot = createWorkspace('skill-description-too-long', {
+    '.xdrs/index.md': rootIndex(),
+    '.xdrs/_local/adrs/index.md': localAdrIndex([
+      '- [001-check-links](principles/skills/001-check-links/SKILL.md) - Check links'
+    ]),
+    '.xdrs/_local/adrs/principles/skills/001-check-links/SKILL.md': [
+      '---',
+      'name: 001-check-links',
+      `description: ${'x'.repeat(1025)}`,
+      '---',
+      '',
+      '## Overview',
+      '',
+      'Overview.',
+      '',
+      '## Instructions',
+      '',
+      'Instructions.',
+      ''
+    ].join('\n'),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).toContain('SKILL.md frontmatter description must be 1024 characters or fewer');
+});
+
+// ─── Word count ───────────────────────────────────────────────────────────────
+
+test('reports XDR document exceeding 2600 word limit', () => {
+  const longBody = ('word '.repeat(2601)).trimEnd();
+  const workspaceRoot = createWorkspace('xdr-too-many-words', {
+    '.xdrs/index.md': rootIndex(),
+    '.xdrs/_local/adrs/index.md': localAdrIndex([
+      '- [001-main](principles/001-main.md) - Main decision'
+    ]),
+    '.xdrs/_local/adrs/principles/001-main.md': xdrDocument(longBody),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).toContain('XDR exceeds maximum word count of 2600');
+});
+
+test('reports article exceeding 5000 word limit', () => {
+  const longBody = ('word '.repeat(5001)).trimEnd();
+  const workspaceRoot = createWorkspace('article-too-many-words', {
+    '.xdrs/index.md': rootIndex(),
+    '.xdrs/_local/adrs/index.md': localAdrIndex([
+      '- [001-guide](principles/articles/001-guide.md) - Guide'
+    ]),
+    '.xdrs/_local/adrs/principles/articles/001-guide.md': articleDocument(longBody),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).toContain('Article exceeds maximum word count of 5000');
+});
+
+test('reports research exceeding 5000 word limit', () => {
+  const longBody = ('word '.repeat(5001)).trimEnd();
+  const workspaceRoot = createWorkspace('research-too-many-words', {
+    '.xdrs/index.md': rootIndex(),
+    '.xdrs/_local/adrs/index.md': localAdrIndex([
+      '- [001-study](principles/researches/001-study.md) - Study'
+    ]),
+    '.xdrs/_local/adrs/principles/researches/001-study.md': researchDocument(longBody, 'Question: What is the answer?'),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).toContain('Research exceeds maximum word count of 5000');
+});
+
+test('reports SKILL.md exceeding 6500 word limit', () => {
+  const longBody = ('word '.repeat(6501)).trimEnd();
+  const workspaceRoot = createWorkspace('skill-too-many-words', {
+    '.xdrs/index.md': rootIndex(),
+    '.xdrs/_local/adrs/index.md': localAdrIndex([
+      '- [001-check-links](principles/skills/001-check-links/SKILL.md) - Check links'
+    ]),
+    '.xdrs/_local/adrs/principles/skills/001-check-links/SKILL.md': skillDocument(longBody),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).toContain('Skill exceeds maximum word count of 6500');
+});
+
+// ─── Files outside .assets in skill package root ────────────────────────────
+
+test('passes when extra files exist at skill package root', () => {
+  const workspaceRoot = createWorkspace('extra-skill-file', {
+    '.xdrs/index.md': rootIndex(),
+    '.xdrs/_local/adrs/index.md': localAdrIndex([
+      '- [001-check-links](principles/skills/001-check-links/SKILL.md) - Check links'
+    ]),
+    '.xdrs/_local/adrs/principles/skills/001-check-links/SKILL.md': skillDocument('Body.'),
+    '.xdrs/_local/adrs/principles/skills/001-check-links/extra.md': 'Allowed extra file',
+    '.xdrs/_local/adrs/principles/skills/001-check-links/schema.json': '{"type":"object"}',
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).not.toContain('extra.md');
+  expect(result.errors.join('\n')).not.toContain('schema.json');
+});
+
+// ─── Research Question: in Introduction ──────────────────────────────────────
+
+test('reports research ## Introduction missing Question: line', () => {
+  const workspaceRoot = createWorkspace('research-no-question', {
+    '.xdrs/index.md': rootIndex(),
+    '.xdrs/_local/adrs/index.md': localAdrIndex([
+      '- [001-study](principles/researches/001-study.md) - Study'
+    ]),
+    '.xdrs/_local/adrs/principles/researches/001-study.md': researchDocument('No question here.', null),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).toContain('Research ## Introduction must contain a "Question:" line');
+});
+
+test('passes when research ## Introduction contains Question: line', () => {
+  const workspaceRoot = createWorkspace('research-with-question', {
+    '.xdrs/index.md': rootIndex(),
+    '.xdrs/_local/adrs/index.md': localAdrIndex([
+      '- [001-study](principles/researches/001-study.md) - Study'
+    ]),
+    '.xdrs/_local/adrs/principles/researches/001-study.md': researchDocument('Some context.', 'Question: Is this the right approach?'),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).not.toContain('Research ## Introduction must contain');
+});
+
+// ─── New helpers ──────────────────────────────────────────────────────────────
+
+function articleDocument(body) {
+  return [
+    '# _local-article-001: Guide',
+    '',
+    '## Overview',
+    '',
+    'Overview text.',
+    '',
+    '## Content',
+    '',
+    body,
+    '',
+    '## References',
+    '',
+    '- No references.',
+    ''
+  ].join('\n');
+}
+
+function researchDocument(introBody, questionLine) {
+  const introSection = questionLine
+    ? `${introBody}\n\n${questionLine}`
+    : introBody;
+  return [
+    '# _local-research-001: Study',
+    '',
+    '## Abstract',
+    '',
+    'Single paragraph abstract.',
+    '',
+    '## Introduction',
+    '',
+    introSection,
+    '',
+    '## Methods',
+    '',
+    'Study methods.',
+    '',
+    '## Results',
+    '',
+    'Study results.',
+    '',
+    '## Discussion',
+    '',
+    'Discussion.',
+    '',
+    '## Conclusion',
+    '',
+    'Conclusion.',
+    '',
+    '## References',
+    '',
+    '- No references.',
+    ''
+  ].join('\n');
+}
+
+function planDocument(body) {
+  return [
+    '# _local-plan-001: My plan',
+    '',
+    '## Executive Summary',
+    '',
+    'Summary.',
+    '',
+    '## Context and Problem Statement',
+    '',
+    body,
+    '',
+    '## Proposed Solution',
+    '',
+    'We will fix it.',
+    '',
+    'Expected end date: 2026-12-31',
+    ''
+  ].join('\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xdrs-core",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "description": "A standard way to organize Decision Records (XDRs) across scopes, subjects, and teams so that AI agents can reliably query and follow them.",
   "repository": {
     "type": "git",