xdrs-core 0.50.0 → 0.52.0

package/lib/lint.test.js

@@ -1590,7 +1590,7 @@ test('accepts companion scope-type file when primary exists in same type folder'
 
   const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
 
-  expect(result.errors.join('\n')).not.toContain('companion-requires-primary');
+  expect(result.errors.join('\n')).not.toContain('def-companion-files');
   expect(result.errors.join('\n')).not.toContain('has no corresponding');
 });
 
@@ -1610,7 +1610,7 @@ test('reports companion scope-type file with no corresponding primary', () => {
 
   const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
 
-  expect(result.errors.join('\n')).toContain('companion-requires-primary');
+  expect(result.errors.join('\n')).toContain('def-companion-files');
   expect(result.errors.join('\n')).toContain('custom-scope-type');
 });
 
@@ -1638,7 +1638,7 @@ test('reports companion scope-type file when primary is in a different type fold
 
   const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
 
-  expect(result.errors.join('\n')).toContain('companion-requires-primary');
+  expect(result.errors.join('\n')).toContain('def-companion-files');
   expect(result.errors.join('\n')).toContain('custom-scope-type');
 });
 
@@ -1807,8 +1807,8 @@ test('accepts multiple local meta-policies in same scope', () => {
 
   const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
 
-  expect(result.errors.join('\n')).not.toContain('[_core-adr-policy-010.10');
-  expect(result.errors.join('\n')).not.toContain('[_core-adr-policy-010.09-local-naming]');
+  expect(result.errors.join('\n')).not.toContain('[_core-adr-policy-010.15');
+  expect(result.errors.join('\n')).not.toContain('[_core-adr-policy-010.13-local-naming]');
 });
 
 test('accepts single local meta-policy in a scope', () => {
@@ -1843,8 +1843,8 @@ test('accepts single local meta-policy in a scope', () => {
 
   const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
 
-  expect(result.errors.join('\n')).not.toContain('[_core-adr-policy-010.10');
-  expect(result.errors.join('\n')).not.toContain('[_core-adr-policy-010.09-local-naming]');
+  expect(result.errors.join('\n')).not.toContain('[_core-adr-policy-010.15');
+  expect(result.errors.join('\n')).not.toContain('[_core-adr-policy-010.13-local-naming]');
 });
 
 test('errors when local meta-policy companion exists without primary in same type folder', () => {
@@ -1879,7 +1879,7 @@ test('errors when local meta-policy companion exists without primary in same typ
 
   const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
 
-  expect(result.errors.join('\n')).toContain('[_core-adr-policy-010.10b-local-primary-required]');
+  expect(result.errors.join('\n')).toContain('[_core-adr-policy-010.15-local-primary-required]');
 });
 
 test('errors when local meta-policy same qualifier appears in two type folders', () => {
@@ -1946,7 +1946,7 @@ test('errors when local meta-policy same qualifier appears in two type folders',
 
   const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
 
-  expect(result.errors.join('\n')).toContain('[_core-adr-policy-010.10c-local-unique-qualifier]');
+  expect(result.errors.join('\n')).toContain('[_core-adr-policy-010.16-local-unique-qualifier]');
 });
 
 test('errors when policy filename contains core as word outside principles', () => {
@@ -1977,7 +1977,7 @@ test('errors when policy filename contains core as word outside principles', ()
 
   const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
 
-  expect(result.errors.join('\n')).toContain('[_core-adr-policy-010.09-local-naming]');
+  expect(result.errors.join('\n')).toContain('[_core-adr-policy-010.13-local-naming]');
 });
 
 test('errors when policy filename contains core as non-first word in principles', () => {
@@ -2010,7 +2010,7 @@ test('errors when policy filename contains core as non-first word in principles'
 
   const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
 
-  expect(result.errors.join('\n')).toContain('[_core-adr-policy-010.09-local-naming]');
+  expect(result.errors.join('\n')).toContain('[_core-adr-policy-010.13-local-naming]');
 });
 
 test('accepts NNN-core-scope-type.md in principles without triggering core-word error', () => {
@@ -2060,7 +2060,7 @@ test('accepts NNN-core-scope-type.md in principles without triggering core-word
 
   const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
 
-  expect(result.errors.join('\n')).not.toContain('[_core-adr-policy-010.09-local-naming]');
+  expect(result.errors.join('\n')).not.toContain('[_core-adr-policy-010.13-local-naming]');
 });
 
 test('reports missing name field in scope index frontmatter', () => {
@@ -2248,6 +2248,21 @@ test('reports error when follows references a scope not in workspace', () => {
   expect(result.readOnlyScopes.has('myteam')).toBe(false);
 });
 
+test('marks scope read-only instead of erroring when follows references a missing scope for an external scope', () => {
+  const workspaceRoot = createWorkspace('follows-missing-scope-external', {
+    '.xdrs/index.md': rootIndex(['[myteam](myteam/index.md)']),
+    '.xdrs/myteam/index.md': '---\nscope-type: standard\nname: myteam\ndescription: Team.\napply-to: Test team\nvalid-from: 2026-01-01\nfollows: nonexistent-core\n---\n\n# myteam Scope Overview\n\n[ADRs](adrs/index.md)\n',
+    '.xdrs/myteam/adrs/index.md': teamAdrIndex(['- [001-team](principles/001-team.md) - Team decision']),
+    '.xdrs/myteam/adrs/principles/001-team.md': teamXdrDocument('Team decision.'),
+    '.filedist.lock': '.xdrs/myteam/adrs/principles/001-team.md|some-package|1.0.0\n',
+  });
+
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+
+  expect(result.errors.join('\n')).not.toContain('follows references scope "nonexistent-core" which does not exist in the workspace');
+  expect(result.readOnlyScopes.has('myteam')).toBe(true);
+});
+
 test('accepts follows scope that exists in workspace', () => {
   const workspaceRoot = createWorkspace('follows-existing-scope', {
     '.xdrs/index.md': rootIndex(['[myteam](myteam/index.md)', '[myarea-core](myarea-core/index.md)']),
@@ -2280,6 +2295,23 @@ test('reports follows scope that is not core-type', () => {
   expect(result.errors.join('\n')).toContain('follows references scope "myarea-domain" which is not a core-type scope');
 });
 
+test('reports core scope-type combined with another type [011.10]', () => {
+  const workspaceRoot = createWorkspace('follows-multi-type-core-scope', {
+    '.xdrs/index.md': rootIndex(['[myteam](myteam/index.md)', '[myarea-core](myarea-core/index.md)']),
+    '.xdrs/myteam/index.md': '---\nscope-type: standard\nname: myteam\ndescription: Team.\napply-to: Test team\nvalid-from: 2026-01-01\nfollows: myarea-core\n---\n\n# myteam Scope Overview\n\n[ADRs](adrs/index.md)\n',
+    '.xdrs/myteam/adrs/index.md': teamAdrIndex(['- [001-team](principles/001-team.md) - Team decision']),
+    '.xdrs/myteam/adrs/principles/001-team.md': teamXdrDocument('Team decision.'),
+    '.xdrs/myarea-core/index.md': '---\nscope-type: core, standard\nname: myarea-core\ndescription: Meta-governance for myarea.\napply-to: All myarea scopes\nvalid-from: 2026-01-01\n---\n\n# myarea-core Scope Overview\n\n[ADRs](adrs/index.md)\n',
+    '.xdrs/myarea-core/adrs/index.md': teamAdrIndex(['- [001-team](principles/001-team.md) - Team decision']),
+    '.xdrs/myarea-core/adrs/principles/001-team.md': teamXdrDocument('Team decision.'),
+  });
+
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+
+  expect(result.errors.join('\n')).not.toContain('follows references scope');
+  expect(result.errors.join('\n')).toContain('[_core-adr-policy-011.10-no-type-combination]');
+});
+
 test('reports scope index apply-to exceeding 30 words', () => {
   const workspaceRoot = createWorkspace('scope-apply-to-too-long', {
     '.xdrs/index.md': rootIndex(['[myteam](myteam/index.md)']),
@@ -2458,7 +2490,7 @@ test('reports extends: and follows: referencing same scope (disjoint violation)'
   expect(result.errors.join('\n')).toContain('[_core-adr-policy-010.28-extends-disjoint]');
 });
 
-test('extends-only scope not in root index is exempt from missing link error', () => {
+test('reports extends-referenced scope missing from root index [022.01]', () => {
   const workspaceRoot = createWorkspace('extends-only-scope-not-in-index', {
     // shared-policies is NOT linked in the root index — it is only referenced via extends:
     '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[myteam](myteam/index.md)']),
@@ -2472,13 +2504,14 @@ test('extends-only scope not in root index is exempt from missing link error', (
 
   const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
 
-  // shared-policies should NOT trigger "missing root index link" since it is extends-only
-  expect(result.errors.filter((e) => e.includes('Root index is missing scope index link') && e.includes('shared-policies')).length).toBe(0);
+  // shared-policies must still be linked in the root index (no extends exemption)
+  expect(result.errors.filter((e) => e.includes('Root index is missing scope index link') && e.includes('shared-policies')).join('\n')).toContain('[_core-adr-policy-022.01-root-index-completeness]');
+  expect(result.errors.join('\n')).toContain('add the line: [View scope shared-policies](shared-policies/index.md)');
   // No extends: validation errors should fire for the extends: field
   expect(result.errors.filter((e) => /\[_core-adr-policy-010\.\d+-extends-/.test(e)).join('\n')).toBe('');
 });
 
-test('warns when extends-referenced scope also appears in root index', () => {
+test('does not warn when extends-referenced scope also appears in root index', () => {
   const workspaceRoot = createWorkspace('extends-scope-in-root-index', {
     '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[myteam](myteam/index.md)', '[shared-policies](shared-policies/index.md)']),
     '.xdrs/myteam/index.md': '---\nscope-type: standard\nname: myteam\ndescription: Team.\napply-to: Test team\nvalid-from: 2026-01-01\nextends: shared-policies\n---\n\n# myteam Scope Overview\n\n[ADRs](adrs/index.md)\n',
@@ -2492,8 +2525,8 @@ test('warns when extends-referenced scope also appears in root index', () => {
   const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
 
   expect(result.errors.join('\n')).not.toContain('[_core-adr-policy-010.35-extends-index]');
-  expect(result.warnings.join('\n')).toContain('[_core-adr-policy-010.35-extends-index]');
-  expect(result.warnings.join('\n')).toContain('shared-policies');
+  expect(result.warnings.join('\n')).not.toContain('[_core-adr-policy-010.35-extends-index]');
+  expect(result.errors.join('\n')).not.toContain('_core-adr-policy-022');
 });
 
 
@@ -2919,7 +2952,7 @@ test('reports scope-type policy missing ### Details section', () => {
   const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
 
   expect(result.errors.join('\n')).toContain('"### Details"');
-  expect(result.errors.join('\n')).toContain('08b-def-scope-type-must-be-structured');
+  expect(result.errors.join('\n')).toContain('11-def-scope-type-must-be-structured');
 });
 
 test('reports scope-type policy missing at least one #### NN-rulename block', () => {
@@ -2955,7 +2988,7 @@ test('reports scope-type policy missing at least one #### NN-rulename block', ()
   const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
 
   expect(result.errors.join('\n')).toContain('at least one structured rule block');
-  expect(result.errors.join('\n')).toContain('08b-def-scope-type-must-be-structured');
+  expect(result.errors.join('\n')).toContain('11-def-scope-type-must-be-structured');
 });
 
 test('reports local meta-policy missing ### Details section', () => {
@@ -2983,7 +3016,7 @@ test('reports local meta-policy missing ### Details section', () => {
   const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
 
   expect(result.errors.join('\n')).toContain('"### Details"');
-  expect(result.errors.join('\n')).toContain('12b-local-must-be-structured');
+  expect(result.errors.join('\n')).toContain('19-local-must-be-structured');
 });
 
 test('reports policy in non-_core core-type scope missing structured format', () => {
@@ -3012,7 +3045,7 @@ test('reports policy in non-_core core-type scope missing structured format', ()
   const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
 
   expect(result.errors.join('\n')).toContain('"### Details"');
-  expect(result.errors.join('\n')).toContain('08c-def-core-scope-policies-must-be-structured');
+  expect(result.errors.join('\n')).toContain('12-def-core-scope-policies-must-be-structured');
 });
 
 test('does not require structured format for _core scope policies (exempt)', () => {
@@ -3026,7 +3059,7 @@ test('does not require structured format for _core scope policies (exempt)', ()
 
   const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
 
-  expect(result.errors.join('\n')).not.toContain('08c-def-core-scope-policies-must-be-structured');
+  expect(result.errors.join('\n')).not.toContain('12-def-core-scope-policies-must-be-structured');
 });
 
 // ─── compiled scope-type checks ───────────────────────────────────────────────
@@ -3122,11 +3155,15 @@ function validCompiledMetaPolicy() {
     '',
     '## Sources',
     '',
-    '- [web] https://example.com/standards',
+    '- [web] example-standards: https://example.com/standards',
     '',
     '## Selectors',
     '',
     '- Include all requirement sections.',
+    '',
+    '## Sync Settings',
+    '',
+    '- Source re-sync period days: 30',
     ''
   ].join('\n');
 }
@@ -3416,6 +3453,331 @@ test('reports compiled scope meta-policy missing ## Selectors section', () => {
   expect(result.errors.join('\n')).toContain('019.07-compilation-meta-policy');
 });
 
+test('reports compiled scope meta-policy missing ## Sync Settings section', () => {
+  const workspaceRoot = createWorkspace('compiled-meta-missing-sync-settings', {
+    '.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] example-standards: https://example.com/standards',
+      '',
+      '## 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('"## Sync Settings" section');
+  expect(result.errors.join('\n')).toContain('019.07-compilation-meta-policy');
+});
+
+test('reports missing Source re-sync period days in ## Sync Settings', () => {
+  const workspaceRoot = createWorkspace('compiled-meta-missing-resync-period', {
+    '.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] example-standards: https://example.com/standards',
+      '',
+      '## Selectors',
+      '',
+      '- Include requirement sections.',
+      '',
+      '## Sync Settings',
+      '',
+      '- Source storage: temporary',
+      ''
+    ].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('"Source re-sync period days: N" bullet with a positive integer');
+  expect(result.errors.join('\n')).toContain('019.07-compilation-meta-policy');
+});
+
+test('reports invalid Source storage value in ## Sync Settings', () => {
+  const workspaceRoot = createWorkspace('compiled-meta-invalid-storage-value', {
+    '.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] example-standards: https://example.com/standards',
+      '',
+      '## Selectors',
+      '',
+      '- Include requirement sections.',
+      '',
+      '## Sync Settings',
+      '',
+      '- Source re-sync period days: 30',
+      '- Source storage: permanent',
+      ''
+    ].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('"Source storage" value must be "temporary" if present');
+  expect(result.errors.join('\n')).toContain('019.07-compilation-meta-policy');
+});
+
+test('reports compiled scope ## Sources bullet missing NAME slug', () => {
+  const workspaceRoot = createWorkspace('compiled-meta-sources-missing-name', {
+    '.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',
+      '',
+      '## Selectors',
+      '',
+      '- Include requirement sections.',
+      '',
+      '## Sync Settings',
+      '',
+      '- Source re-sync period days: 30',
+      ''
+    ].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('must include a NAME slug');
+  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)']),
@@ -3476,6 +3838,88 @@ test('skips ## Source check for local meta-policy files in compiled scope', () =
   expect(result.errors.join('\n')).not.toContain('Compiled policy must include a "## Source" section');
 });
 
+test('does not report orphan asset errors for files under .assets/sources in a compiled scope', () => {
+  const workspaceRoot = createWorkspace('compiled-sources-orphan-exempt', {
+    '.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(),
+    '.xdrs/my-compiled/adrs/principles/.assets/sources/example-standards/source.md': [
+      '# Source',
+      '',
+      'last-fetch-timestamp: 2026-01-01 10:00:00',
+      'last-compilation-timestamp: 2026-01-01 10:05:00',
+      ''
+    ].join('\n'),
+    '.xdrs/my-compiled/adrs/principles/.assets/sources/example-standards/raw-standard.md': '# Raw fetched content\n',
+    '.xdrs/my-compiled/adrs/principles/.assets/unused.png': Buffer.alloc(0),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).not.toContain('raw-standard.md');
+  expect(result.errors.join('\n')).not.toContain('019.12-source-storage-tracking');
+  expect(result.errors.join('\n')).toContain('Orphan asset file');
+  expect(result.errors.join('\n')).toContain('unused.png');
+});
+
+test('reports missing source.md tracking file in a compiled source snapshot folder', () => {
+  const workspaceRoot = createWorkspace('compiled-sources-missing-tracking-file', {
+    '.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(),
+    '.xdrs/my-compiled/adrs/principles/.assets/sources/example-standards/raw-standard.md': '# Raw fetched content\n',
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).toContain('must contain a "source.md" tracking file');
+  expect(result.errors.join('\n')).toContain('019.12-source-storage-tracking');
+});
+
+test('reports malformed source.md tracking file content', () => {
+  const workspaceRoot = createWorkspace('compiled-sources-malformed-tracking-file', {
+    '.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(),
+    '.xdrs/my-compiled/adrs/principles/.assets/sources/example-standards/source.md': [
+      'last-fetch-timestamp: not-a-date',
+      ''
+    ].join('\n'),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).toContain('must start with a "# Source" heading');
+  expect(result.errors.join('\n')).toContain('must include a "last-compilation-timestamp:" line');
+  expect(result.errors.join('\n')).toContain('must match "YYYY-MM-DD HH:MM:SS"');
+  expect(result.errors.join('\n')).toContain('019.12-source-storage-tracking');
+});
+
+test('reports document linking directly into a compiled-source snapshot path', () => {
+  const workspaceRoot = createWorkspace('source-snapshot-link-forbidden', {
+    '.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('See [raw source](.assets/sources/example-standards/raw-standard.md).'),
+    '.xdrs/_local/adrs/principles/.assets/sources/example-standards/raw-standard.md': '# Raw fetched content\n',
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(result.errors.join('\n')).toContain('must not link directly to compiled-source snapshot content');
+  expect(result.errors.join('\n')).toContain('019.14-source-not-authoritative');
+});
+
 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)']),
@@ -5017,4 +5461,372 @@ test('error messages include policy references', () => {
 
   expect(result.errors.join('\n')).toContain('[_core-adr-policy-');
   expect(result.errors.every((e) => e.includes('[_core-adr-policy-'))).toBe(true);
-});
+});
+
+// ---------------------------------------------------------------------------
+// Scope activation (_core-adr-policy-022) and scope-type hardening (011.10)
+// ---------------------------------------------------------------------------
+
+const ACTIVATION_LEGEND = 'Scopes tagged `disabled` MUST be ignored; `extends-only` scopes apply only via extends (see _core-adr-policy-022)';
+
+function scopeIndexWith(name, extraFields = '', scopeType = 'standard') {
+  return `---\nscope-type: ${scopeType}\nname: ${name}\ndescription: Scope ${name}.\napply-to: Test teams\nvalid-from: 2026-01-01\n${extraFields}---\n\n# ${name} Scope Overview\n\n[ADRs](adrs/index.md)\n`;
+}
+
+function scopeFiles(name, extraFields = '', scopeType = 'standard') {
+  return {
+    [`.xdrs/${name}/index.md`]: scopeIndexWith(name, extraFields, scopeType),
+    [`.xdrs/${name}/adrs/index.md`]: teamAdrIndex(['- [001-team](principles/001-team.md) - Decision']),
+    [`.xdrs/${name}/adrs/principles/001-team.md`]: teamXdrDocument('Decision.'),
+  };
+}
+
+const activationErrors = (result) => result.errors.filter((e) => e.includes('_core-adr-policy-022')).join('\n');
+const activationWarnings = (result) => result.warnings.filter((e) => e.includes('_core-adr-policy-022')).join('\n');
+
+test('passes activation checks when only _core is installed and linked (smoke)', () => {
+  const workspaceRoot = createWorkspace('activation-smoke', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)']),
+    ...coreWithScopeTypes(['standard']),
+  });
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  expect(activationErrors(result)).toBe('');
+  expect(result.readOnlyScopes.size).toBe(0);
+});
+
+test('reports unlisted scope without type indexes with a paste-ready line [022.01]', () => {
+  const workspaceRoot = createWorkspace('activation-unlisted-no-types', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)']),
+    '.xdrs/lonely/index.md': scopeIndexWith('lonely'),
+  });
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  expect(activationErrors(result)).toContain('add the line: [View scope lonely](lonely/index.md) [_core-adr-policy-022.01-root-index-completeness]');
+});
+
+test('reports unlisted external scope even when external scopes are skipped [022.01]', () => {
+  const workspaceRoot = createWorkspace('activation-unlisted-external', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)']),
+    ...scopeFiles('vendor'),
+    '.filedist.lock': '.xdrs/vendor/index.md|some-package|1.0.0\n',
+  });
+  const result = lintWorkspace(workspaceRoot);
+  expect(activationErrors(result)).toContain('[View scope vendor](vendor/index.md)');
+});
+
+test('does not require _local to be listed in the root index', () => {
+  const workspaceRoot = createWorkspace('activation-local-unlisted', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)']),
+    '.xdrs/_local/index.md': localScopeIndex(),
+    ...coreWithScopeTypes(['_local']),
+  });
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  expect(activationErrors(result)).toBe('');
+});
+
+test('reports a scope linked twice, including ./x/index.md vs x/index.md [022.01]', () => {
+  const workspaceRoot = createWorkspace('activation-duplicate-link', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope myteam](myteam/index.md)', '[again](./myteam/index.md)']),
+    ...scopeFiles('myteam'),
+  });
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  expect(activationErrors(result)).toContain('Root index links scope "myteam" more than once');
+});
+
+test('ignores scope links inside fenced code blocks [022.01]', () => {
+  const workspaceRoot = createWorkspace('activation-fenced-link', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '```', '[View scope myteam](myteam/index.md) `whatever`', '```']),
+    ...scopeFiles('myteam'),
+  });
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  expect(activationErrors(result)).toContain('missing scope index link');
+  expect(activationErrors(result)).not.toContain('022.03');
+});
+
+test('recognises a tag separated by tabs and spaces [022.03]', () => {
+  const workspaceRoot = createWorkspace('activation-tag-whitespace', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope myteam](myteam/index.md) \t  `disabled`', ACTIVATION_LEGEND]),
+    ...scopeFiles('myteam'),
+  });
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  expect(activationErrors(result)).toBe('');
+});
+
+test.each([
+  ['uppercase value', '[View scope myteam](myteam/index.md) `DISABLED`'],
+  ['unknown value', '[View scope myteam](myteam/index.md) `optional`'],
+  ['two tags', '[View scope myteam](myteam/index.md) `disabled` `extends-only`'],
+  ['tag placed later on the line', '[View scope myteam](myteam/index.md) - team rules `disabled`'],
+])('reports invalid activation tag: %s [022.03]', (_label, linkLine) => {
+  const workspaceRoot = createWorkspace(`activation-invalid-tag-${_label.replace(/\s+/g, '-')}`, {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', linkLine, ACTIVATION_LEGEND]),
+    ...scopeFiles('myteam'),
+  });
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  expect(activationErrors(result)).toContain('[_core-adr-policy-022.03-activation-tag-syntax]');
+});
+
+test('does not treat inline code on the next line or on other lines as a tag [022.03]', () => {
+  const workspaceRoot = createWorkspace('activation-tag-next-line', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope myteam](myteam/index.md)', '`disabled`']),
+    ...scopeFiles('myteam'),
+  });
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  expect(activationErrors(result)).toBe('');
+});
+
+test('reports an activation tag on _core [022.03]', () => {
+  const workspaceRoot = createWorkspace('activation-tag-core', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md) `disabled`', ACTIVATION_LEGEND]),
+    ...coreWithScopeTypes(['standard']),
+  });
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  expect(activationErrors(result)).toContain('Scope "_core" must not carry an activation tag');
+});
+
+test('reports extends-only: true without a tag and prints the exact line [022.07]', () => {
+  const workspaceRoot = createWorkspace('activation-field-no-tag', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope lib](lib/index.md)']),
+    ...scopeFiles('lib', 'extends-only: true\n'),
+  });
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  expect(activationErrors(result)).toContain('change it to: [View scope lib](lib/index.md) `extends-only`');
+  expect(activationErrors(result)).toContain('[_core-adr-policy-022.07-extends-only-field]');
+});
+
+test('accepts extends-only: true with a disabled tag [022.07]', () => {
+  const workspaceRoot = createWorkspace('activation-field-disabled', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope lib](lib/index.md) `disabled`', ACTIVATION_LEGEND]),
+    ...scopeFiles('lib', 'extends-only: true\n'),
+  });
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  expect(activationErrors(result)).toBe('');
+});
+
+test('accepts consumer narrowing: extends-only: false with an extends-only tag [022.07]', () => {
+  const workspaceRoot = createWorkspace('activation-field-narrowing', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope lib](lib/index.md) `extends-only`', '[View scope myteam](myteam/index.md)', ACTIVATION_LEGEND]),
+    ...scopeFiles('lib', 'extends-only: false\n'),
+    ...scopeFiles('myteam', 'extends: lib\n'),
+  });
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  expect(activationErrors(result)).toBe('');
+  expect(activationWarnings(result)).toBe('');
+});
+
+test.each([['quoted', '"true"'], ['capitalised', 'True']])('reports %s extends-only value in a local scope [022.07]', (_label, value) => {
+  const workspaceRoot = createWorkspace(`activation-field-invalid-${_label}`, {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope lib](lib/index.md)']),
+    ...scopeFiles('lib', `extends-only: ${value}\n`),
+  });
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  expect(activationErrors(result)).toContain('extends-only must be unquoted lowercase true or false');
+});
+
+test('marks external scope with invalid extends-only value read-only, treated as absent [022.06]', () => {
+  const workspaceRoot = createWorkspace('activation-field-invalid-external', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope lib](lib/index.md)']),
+    ...scopeFiles('lib', 'extends-only: yes\n'),
+    '.filedist.lock': '.xdrs/lib/index.md|some-package|1.0.0\n',
+  });
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  expect(activationErrors(result)).toBe('');
+  expect(result.readOnlyScopes.get('lib').join('\n')).toContain('invalid extends-only value "yes"');
+});
+
+test('reports extends-only on core-type and _local scopes [022.07]', () => {
+  const workspaceRoot = createWorkspace('activation-field-core-local', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope area-core](area-core/index.md) `extends-only`', ACTIVATION_LEGEND]),
+    ...scopeFiles('area-core', 'extends-only: true\n', 'core'),
+    '.xdrs/_local/index.md': localScopeIndex().replace('valid-from: 2026-01-01', 'valid-from: 2026-01-01\nextends-only: true'),
+    ...coreWithScopeTypes(['_local']),
+  });
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  const errors = activationErrors(result);
+  expect(errors).toContain('Core-type scope "area-core" must not be tagged `extends-only`');
+  expect(errors).toContain('area-core/index.md [_core-adr-policy-022.07-extends-only-field]');
+  expect(errors).toContain('_local/index.md [_core-adr-policy-022.07-extends-only-field]');
+});
+
+test('warns when no active scope extends an extends-only scope [022.04]', () => {
+  const workspaceRoot = createWorkspace('activation-unused-extends-only', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope lib](lib/index.md) `extends-only`', ACTIVATION_LEGEND]),
+    ...scopeFiles('lib'),
+  });
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  expect(activationErrors(result)).toBe('');
+  expect(activationWarnings(result)).toContain('Scope "lib" is tagged `extends-only` but no active scope extends it');
+});
+
+test('warns when an extends-only scope is reached only through a disabled scope [022.04]', () => {
+  const workspaceRoot = createWorkspace('activation-reach-through-disabled', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope lib](lib/index.md) `extends-only`', '[View scope mid](mid/index.md) `disabled`', '[View scope myteam](myteam/index.md)', ACTIVATION_LEGEND]),
+    ...scopeFiles('lib'),
+    ...scopeFiles('mid', 'extends: lib\n'),
+    ...scopeFiles('myteam', 'extends: mid\n'),
+  });
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  expect(activationWarnings(result)).toContain('Scope "lib" is tagged `extends-only`');
+  expect(result.readOnlyScopes.get('myteam').join('\n')).toContain('extends: scope "mid" is tagged `disabled`');
+});
+
+test('makes a scope following a disabled scope read-only while it still reaches extends-only scopes [022.04, 022.06]', () => {
+  const workspaceRoot = createWorkspace('activation-read-only-reaches', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope area-core](area-core/index.md) `disabled`', '[View scope lib](lib/index.md) `extends-only`', '[View scope myteam](myteam/index.md)', ACTIVATION_LEGEND]),
+    ...scopeFiles('area-core', '', 'core'),
+    ...scopeFiles('lib'),
+    ...scopeFiles('myteam', 'follows: area-core\nextends: lib\n'),
+  });
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  expect(activationWarnings(result)).toBe('');
+  expect(result.readOnlyScopes.get('myteam').join('\n')).toContain('follows: scope "area-core" is tagged `disabled` in the root index; enable it or remove the follows: reference');
+});
+
+test('makes an external scope extending a disabled scope read-only [022.06]', () => {
+  const workspaceRoot = createWorkspace('activation-external-extends-disabled', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope lib](lib/index.md) `disabled`', '[View scope vendor](vendor/index.md)', ACTIVATION_LEGEND]),
+    ...scopeFiles('lib'),
+    ...scopeFiles('vendor', 'extends: lib\n'),
+    '.filedist.lock': '.xdrs/vendor/index.md|some-package|1.0.0\n',
+  });
+  const result = lintWorkspace(workspaceRoot);
+  expect(result.readOnlyScopes.has('vendor')).toBe(true);
+});
+
+test('makes _local extending a disabled scope read-only [022.06]', () => {
+  const workspaceRoot = createWorkspace('activation-local-extends-disabled', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope lib](lib/index.md) `disabled`', ACTIVATION_LEGEND]),
+    ...scopeFiles('lib'),
+    '.xdrs/_local/index.md': localScopeIndex().replace('valid-from: 2026-01-01', 'valid-from: 2026-01-01\nextends: lib'),
+    ...coreWithScopeTypes(['standard', '_local']),
+  });
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  expect(result.readOnlyScopes.has('_local')).toBe(true);
+});
+
+test('makes a scope whose type is defined only in a disabled scope read-only [022.06]', () => {
+  const workspaceRoot = createWorkspace('activation-type-in-disabled-scope', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope widgets-core](widgets-core/index.md) `disabled`', '[View scope shop](shop/index.md)', ACTIVATION_LEGEND]),
+    '.xdrs/widgets-core/index.md': scopeIndexWith('widgets-core', '', 'core'),
+    '.xdrs/widgets-core/adrs/index.md': teamAdrIndex(['- [001-widget-scope-type](principles/001-widget-scope-type.md) - Widget type']),
+    '.xdrs/widgets-core/adrs/principles/001-widget-scope-type.md': structuredScopeTypePolicy('widgets-core', '001', 'widget'),
+    ...scopeFiles('shop', '', 'widget'),
+    ...coreWithScopeTypes(['standard']),
+  });
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  expect(result.errors.join('\n')).not.toContain('has no corresponding widget-scope-type policy');
+  expect(result.readOnlyScopes.get('shop').join('\n')).toContain('scope type "widget" is defined only in disabled scope(s) "widgets-core"');
+});
+
+test('prints one read-only line per cause citing 022.06', () => {
+  const workspaceRoot = createWorkspace('activation-cli-read-only', {
+    '.xdrs/index.md': rootIndex(['[View scope _core](_core/index.md)', '[View scope area-core](area-core/index.md) `disabled`', '[View scope lib](lib/index.md) `disabled`', '[View scope myteam](myteam/index.md)', ACTIVATION_LEGEND]),
+    ...scopeFiles('area-core', '', 'core'),
+    ...scopeFiles('lib'),
+    ...scopeFiles('myteam', 'follows: area-core\nextends: lib\n'),
+  });
+  const { runLintCli } = require('./lint');
+  const logs = [];
+  const logSpy = jest.spyOn(console, 'log').mockImplementation((msg) => logs.push(msg));
+  const errSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+  const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+  try {
+    runLintCli(['--all', workspaceRoot]);
+  } finally {
+    logSpy.mockRestore();
+    errSpy.mockRestore();
+    warnSpy.mockRestore();
+  }
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  expect(result.readOnlyScopes.get('myteam')).toHaveLength(2);
+  const readOnlyLines = logs.filter((l) => l.includes('READ-ONLY scope "myteam"'));
+  expect(readOnlyLines).toHaveLength(2);
+  expect(readOnlyLines.every((l) => l.includes('[_core-adr-policy-022.06-read-only-dependencies]'))).toBe(true);
+});
+
+test('dry-run workspace: disabled core, extends-only ref, unlisted legacy scope', () => {
+  const workspaceRoot = createWorkspace('activation-dry-run', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope ecomm-core](ecomm-core/index.md) `disabled`', '[View scope payments-ref](payments-ref/index.md) `extends-only`', '[View scope checkout](checkout/index.md)', ACTIVATION_LEGEND]),
+    ...scopeFiles('ecomm-core', '', 'core'),
+    ...scopeFiles('payments-ref', 'extends-only: true\n'),
+    ...scopeFiles('checkout', 'follows: ecomm-core\nextends: payments-ref\n'),
+    ...scopeFiles('legacy'),
+  });
+  const disabledIndexBefore = fs.readFileSync(path.join(workspaceRoot, '.xdrs/ecomm-core/index.md'), 'utf8');
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  expect(result.readOnlyScopes.get('checkout')).toHaveLength(1);
+  expect(activationWarnings(result)).toBe('');
+  expect(activationErrors(result)).toContain('[View scope legacy](legacy/index.md)');
+  expect(activationErrors(result).split('\n')).toHaveLength(1);
+  expect(fs.readFileSync(path.join(workspaceRoot, '.xdrs/ecomm-core/index.md'), 'utf8')).toBe(disabledIndexBefore);
+});
+
+test('reports activation tags without the legend line [022.09]', () => {
+  const workspaceRoot = createWorkspace('activation-no-legend', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope myteam](myteam/index.md) `disabled`']),
+    ...scopeFiles('myteam'),
+  });
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  expect(activationErrors(result)).toContain('[_core-adr-policy-022.09-root-index-ownership]');
+});
+
+function coreWithParentType(typeName, parentType) {
+  const files = coreWithScopeTypes(['standard', typeName]);
+  const policyPath = Object.keys(files).find((p) => p.endsWith(`-${typeName}-scope-type.md`));
+  const num = path.basename(policyPath).slice(0, 3);
+  files[policyPath] = `${structuredScopeTypePolicy('_core', num, typeName)}\n#### 02-parent-scope-type\n\nInstances inherit all rules from the \`${parentType}\` scope type.\n`;
+  return files;
+}
+
+test('treats a type whose parent chain reaches core as core-type (naming, follows, structured) [011.03]', () => {
+  const workspaceRoot = createWorkspace('scope-type-inherited-core', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope gov](gov/index.md)', '[View scope myteam](myteam/index.md)']),
+    ...scopeFiles('gov', '', 'governance'),
+    ...scopeFiles('myteam', 'follows: gov\n'),
+    ...coreWithParentType('governance', 'core'),
+  });
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  const errors = result.errors.join('\n');
+  expect(errors).toContain('gov/index.md [_core-adr-policy-011.03-naming-convention]');
+  expect(errors).not.toContain('follows references scope "gov" which is not a core-type scope');
+  expect(errors).toContain('_core-adr-policy-010.12-def-core-scope-policies-must-be-structured');
+});
+
+test('reports missing scope-type for local scopes and marks external ones read-only [010.10, 022.06]', () => {
+  const noType = (name) => `---\nname: ${name}\ndescription: Scope ${name}.\napply-to: Test teams\nvalid-from: 2026-01-01\n---\n\n# ${name}\n`;
+  const workspaceRoot = createWorkspace('scope-type-missing-local-external', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope localone](localone/index.md)', '[View scope vendor](vendor/index.md)']),
+    '.xdrs/localone/index.md': noType('localone'),
+    '.xdrs/vendor/index.md': noType('vendor'),
+    '.filedist.lock': '.xdrs/vendor/index.md|some-package|1.0.0\n',
+    ...coreWithScopeTypes(['standard']),
+  });
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  const missingTypeErrors = result.errors.filter((e) => e.includes('must include a scope-type field'));
+  expect(missingTypeErrors.join('\n')).toContain('localone/index.md');
+  expect(missingTypeErrors.join('\n')).not.toContain('vendor/index.md');
+  expect(result.readOnlyScopes.get('vendor').join('\n')).toContain('no scope-type');
+});
+
+test('reports missing parent type for local scopes and marks external ones read-only [010.09, 022.06]', () => {
+  const workspaceRoot = createWorkspace('scope-type-missing-parent', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope localone](localone/index.md)', '[View scope vendor](vendor/index.md)']),
+    ...scopeFiles('localone', '', 'widget'),
+    ...scopeFiles('vendor', '', 'widget'),
+    '.filedist.lock': '.xdrs/vendor/index.md|some-package|1.0.0\n',
+    ...coreWithParentType('widget', 'ghost'),
+  });
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  const parentErrors = result.errors.filter((e) => e.includes('declares parent "ghost"'));
+  expect(parentErrors).toHaveLength(1);
+  expect(parentErrors[0]).toContain('localone/index.md');
+  expect(result.readOnlyScopes.get('vendor').join('\n')).toContain('scope type "ghost"');
+});
+
+test('accepts compiled combined with a non-core type [011.10]', () => {
+  const workspaceRoot = createWorkspace('scope-type-compiled-combo', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope sec-ref-owasp](sec-ref-owasp/index.md)']),
+    ...scopeFiles('sec-ref-owasp', '', 'compiled, reference'),
+  });
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  expect(result.errors.join('\n')).not.toContain('011.10');
+});