xdrs-core 0.45.0 → 0.46.1

package/.xdrs/_core/index.md

@@ -45,6 +45,10 @@ Each artifact type has its own writing standard:
 
 Slide presentations that support XDRS documents follow [_core-adr-policy-009](adrs/principles/009-presentation-standards.md). Slides use the Marp Markdown format, live in `.assets/` next to the document they support, and must maintain bidirectional links with the parent document.
 
+### Media and asset standards
+
+[_core-adr-policy-020](adrs/principles/020-media-and-asset-standards.md) defines the canonical preference order for representing visual information across all XDRS document types: Markdown → ASCII → Mermaid → draw.io → SVG → PNG. It also defines where non-Markdown files must be stored (`.assets/` sibling folder) and prohibits policy content from living inside asset files. All document-type policies and write-* skills reference this policy instead of repeating these rules independently.
+
 ### Standard scope meta governance
 
 [_core-adr-policy-010](adrs/principles/010-scope-governance.md) defines the full scope governance model: how to define a custom scope type using `{scope-type}-scope-type` policies, how to define scope-local content standards using local meta-policies (`NNN-core.md` or `NNN-core-{qualifier}.md` in `principles/`), and how all governance mechanisms (`follows:`, scope-type standards, local meta-policies) apply with their precedence chain.

package/README.md

@@ -12,6 +12,10 @@ Policies capture Architectural (ADR), Business (BDR), and Engineering (EDR) deci
 
 This project defines a standard for organizing XDRS that satisfies the following requirements.
 
+## Overview
+
+![XDRS Overview Diagram](.xdrs/_core/adrs/principles/articles/.assets/001-xdrs-overview.svg)
+
 ## XDRS elements
 
 A traditional Decision Record normally combines several concerns in the same document:

package/lib/lint.js

