xdrs-core 0.55.0 → 0.56.1

package/lib/lint.test.js

@@ -5905,16 +5905,147 @@ test('reports a local scope whose type is defined only in a disabled scope as fr
   expect(activationErrors(result)).toContain('Local scope "shop" is frozen (read-only) because scope type "widget" is defined only in disabled scope(s) "widgets-core"');
 });
 
-test('reports missing dependencies of a disabled local scope as errors [022.05]', () => {
+test('does not report missing dependencies of a disabled scope [022.06]', () => {
   const workspaceRoot = createWorkspace('activation-disabled-local-missing-deps', {
     '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope myteam](myteam/index.md) `disabled`', ACTIVATION_LEGEND]),
     ...scopeFiles('myteam', 'follows: ghost-core\nextends: ghost-lib\n', 'phantom'),
     ...coreWithScopeTypes(['standard']),
   });
   const errors = lintWorkspace(workspaceRoot, { ignoreExternal: false }).errors.join('\n');
-  expect(errors).toContain('follows references scope "ghost-core" which does not exist in the workspace');
-  expect(errors).toContain('ghost-lib');
-  expect(errors).toContain('phantom');
+  expect(errors).not.toContain('ghost-core');
+  expect(errors).not.toContain('ghost-lib');
+  expect(errors).not.toContain('phantom');
+});
+
+test('does not report a disabled scope extending a disabled scope [022.06]', () => {
+  const workspaceRoot = createWorkspace('activation-disabled-extends-disabled', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope lib](lib/index.md) `disabled`', '[View scope mid](mid/index.md) `disabled`', ACTIVATION_LEGEND]),
+    ...scopeFiles('lib'),
+    ...scopeFiles('mid', 'extends: lib\n'),
+  });
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+  expect(activationErrors(result)).toBe('');
+  expect(result.errors.join('\n')).not.toContain('frozen');
+});
+
+test('does not report a disabled scope following a disabled core scope [022.06]', () => {
+  const workspaceRoot = createWorkspace('activation-disabled-follows-disabled', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope area-core](area-core/index.md) `disabled`', '[View scope myteam](myteam/index.md) `disabled`', ACTIVATION_LEGEND]),
+    ...scopeFiles('area-core', '', 'core'),
+    ...scopeFiles('myteam', 'follows: area-core\n'),
+  });
+  expect(activationErrors(lintWorkspace(workspaceRoot, { ignoreExternal: false }))).toBe('');
+});
+
+test('does not report a disabled scope whose type is defined only in a disabled scope [022.06]', () => {
+  const workspaceRoot = createWorkspace('activation-disabled-type-in-disabled', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope widgets-core](widgets-core/index.md) `disabled`', '[View scope shop](shop/index.md) `disabled`', 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']),
+  });
+  expect(activationErrors(lintWorkspace(workspaceRoot, { ignoreExternal: false }))).toBe('');
+});
+
+test('does not report a disabled scope extending a scope with an invalid index [022.06]', () => {
+  const workspaceRoot = createWorkspace('activation-disabled-extends-invalid', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope lib](lib/index.md)', '[View scope mid](mid/index.md) `disabled`', ACTIVATION_LEGEND]),
+    ...scopeFiles('lib'),
+    '.xdrs/lib/index.md': '# lib without frontmatter\n',
+    ...scopeFiles('mid', 'extends: lib\n'),
+  });
+  expect(activationErrors(lintWorkspace(workspaceRoot, { ignoreExternal: false }))).not.toContain('Local scope "mid" is frozen');
+});
+
+test('does not report a disabled external scope extending a disabled or missing scope [022.06]', () => {
+  const workspaceRoot = createWorkspace('activation-disabled-external-extends', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope lib](lib/index.md) `disabled`', '[View scope vendor](vendor/index.md) `disabled`', ACTIVATION_LEGEND]),
+    ...scopeFiles('lib'),
+    ...scopeFiles('vendor', 'extends: lib, ghost-lib\n'),
+    '.filedist.lock': '.xdrs/vendor/index.md|some-package|1.0.0\n',
+  });
+  expect(activationErrors(lintWorkspace(workspaceRoot, { ignoreExternal: false }))).toBe('');
+});
+
+test('does not report a disabled scope with extends-only: true extending a disabled scope [022.06]', () => {
+  const workspaceRoot = createWorkspace('activation-disabled-extends-only-field', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope lib](lib/index.md) `disabled`', '[View scope mid](mid/index.md) `disabled`', ACTIVATION_LEGEND]),
+    ...scopeFiles('lib'),
+    ...scopeFiles('mid', 'extends: lib\nextends-only: true\n'),
+  });
+  expect(activationErrors(lintWorkspace(workspaceRoot, { ignoreExternal: false }))).toBe('');
+});
+
+test('reports only the enabled extender in the chain enabled -> disabled -> disabled [022.06]', () => {
+  const workspaceRoot = createWorkspace('activation-chain-enabled-disabled-disabled', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope lib](lib/index.md) `disabled`', '[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 errors = activationErrors(lintWorkspace(workspaceRoot, { ignoreExternal: false }));
+  expect(errors).toContain('Local scope "myteam" is frozen (read-only) because extends: scope "mid" is tagged `disabled`');
+  expect(errors).not.toContain('Local scope "mid"');
+});
+
+test('reports only the direct extender in the chain enabled -> enabled -> disabled [022.06]', () => {
+  const workspaceRoot = createWorkspace('activation-chain-enabled-enabled-disabled', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope lib](lib/index.md) `disabled`', '[View scope mid](mid/index.md)', '[View scope myteam](myteam/index.md)', ACTIVATION_LEGEND]),
+    ...scopeFiles('lib'),
+    ...scopeFiles('mid', 'extends: lib\n'),
+    ...scopeFiles('myteam', 'extends: mid\n'),
+  });
+  const errors = activationErrors(lintWorkspace(workspaceRoot, { ignoreExternal: false }));
+  expect(errors).toContain('Local scope "mid" is frozen (read-only) because extends: scope "lib" is tagged `disabled`');
+  expect(errors).not.toContain('Local scope "myteam"');
+});
+
+test('still reports an enabled scope extending a missing scope [010.32]', () => {
+  const workspaceRoot = createWorkspace('activation-enabled-extends-missing', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope myteam](myteam/index.md)']),
+    ...scopeFiles('myteam', 'extends: ghost-lib\n'),
+  });
+  const errors = lintWorkspace(workspaceRoot, { ignoreExternal: false }).errors.join('\n');
+  expect(errors).toContain('extends references scope "ghost-lib" which does not exist in the workspace');
+});
+
+test('still reports extends cycles and self-extends in disabled scopes [010.30, 010.31]', () => {
+  const workspaceRoot = createWorkspace('activation-disabled-structural', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope a](a/index.md) `disabled`', '[View scope b](b/index.md) `disabled`', '[View scope c](c/index.md) `disabled`', ACTIVATION_LEGEND]),
+    ...scopeFiles('a', 'extends: b\n'),
+    ...scopeFiles('b', 'extends: a\n'),
+    ...scopeFiles('c', 'extends: c\n'),
+  });
+  const errors = lintWorkspace(workspaceRoot, { ignoreExternal: false }).errors.join('\n');
+  expect(errors).toContain('Circular extends chain detected');
+  expect(errors).toContain('must not reference the scope itself');
+});
+
+test('still reports a disabled scope following a non-core scope [001]', () => {
+  const workspaceRoot = createWorkspace('activation-disabled-follows-non-core', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope lib](lib/index.md)', '[View scope mid](mid/index.md) `disabled`', ACTIVATION_LEGEND]),
+    ...scopeFiles('lib'),
+    ...scopeFiles('mid', 'follows: lib\n'),
+  });
+  const errors = lintWorkspace(workspaceRoot, { ignoreExternal: false }).errors.join('\n');
+  expect(errors).toContain('follows references scope "lib" which is not a core-type scope');
+});
+
+test('reports an enabled scope type defined only in a disabled scope as frozen while a disabled user is exempt [022.06]', () => {
+  const workspaceRoot = createWorkspace('activation-type-enabled-vs-disabled-user', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope widgets-core](widgets-core/index.md) `disabled`', '[View scope shop](shop/index.md)', '[View scope kiosk](kiosk/index.md) `disabled`', 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'),
+    ...scopeFiles('kiosk', '', 'widget'),
+    ...coreWithScopeTypes(['standard']),
+  });
+  const errors = activationErrors(lintWorkspace(workspaceRoot, { ignoreExternal: false }));
+  expect(errors).toContain('Local scope "shop" is frozen (read-only)');
+  expect(errors).not.toContain('Local scope "kiosk"');
 });
 
 test('prints frozen local scopes as errors and never prints warning or READ-ONLY lines [022.06]', () => {
@@ -6048,3 +6179,161 @@ test('accepts compiled combined with a non-core type [011.10]', () => {
   const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
   expect(result.errors.join('\n')).not.toContain('011.10');
 });
+
+// ---------------------------------------------------------------------------
+// sync-date frontmatter (_core-adr-policy-024)
+// ---------------------------------------------------------------------------
+
+const SYNC_DATE_ERRORS = (result) => result.errors.filter((e) => e.includes('sync-date')).join('\n');
+
+function syncDatePolicy(extraFrontmatter) {
+  return [
+    '---',
+    'name: _local-adr-policy-001-main',
+    'description: Test XDRS element',
+    'apply-to: All scopes',
+    'valid-from: 2026-01-01',
+    ...extraFrontmatter,
+    '---',
+    '',
+    '# _local-adr-policy-001: Main decision',
+    '',
+    '## Context and Problem Statement',
+    '',
+    'Test body.',
+    '',
+    '## Decision Outcome',
+    '',
+    'Test decision outcome.',
+    ''
+  ].join('\n');
+}
+
+test('accepts a valid sync-date in Policy frontmatter', () => {
+  const workspaceRoot = createWorkspace('syncd-policy-valid', {
+    '.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': syncDatePolicy(['sync-date: 2026-11-04']),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(SYNC_DATE_ERRORS(result)).toBe('');
+  expect(result.errors.join('\n')).not.toContain('unknown field');
+});
+
+test('reports invalid and empty sync-date in Policy frontmatter', () => {
+  for (const [name, value] of [['syncd-policy-invalid', 'sync-date: yesterday'], ['syncd-policy-empty', 'sync-date:'], ['syncd-policy-quoted', 'sync-date: "2026-11-04"']]) {
+    const workspaceRoot = createWorkspace(name, {
+      '.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': syncDatePolicy([value]),
+    });
+
+    const result = lintWorkspace(workspaceRoot);
+
+    expect(SYNC_DATE_ERRORS(result)).toContain('Policy frontmatter sync-date must be a valid ISO date YYYY-MM-DD');
+  }
+});
+
+test('reports sync-date in a Policy of a compiled scope', () => {
+  const policy = validCompiledPolicy().replace('valid-from: 2026-01-01\n', 'valid-from: 2026-01-01\nsync-date: 2026-11-04\n');
+  const workspaceRoot = createWorkspace('syncd-compiled-policy', {
+    '.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': policy,
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(SYNC_DATE_ERRORS(result)).toContain('024.07-compiled-scopes');
+});
+
+test('accepts sync-date in the scope index of a compiled scope', () => {
+  const workspaceRoot = createWorkspace('syncd-compiled-scope-index', {
+    '.xdrs/index.md': rootIndex(['[my-compiled](my-compiled/index.md)']),
+    '.xdrs/my-compiled/index.md': compiledScopeIndex().replace('valid-from: 2026-01-01\n', 'valid-from: 2026-01-01\nsync-date: 2026-11-04\n'),
+    '.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(SYNC_DATE_ERRORS(result)).toBe('');
+  expect(result.errors.join('\n')).not.toContain('unknown field');
+});
+
+test('reports invalid sync-date in scope index frontmatter', () => {
+  const workspaceRoot = createWorkspace('syncd-scope-index-invalid', {
+    '.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\nsync-date: 2026-13-45\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.'),
+  });
+
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
+
+  expect(SYNC_DATE_ERRORS(result)).toContain('Scope index frontmatter sync-date must be a valid ISO date YYYY-MM-DD');
+});
+
+test('validates metadata.sync-date in SKILL.md frontmatter', () => {
+  const skillWith = (syncDate) => fullSkillDocument().replace(
+    'description: Test skill document\n---',
+    `description: Test skill document\nmetadata:\n  version: "1.0.0"\n  author: test\n  updated: 2026-11-04\n  sync-date: ${syncDate}\n---`
+  );
+  const build = (name, syncDate) => createWorkspace(name, {
+    '.xdrs/index.md': rootIndex(),
+    '.xdrs/_local/adrs/index.md': localAdrIndex(['- [check-links](principles/skills/check-links/SKILL.md) - Check links']),
+    '.xdrs/_local/adrs/principles/skills/check-links/SKILL.md': skillWith(syncDate),
+  });
+
+  const valid = lintWorkspace(build('syncd-skill-valid', '2026-11-04'));
+  const invalid = lintWorkspace(build('syncd-skill-invalid', 'soon'));
+
+  expect(SYNC_DATE_ERRORS(valid)).toBe('');
+  expect(SYNC_DATE_ERRORS(invalid)).toContain('SKILL.md frontmatter metadata.sync-date must be a valid ISO date YYYY-MM-DD');
+});
+
+test('accepts sync-date-only frontmatter in article, research and initiative documents', () => {
+  const fm = '---\nsync-date: 2026-11-04\n---\n\n';
+  const workspaceRoot = createWorkspace('syncd-docs-valid', {
+    '.xdrs/index.md': rootIndex(),
+    '.xdrs/_local/adrs/index.md': localAdrIndex([
+      '- [001-guide](principles/articles/001-guide.md) - Guide',
+      '- [001-study](principles/researches/001-study.md) - Study',
+      '- [001-myinitiative](principles/initiatives/001-myinitiative.md) - My initiative',
+    ]),
+    '.xdrs/_local/adrs/principles/articles/001-guide.md': fm + articleDocument('Body.'),
+    '.xdrs/_local/adrs/principles/researches/001-study.md': fm + researchDocument('Context.', 'Question: Is this right?'),
+    '.xdrs/_local/adrs/principles/initiatives/001-myinitiative.md': fm + initiativeDocument('Body.'),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+
+  expect(SYNC_DATE_ERRORS(result)).toBe('');
+  expect(result.errors.join('\n')).not.toContain('title must start with');
+  expect(result.errors.join('\n')).not.toContain('frontmatter');
+});
+
+test('reports unknown, missing and invalid frontmatter fields in article, research and initiative documents', () => {
+  const workspaceRoot = createWorkspace('syncd-docs-invalid', {
+    '.xdrs/index.md': rootIndex(),
+    '.xdrs/_local/adrs/index.md': localAdrIndex([
+      '- [001-guide](principles/articles/001-guide.md) - Guide',
+      '- [001-study](principles/researches/001-study.md) - Study',
+      '- [001-myinitiative](principles/initiatives/001-myinitiative.md) - My initiative',
+    ]),
+    '.xdrs/_local/adrs/principles/articles/001-guide.md': '---\nsync-date: 2026-11-04\nauthor: me\n---\n\n' + articleDocument('Body.'),
+    '.xdrs/_local/adrs/principles/researches/001-study.md': '---\nsync-date: never\n---\n\n' + researchDocument('Context.', 'Question: Is this right?'),
+    '.xdrs/_local/adrs/principles/initiatives/001-myinitiative.md': '---\nauthor: me\n---\n\n' + initiativeDocument('Body.'),
+  });
+
+  const result = lintWorkspace(workspaceRoot);
+  const errors = result.errors.join('\n');
+
+  expect(errors).toContain('Article frontmatter has unknown field "author" (only sync-date is allowed)');
+  expect(errors).toContain('Research frontmatter sync-date must be a valid ISO date YYYY-MM-DD');
+  expect(errors).toContain('Initiative frontmatter has unknown field "author" (only sync-date is allowed)');
+  expect(errors).toContain('Initiative frontmatter must include a sync-date field when present');
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xdrs-core",
-  "version": "0.55.0",
+  "version": "0.56.1",
   "description": "XDRS (eXtensible Decision Record System): a framework to structure, compile and distribute Architectural (ADR), Business (BDR), and Engineering (EDR) decision records contents so that AI agents and humans can reliably find and use them with hierarchical scopes and controlled rollout in the format of distributable versioned packages.",
   "repository": {
     "type": "git",