@@ -670,6 +670,7 @@ function lintScopeDirectory(xdrsRoot, scopeName, errors, warnings, actualTypeInd
   // Determine if this scope is a core-type scope (but not _core which is exempt)
   // Used to enforce structured format on all policies in core-type scopes
   let isCoreTypeNonExempt = false;
+  let isCompiledScope = false;
   if (scopeName !== '_core') {
     const scopeIndexPath = path.join(scopePath, 'index.md');
     if (existsFile(scopeIndexPath)) {
@@ -678,10 +679,12 @@ function lintScopeDirectory(xdrsRoot, scopeName, errors, warnings, actualTypeInd
         const stMatch = idxContent.match(/^scope-type:\s*(.+)$/m);
         if (stMatch) {
           const stRaw = stMatch[1].trim();
+          // Handle both "[type1, type2]" YAML array format and "type1, type2" inline CSV format
           const stList = stRaw.startsWith('[') && stRaw.endsWith(']')
             ? stRaw.slice(1, -1).split(',').map((s) => s.trim())
-            : [stRaw];
+            : stRaw.split(',').map((s) => s.trim());
           isCoreTypeNonExempt = stList.includes('core');
+          isCompiledScope = stList.includes('compiled');
         }
       } catch { /* ignore read errors; will be caught later */ }
     }
@@ -696,7 +699,7 @@ function lintScopeDirectory(xdrsRoot, scopeName, errors, warnings, actualTypeInd
         errors.push(`Unexpected directory under scope ${scopeName}: ${toDisplayPath(entryPath)} [_core-adr-policy-001]`);
         continue;
       }
-      lintTypeDirectory(xdrsRoot, scopeName, entry.name, errors, warnings, actualTypeIndexes, externalScopes, isCoreTypeNonExempt);
+      lintTypeDirectory(xdrsRoot, scopeName, entry.name, errors, warnings, actualTypeIndexes, externalScopes, isCoreTypeNonExempt, isCompiledScope);
       const typeIndexPath = path.join(entryPath, 'index.md');
       if (existsFile(typeIndexPath)) {
         typeIndexesInScope.push(typeIndexPath);
@@ -718,10 +721,10 @@ function lintScopeDirectory(xdrsRoot, scopeName, errors, warnings, actualTypeInd
     lintScopeIndex(scopeIndexPath, xdrsRoot, scopeName, typeIndexesInScope, errors, externalScopes);
     lintScopeIndexFrontmatter(scopeIndexPath, scopeName, errors, xdrsRoot, knownScopeTypes, readOnlyScopes, extendsRelationships);
   }
-  lintLocalMetaPolicies(xdrsRoot, scopeName, errors);
+  lintLocalMetaPolicies(xdrsRoot, scopeName, errors, isCompiledScope);
 }
 
-function lintLocalMetaPolicies(xdrsRoot, scopeName, errors) {
+function lintLocalMetaPolicies(xdrsRoot, scopeName, errors, isCompiledScope = false) {
   const scopePath = path.join(xdrsRoot, scopeName);
   // Track qualifiers across all type folders: qualifier ('' for primary) -> filePath
   const seenQualifiers = new Map();
@@ -757,6 +760,21 @@ function lintLocalMetaPolicies(xdrsRoot, scopeName, errors) {
         errors.push(`Local meta-policy companion "${path.basename(companion.filePath)}" requires a primary "NNN-core.md" in the same type folder "${typeName}": ${toDisplayPath(companion.filePath)} [_core-adr-policy-010.10b-local-primary-required]`);
       }
     }
+    // For compiled scopes: primary meta-policy must include ## Sources and ## Selectors
+    if (isCompiledScope && primaryInFolder) {
+      let metaContent;
+      try { metaContent = fs.readFileSync(primaryInFolder.filePath, 'utf8'); } catch { /* will be caught elsewhere */ }
+      if (metaContent !== undefined) {
+        const metaLines = metaContent.split(/\r?\n/);
+        const metaIgnored = findIgnoredMarkdownLines(metaLines);
+        if (findHeadingLine(metaLines, metaIgnored, '## Sources') === -1) {
+          errors.push(`Compiled scope meta-policy must include a "## Sources" section: ${toDisplayPath(primaryInFolder.filePath)} [_core-adr-policy-019.07-compilation-meta-policy]`);
+        }
+        if (findHeadingLine(metaLines, metaIgnored, '## Selectors') === -1) {
+          errors.push(`Compiled scope meta-policy must include a "## Selectors" section: ${toDisplayPath(primaryInFolder.filePath)} [_core-adr-policy-019.07-compilation-meta-policy]`);
+        }
+      }
+    }
     // Check qualifier uniqueness across all type folders
     const allInFolder = primaryInFolder ? [primaryInFolder, ...companionsInFolder] : companionsInFolder;
     for (const { filePath, qualifier } of allInFolder) {
@@ -773,7 +791,7 @@ function lintLocalMetaPolicies(xdrsRoot, scopeName, errors) {
   }
 }
 
-function lintTypeDirectory(xdrsRoot, scopeName, typeName, errors, warnings, actualTypeIndexes, externalScopes = new Set(), enforceStructured = false) {
+function lintTypeDirectory(xdrsRoot, scopeName, typeName, errors, warnings, actualTypeIndexes, externalScopes = new Set(), enforceStructured = false, isCompiledScope = false) {
   const typePath = path.join(xdrsRoot, scopeName, typeName);
   const indexPath = path.join(typePath, 'index.md');
   const xdrsNumbers = new Map();
@@ -804,7 +822,7 @@ function lintTypeDirectory(xdrsRoot, scopeName, typeName, errors, warnings, actu
       warnings.push(`Invalid subject folder for ${typeName}: ${toDisplayPath(entryPath)} [_core-adr-policy-001] [exempt: freeze-reference]`);
     }
 
-    artifacts.push(...lintSubjectDirectory(xdrsRoot, scopeName, typeName, entry.name, xdrsNumbers, errors, warnings, externalScopes, enforceStructured));
+    artifacts.push(...lintSubjectDirectory(xdrsRoot, scopeName, typeName, entry.name, xdrsNumbers, errors, warnings, externalScopes, enforceStructured, isCompiledScope));
   }
 
   if (existsFile(indexPath)) {
@@ -812,7 +830,7 @@ function lintTypeDirectory(xdrsRoot, scopeName, typeName, errors, warnings, actu
   }
 }
 
-function lintSubjectDirectory(xdrsRoot, scopeName, typeName, subjectName, xdrsNumbers, errors, warnings, externalScopes = new Set(), enforceStructured = false) {
+function lintSubjectDirectory(xdrsRoot, scopeName, typeName, subjectName, xdrsNumbers, errors, warnings, externalScopes = new Set(), enforceStructured = false, isCompiledScope = false) {
   const subjectPath = path.join(xdrsRoot, scopeName, typeName, subjectName);
   const artifacts = [];
   const entries = safeReadDir(subjectPath, errors, `read subject directory ${scopeName}/${typeName}/${subjectName}`);
@@ -851,7 +869,7 @@ function lintSubjectDirectory(xdrsRoot, scopeName, typeName, subjectName, xdrsNu
     }
 
     artifacts.push(entryPath);
-    lintXdrsElementFile(xdrsRoot, scopeName, typeName, subjectName, entryPath, xdrsNumbers, errors, warnings, externalScopes, enforceStructured);
+    lintXdrsElementFile(xdrsRoot, scopeName, typeName, subjectName, entryPath, xdrsNumbers, errors, warnings, externalScopes, enforceStructured, isCompiledScope);
   }
 
   const subjectAssetsDir = path.join(subjectPath, RESOURCE_DIR_NAME);
@@ -861,7 +879,7 @@ function lintSubjectDirectory(xdrsRoot, scopeName, typeName, subjectName, xdrsNu
   return artifacts;
 }
 
-function lintXdrsElementFile(xdrsRoot, scopeName, typeName, subjectName, filePath, xdrsNumbers, errors, warnings, externalScopes = new Set(), enforceStructured = false) {
+function lintXdrsElementFile(xdrsRoot, scopeName, typeName, subjectName, filePath, xdrsNumbers, errors, warnings, externalScopes = new Set(), enforceStructured = false, isCompiledScope = false) {
   const baseName = path.basename(filePath);
   const match = baseName.match(NUMBERED_FILE_RE);
   if (!match) {
@@ -903,9 +921,15 @@ function lintXdrsElementFile(xdrsRoot, scopeName, typeName, subjectName, filePat
   lintXdrsElementFrontmatter(content, expectedName, filePath, errors, warnings, freezeReference);
   if (enforceStructured) {
     validateStructuredFormatContent(content, filePath, errors, '_core-adr-policy-010.08c-def-core-scope-policies-must-be-structured');
+  } else if (isCompiledScope) {
+    validateStructuredFormatContent(content, filePath, errors, '_core-adr-policy-019.04-structured-format-required');
   } else {
     lintStructuredRuleBlocks(content, filePath, errors);
   }
+  const isLocalMetaPolicy = subjectName === 'principles' && titleParts[0] === 'core';
+  if (isCompiledScope && !isLocalMetaPolicy) {
+    lintCompiledPolicySourceSection(content, filePath, errors);
+  }
   lintRequiredSections(content, filePath, XDRS_REQUIRED_SECTIONS, 'Policy', errors);
   lintNoEmojis(content, filePath, 'Policy', errors);
   lintWordCount(content, filePath, 'Policy', POLICY_MAX_WORDS, errors);
@@ -1708,6 +1732,32 @@ function validateStructuredFormatContent(content, filePath, errors, errorCode) {
   lintStructuredRuleBlocks(content, filePath, errors);
 }
 
+function lintCompiledPolicySourceSection(content, filePath, errors) {
+  const lines = content.split(/\r?\n/);
+  const ignoredLines = findIgnoredMarkdownLines(lines);
+  const sourceStart = findHeadingLine(lines, ignoredLines, '## Source');
+  if (sourceStart === -1) {
+    errors.push(`Compiled policy must include a "## Source" section: ${toDisplayPath(filePath)} [_core-adr-policy-019.10-source-section]`);
+    return;
+  }
+  // Find end of ## Source section (next ## heading or EOF)
+  let sourceEnd = lines.length;
+  for (let i = sourceStart + 1; i < lines.length; i++) {
+    if (!ignoredLines[i] && /^## /.test(lines[i])) {
+      sourceEnd = i;
+      break;
+    }
+  }
+  // Paths in ## Source MUST NOT be written as markdown links
+  const MD_LINK_RE = /\[.+?\]\(.+?\)/;
+  for (let i = sourceStart + 1; i < sourceEnd; i++) {
+    if (!ignoredLines[i] && MD_LINK_RE.test(lines[i])) {
+      errors.push(`Compiled policy "## Source" section must not use markdown links (use plain text paths): ${toDisplayPath(filePath)}:${i + 1} [_core-adr-policy-019.10-source-section]`);
+      break;
+    }
+  }
+}
+
 function findIgnoredMarkdownLines(lines) {
   const ignored = [];
   let inCodeFence = false;

package/lib/lint.test.js

@@ -2456,6 +2456,509 @@ test('does not require structured format for _core scope policies (exempt)', ()
   expect(result.errors.join('\n')).not.toContain('08c-def-core-scope-policies-must-be-structured');
 });
 
+// ─── compiled scope-type checks ───────────────────────────────────────────────
+
+function compiledScopeIndex() {
+  return [
+    '---',
+    'scope-type: compiled',
+    'name: my-compiled',
+    'description: Compiled scope for tests.',
+    'apply-to: All consumers of compiled content',
+    'valid-from: 2026-01-01',
+    '---',
+    '',
+    '# my-compiled Scope Overview',
+    '',
+    'Compiled scope for tests.',
+    '',
+    '[ADRs](adrs/index.md)',
+    ''
+  ].join('\n');
+}
+
+function compiledAdrIndex(entries) {
+  return [
+    '# my-compiled ADR Index',
+    '',
+    'Compiled ADRs for tests.',
+    '',
+    '## principles',
+    '',
+    ...entries,
+    ''
+  ].join('\n');
+}
+
+function validCompiledPolicy() {
+  return [
+    '---',
+    'name: my-compiled-adr-policy-001-a01',
+    'description: Compiled test policy.',
+    'apply-to: All teams',
+    'valid-from: 2026-01-01',
+    '---',
+    '',
+    '# my-compiled-adr-policy-001: A01',
+    '',
+    '## Context and Problem Statement',
+    '',
+    'External source defines this requirement.',
+    '',
+    '## Decision Outcome',
+    '',
+    'Follow the rule.',
+    '',
+    '### Details',
+    '',
+    '#### 01-rule',
+    '',
+    'MUST comply.',
+    '',
+    '## Source',
+    '',
+    '- source-1/standards/a01.md',
+    ''
+  ].join('\n');
+}
+
+function validCompiledMetaPolicy() {
+  return [
+    '---',
+    'name: my-compiled-adr-policy-001-core',
+    'description: Compilation meta-policy for adrs.',
+    'apply-to: Compilation process for this scope',
+    'valid-from: 2026-01-01',
+    '---',
+    '',
+    '# my-compiled-adr-policy-001: core',
+    '',
+    '## Context and Problem Statement',
+    '',
+    'Defines compilation configuration.',
+    '',
+    '## Decision Outcome',
+    '',
+    'Use the configured sources.',
+    '',
+    '### Details',
+    '',
+    '#### 01-rule',
+    '',
+    'MUST use configured sources.',
+    '',
+    '## Sources',
+    '',
+    '- [web] https://example.com/standards',
+    '',
+    '## Selectors',
+    '',
+    '- Include all requirement sections.',
+    ''
+  ].join('\n');
+}
+
+test('reports policy in compiled scope missing structured format', () => {
+  const workspaceRoot = createWorkspace('compiled-scope-policy-unstructured', {
+    '.xdrs/index.md': rootIndex(['[my-compiled](my-compiled/index.md)']),
+    '.xdrs/my-compiled/index.md': compiledScopeIndex(),
+    '.xdrs/my-compiled/adrs/index.md': compiledAdrIndex([
+      '- [001-a01](principles/001-a01.md) - A01'
+    ]),
+    '.xdrs/my-compiled/adrs/principles/001-a01.md': [
+      '---',
+      'name: my-compiled-adr-policy-001-a01',
+      'description: Compiled test policy.',
+      'apply-to: All teams',
+      'valid-from: 2026-01-01',
+      '---',
+      '',
+      '# my-compiled-adr-policy-001: A01',
+      '',
+      '## Context and Problem Statement',
+      '',
+      'External source.',
+      '',
+      '## Decision Outcome',
+      '',
+      'Follow rule.',
+      '',
+      '## Source',
+      '',
+      '- source-1/a01.md',
+      ''
+    ].join('\n'),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).toContain('"### Details"');
+  expect(result.errors.join('\n')).toContain('019.04-structured-format-required');
+});
+
+test('reports compiled policy missing ## Source section', () => {
+  const workspaceRoot = createWorkspace('compiled-scope-missing-source', {
+    '.xdrs/index.md': rootIndex(['[my-compiled](my-compiled/index.md)']),
+    '.xdrs/my-compiled/index.md': compiledScopeIndex(),
+    '.xdrs/my-compiled/adrs/index.md': compiledAdrIndex([
+      '- [001-a01](principles/001-a01.md) - A01'
+    ]),
+    '.xdrs/my-compiled/adrs/principles/001-a01.md': [
+      '---',
+      'name: my-compiled-adr-policy-001-a01',
+      'description: Compiled test policy.',
+      'apply-to: All teams',
+      'valid-from: 2026-01-01',
+      '---',
+      '',
+      '# my-compiled-adr-policy-001: A01',
+      '',
+      '## Context and Problem Statement',
+      '',
+      'External source.',
+      '',
+      '## Decision Outcome',
+      '',
+      'Follow rule.',
+      '',
+      '### Details',
+      '',
+      '#### 01-rule',
+      '',
+      'MUST comply.',
+      ''
+    ].join('\n'),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).toContain('Compiled policy must include a "## Source" section');
+  expect(result.errors.join('\n')).toContain('019.10-source-section');
+});
+
+test('reports compiled policy with markdown links in ## Source section', () => {
+  const workspaceRoot = createWorkspace('compiled-scope-source-md-links', {
+    '.xdrs/index.md': rootIndex(['[my-compiled](my-compiled/index.md)']),
+    '.xdrs/my-compiled/index.md': compiledScopeIndex(),
+    '.xdrs/my-compiled/adrs/index.md': compiledAdrIndex([
+      '- [001-a01](principles/001-a01.md) - A01'
+    ]),
+    '.xdrs/my-compiled/adrs/principles/001-a01.md': [
+      '---',
+      'name: my-compiled-adr-policy-001-a01',
+      'description: Compiled test policy.',
+      'apply-to: All teams',
+      'valid-from: 2026-01-01',
+      '---',
+      '',
+      '# my-compiled-adr-policy-001: A01',
+      '',
+      '## Context and Problem Statement',
+      '',
+      'External source.',
+      '',
+      '## Decision Outcome',
+      '',
+      'Follow rule.',
+      '',
+      '### Details',
+      '',
+      '#### 01-rule',
+      '',
+      'MUST comply.',
+      '',
+      '## Source',
+      '',
+      '- [source-1/a01.md](source-1/a01.md)',
+      ''
+    ].join('\n'),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).toContain('"## Source" section must not use markdown links');
+  expect(result.errors.join('\n')).toContain('019.10-source-section');
+});
+
+test('accepts valid compiled policy with ## Source section and no markdown links', () => {
+  const workspaceRoot = createWorkspace('compiled-scope-valid', {
+    '.xdrs/index.md': rootIndex(['[my-compiled](my-compiled/index.md)']),
+    '.xdrs/my-compiled/index.md': compiledScopeIndex(),
+    '.xdrs/my-compiled/adrs/index.md': compiledAdrIndex([
+      '- [001-a01](principles/001-a01.md) - A01'
+    ]),
+    '.xdrs/my-compiled/adrs/principles/001-a01.md': validCompiledPolicy(),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).not.toContain('019');
+});
+
+test('reports compiled scope meta-policy missing ## Sources section', () => {
+  const workspaceRoot = createWorkspace('compiled-meta-missing-sources', {
+    '.xdrs/index.md': rootIndex(['[my-compiled](my-compiled/index.md)']),
+    '.xdrs/my-compiled/index.md': compiledScopeIndex(),
+    '.xdrs/my-compiled/adrs/index.md': compiledAdrIndex([
+      '- [001-core](principles/001-core.md) - meta-policy',
+      '- [002-a01](principles/002-a01.md) - A01'
+    ]),
+    '.xdrs/my-compiled/adrs/principles/001-core.md': [
+      '---',
+      'name: my-compiled-adr-policy-001-core',
+      'description: Compilation meta-policy.',
+      'apply-to: Compilation process',
+      'valid-from: 2026-01-01',
+      '---',
+      '',
+      '# my-compiled-adr-policy-001: core',
+      '',
+      '## Context and Problem Statement',
+      '',
+      'Defines compilation config.',
+      '',
+      '## Decision Outcome',
+      '',
+      'Use configured sources.',
+      '',
+      '### Details',
+      '',
+      '#### 01-rule',
+      '',
+      'MUST use configured sources.',
+      '',
+      '## Selectors',
+      '',
+      '- Include requirement sections.',
+      ''
+    ].join('\n'),
+    '.xdrs/my-compiled/adrs/principles/002-a01.md': [
+      '---',
+      'name: my-compiled-adr-policy-002-a01',
+      'description: Compiled test policy.',
+      'apply-to: All teams',
+      'valid-from: 2026-01-01',
+      '---',
+      '',
+      '# my-compiled-adr-policy-002: A01',
+      '',
+      '## Context and Problem Statement',
+      '',
+      'External source.',
+      '',
+      '## Decision Outcome',
+      '',
+      'Follow rule.',
+      '',
+      '### Details',
+      '',
+      '#### 01-rule',
+      '',
+      'MUST comply.',
+      '',
+      '## Source',
+      '',
+      '- source-1/a01.md',
+      ''
+    ].join('\n'),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).toContain('"## Sources" section');
+  expect(result.errors.join('\n')).toContain('019.07-compilation-meta-policy');
+});
+
+test('reports compiled scope meta-policy missing ## Selectors section', () => {
+  const workspaceRoot = createWorkspace('compiled-meta-missing-selectors', {
+    '.xdrs/index.md': rootIndex(['[my-compiled](my-compiled/index.md)']),
+    '.xdrs/my-compiled/index.md': compiledScopeIndex(),
+    '.xdrs/my-compiled/adrs/index.md': compiledAdrIndex([
+      '- [001-core](principles/001-core.md) - meta-policy',
+      '- [002-a01](principles/002-a01.md) - A01'
+    ]),
+    '.xdrs/my-compiled/adrs/principles/001-core.md': [
+      '---',
+      'name: my-compiled-adr-policy-001-core',
+      'description: Compilation meta-policy.',
+      'apply-to: Compilation process',
+      'valid-from: 2026-01-01',
+      '---',
+      '',
+      '# my-compiled-adr-policy-001: core',
+      '',
+      '## Context and Problem Statement',
+      '',
+      'Defines compilation config.',
+      '',
+      '## Decision Outcome',
+      '',
+      'Use configured sources.',
+      '',
+      '### Details',
+      '',
+      '#### 01-rule',
+      '',
+      'MUST use configured sources.',
+      '',
+      '## Sources',
+      '',
+      '- [web] https://example.com/standards',
+      ''
+    ].join('\n'),
+    '.xdrs/my-compiled/adrs/principles/002-a01.md': [
+      '---',
+      'name: my-compiled-adr-policy-002-a01',
+      'description: Compiled test policy.',
+      'apply-to: All teams',
+      'valid-from: 2026-01-01',
+      '---',
+      '',
+      '# my-compiled-adr-policy-002: A01',
+      '',
+      '## Context and Problem Statement',
+      '',
+      'External source.',
+      '',
+      '## Decision Outcome',
+      '',
+      'Follow rule.',
+      '',
+      '### Details',
+      '',
+      '#### 01-rule',
+      '',
+      'MUST comply.',
+      '',
+      '## Source',
+      '',
+      '- source-1/a01.md',
+      ''
+    ].join('\n'),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).toContain('"## Selectors" section');
+  expect(result.errors.join('\n')).toContain('019.07-compilation-meta-policy');
+});
+
+test('accepts valid compiled scope meta-policy with required sections', () => {
+  const workspaceRoot = createWorkspace('compiled-meta-valid', {
+    '.xdrs/index.md': rootIndex(['[my-compiled](my-compiled/index.md)']),
+    '.xdrs/my-compiled/index.md': compiledScopeIndex(),
+    '.xdrs/my-compiled/adrs/index.md': compiledAdrIndex([
+      '- [001-core](principles/001-core.md) - meta-policy',
+      '- [002-a01](principles/002-a01.md) - A01'
+    ]),
+    '.xdrs/my-compiled/adrs/principles/001-core.md': validCompiledMetaPolicy(),
+    '.xdrs/my-compiled/adrs/principles/002-a01.md': [
+      '---',
+      'name: my-compiled-adr-policy-002-a01',
+      'description: Compiled test policy.',
+      'apply-to: All teams',
+      'valid-from: 2026-01-01',
+      '---',
+      '',
+      '# my-compiled-adr-policy-002: A01',
+      '',
+      '## Context and Problem Statement',
+      '',
+      'External source.',
+      '',
+      '## Decision Outcome',
+      '',
+      'Follow rule.',
+      '',
+      '### Details',
+      '',
+      '#### 01-rule',
+      '',
+      'MUST comply.',
+      '',
+      '## Source',
+      '',
+      '- source-1/a01.md',
+      ''
+    ].join('\n'),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).not.toContain('019');
+});
+
+test('skips ## Source check for local meta-policy files in compiled scope', () => {
+  const workspaceRoot = createWorkspace('compiled-meta-no-source-required', {
+    '.xdrs/index.md': rootIndex(['[my-compiled](my-compiled/index.md)']),
+    '.xdrs/my-compiled/index.md': compiledScopeIndex(),
+    '.xdrs/my-compiled/adrs/index.md': compiledAdrIndex([
+      '- [001-core](principles/001-core.md) - meta-policy'
+    ]),
+    '.xdrs/my-compiled/adrs/principles/001-core.md': validCompiledMetaPolicy(),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).not.toContain('Compiled policy must include a "## Source" section');
+});
+
+test('enforces compiled scope checks when scope-type is comma-separated with compiled', () => {
+  const workspaceRoot = createWorkspace('compiled-multi-type-checks', {
+    '.xdrs/index.md': rootIndex(['[my-compiled-scope](my-compiled-scope/index.md)']),
+    '.xdrs/my-compiled-scope/index.md': [
+      '---',
+      'scope-type: compiled, standard',
+      'name: my-compiled-scope',
+      'description: Compiled standard scope for tests.',
+      'apply-to: All consumers',
+      'valid-from: 2026-01-01',
+      '---',
+      '',
+      '# my-compiled-scope Scope Overview',
+      '',
+      'Compiled standard.',
+      '',
+      '[ADRs](adrs/index.md)',
+      ''
+    ].join('\n'),
+    '.xdrs/my-compiled-scope/adrs/index.md': [
+      '# my-compiled-scope ADR Index', '', 'ADRs.', '', '## principles', '',
+      '- [001-a01](principles/001-a01.md) - A01', ''
+    ].join('\n'),
+    '.xdrs/my-compiled-scope/adrs/principles/001-a01.md': [
+      '---',
+      'name: my-compiled-scope-adr-policy-001-a01',
+      'description: Compiled test policy.',
+      'apply-to: All teams',
+      'valid-from: 2026-01-01',
+      '---',
+      '',
+      '# my-compiled-scope-adr-policy-001: A01',
+      '',
+      '## Context and Problem Statement',
+      '',
+      'External source.',
+      '',
+      '## Decision Outcome',
+      '',
+      'Follow rule.',
+      '',
+      '## Source',
+      '',
+      '- source-1/a01.md',
+      ''
+    ].join('\n'),
+    ...coreWithStructuredScopeTypes(['standard', 'compiled']),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).toContain('"### Details"');
+  expect(result.errors.join('\n')).toContain('019.04-structured-format-required');
+});
+
+
 function localScopeIndex() {
   return [
     '---',