xdrs-core 0.37.2 → 0.38.0

package/lib/lint.js

@@ -37,6 +37,26 @@ const ARTICLE_MAX_WORDS = 8000;
 const RESEARCH_MAX_WORDS = 5000;
 const SKILL_MAX_WORDS = 6500;
 
+const NORMATIVE_KEYWORDS_RE = /\bMUST NOT\b|\bMUST\b|\bSHOULD NOT\b|\bSHOULD\b|\bMAY\b|\bREQUIRED\b|\bOPTIONAL\b/;
+
+const RESEARCH_SECTION_LIMITS = {
+  '## Abstract': 200,
+  '## Introduction': 700,
+  '## Methods': 1200,
+  '## Results': 1800,
+  '## Discussion': 1000,
+  '## Conclusion': 400,
+};
+
+const DOC_TYPE_POLICY_REF = {
+  Policy: '[_core-adr-policy-002]',
+  Skill: '[_core-adr-policy-003]',
+  Article: '[_core-adr-policy-004]',
+  Research: '[_core-adr-policy-006]',
+  Plan: '[_core-adr-policy-007]',
+  Slide: '[_core-adr-policy-009]',
+};
+
 function runLintCli(args) {
   if (args.includes('--help') || args.includes('-h')) {
     printHelp();
@@ -50,6 +70,11 @@ function runLintCli(args) {
 
   if (result.errors.length === 0) {
     console.log(`Lint passed for ${toDisplayPath(result.xdrsRoot)}`);
+    if (result.readOnlyScopes.size > 0) {
+      for (const scopeName of result.readOnlyScopes) {
+        console.log(`- READ-ONLY scope "${scopeName}": one or more follows -core scopes are not present in this workspace; no changes must be made to this scope [_core-adr-policy-011.08-unavailable-core-read-only]`);
+      }
+    }
     return 0;
   }
 
@@ -84,10 +109,11 @@ function lintWorkspace(targetPath, options = {}) {
   const resolvedTarget = path.resolve(targetPath);
   const xdrsRoot = resolveXdrsRoot(resolvedTarget);
   const errors = [];
+  const readOnlyScopes = new Set();
 
   if (!existsDirectory(xdrsRoot)) {
-    errors.push(`Missing XDRS root directory: ${toDisplayPath(xdrsRoot)}`);
-    return { xdrsRoot, errors };
+    errors.push(`Missing XDRS root directory: ${toDisplayPath(xdrsRoot)} [_core-adr-policy-001]`);
+    return { xdrsRoot, errors, readOnlyScopes };
   }
 
   const repoRoot = path.dirname(xdrsRoot);
@@ -126,22 +152,22 @@ function lintWorkspace(targetPath, options = {}) {
 
   for (const entry of rootEntries) {
     if (entry.isFile() && entry.name !== 'index.md') {
-      errors.push(`Unexpected file at .xdrs root: ${entry.name}`);
+      errors.push(`Unexpected file at .xdrs root: ${entry.name} [_core-adr-policy-001]`);
     }
   }
 
   for (const scopeEntry of scopeEntries) {
-    lintScopeDirectory(xdrsRoot, scopeEntry.name, errors, actualTypeIndexes, ignoreExternal, effectiveExternalScopes, knownScopeTypes);
+    lintScopeDirectory(xdrsRoot, scopeEntry.name, errors, actualTypeIndexes, ignoreExternal, effectiveExternalScopes, knownScopeTypes, readOnlyScopes);
   }
 
   const rootIndexPath = path.join(xdrsRoot, 'index.md');
   if (!existsFile(rootIndexPath)) {
-    errors.push('Missing required root index: .xdrs/index.md');
+    errors.push('Missing required root index: .xdrs/index.md [_core-adr-policy-001]');
   } else {
     lintRootIndex(rootIndexPath, xdrsRoot, actualTypeIndexes, errors, effectiveExternalScopes);
   }
 
-  return { xdrsRoot, errors };
+  return { xdrsRoot, errors, readOnlyScopes };
 }
 
 function lintRootIndex(rootIndexPath, xdrsRoot, actualTypeIndexes, errors, externalScopes = new Set()) {
@@ -149,14 +175,17 @@ function lintRootIndex(rootIndexPath, xdrsRoot, actualTypeIndexes, errors, exter
   const repoRoot = path.dirname(xdrsRoot);
 
   if (!content.includes(REQUIRED_ROOT_INDEX_TEXT)) {
-    errors.push(`Root index is missing required override text: ${toDisplayPath(rootIndexPath)}`);
+    errors.push(`Root index is missing required override text: ${toDisplayPath(rootIndexPath)} [_core-adr-policy-001]`);
   }
 
   const links = parseLocalLinks(content, path.dirname(rootIndexPath), repoRoot);
   for (const linkPath of links) {
     if (!fs.existsSync(linkPath)) {
       if (isExternalScopeLink(linkPath, xdrsRoot, externalScopes)) continue;
-      errors.push(`Broken link in root index: ${displayPath(rootIndexPath, linkPath)}`);
+      errors.push(`Broken link in root index: ${displayPath(rootIndexPath, linkPath)} [_core-adr-policy-001]`);
+    }
+    if (isCanonicalTypeIndex(linkPath, xdrsRoot)) {
+      errors.push(`Root index must not link directly to type indexes: ${displayPath(rootIndexPath, linkPath)} [_core-adr-policy-001]`);
     }
   }
 
@@ -166,7 +195,7 @@ function lintRootIndex(rootIndexPath, xdrsRoot, actualTypeIndexes, errors, exter
 
   for (const linkPath of links) {
     if (isPathInside(localScopePath, linkPath) || normalizePath(linkPath) === localScopePath) {
-      errors.push(`Root index must not link into _local scope: ${displayPath(rootIndexPath, linkPath)}`);
+      errors.push(`Root index must not link into _local scope: ${displayPath(rootIndexPath, linkPath)} [_core-adr-policy-001]`);
     }
   }
 
@@ -182,7 +211,7 @@ function lintRootIndex(rootIndexPath, xdrsRoot, actualTypeIndexes, errors, exter
   for (const scopeName of scopesWithTypeIndexes) {
     const scopeIndexPath = normalizePath(path.join(xdrsRoot, scopeName, 'index.md'));
     if (!linkedSet.has(scopeIndexPath)) {
-      errors.push(`Root index is missing scope index link: ${toDisplayPath(path.join(xdrsRoot, scopeName, 'index.md'))}`);
+      errors.push(`Root index is missing scope index link: ${toDisplayPath(path.join(xdrsRoot, scopeName, 'index.md'))} [_core-adr-policy-001]`);
     }
   }
 }
@@ -196,13 +225,13 @@ function lintScopeIndex(scopeIndexPath, xdrsRoot, scopeName, typeIndexesInScope,
   for (const linkPath of links) {
     if (!fs.existsSync(linkPath)) {
       if (isExternalScopeLink(linkPath, xdrsRoot, externalScopes)) continue;
-      errors.push(`Broken link in scope index: ${displayPath(scopeIndexPath, linkPath)}`);
+      errors.push(`Broken link in scope index: ${displayPath(scopeIndexPath, linkPath)} [_core-adr-policy-001]`);
     }
   }
 
   for (const typeIndexPath of typeIndexesInScope) {
     if (!linkedSet.has(normalizePath(typeIndexPath))) {
-      errors.push(`Scope index ${toDisplayPath(scopeIndexPath)} is missing link to type index: ${toDisplayPath(typeIndexPath)}`);
+      errors.push(`Scope index ${toDisplayPath(scopeIndexPath)} is missing link to type index: ${toDisplayPath(typeIndexPath)} [_core-adr-policy-001]`);
     }
   }
 }
@@ -223,11 +252,11 @@ function extractParentScopeType(policyFilePath) {
   return bodyMatch ? bodyMatch[1] : null;
 }
 
-function lintScopeIndexFrontmatter(scopeIndexPath, scopeName, errors, xdrsRoot, knownScopeTypes = new Map()) {
+function lintScopeIndexFrontmatter(scopeIndexPath, scopeName, errors, xdrsRoot, knownScopeTypes = new Map(), readOnlyScopes = new Set()) {
   const content = fs.readFileSync(scopeIndexPath, 'utf8');
   const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
   if (!fmMatch) {
-    errors.push(`Scope index must start with a YAML frontmatter block: ${toDisplayPath(scopeIndexPath)}`);
+    errors.push(`Scope index must start with a YAML frontmatter block: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-001]`);
     return;
   }
   const block = fmMatch[1];
@@ -235,22 +264,22 @@ function lintScopeIndexFrontmatter(scopeIndexPath, scopeName, errors, xdrsRoot,
 
   for (const key of fm.topLevelKeys) {
     if (!SCOPE_INDEX_ALLOWED_FRONTMATTER_KEYS.has(key)) {
-      errors.push(`Scope index frontmatter has unknown field "${key}": ${toDisplayPath(scopeIndexPath)}`);
+      errors.push(`Scope index frontmatter has unknown field "${key}": ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-001]`);
     }
   }
 
   const scopeTypeMatch = block.match(/^scope-type:\s*(.+)$/m);
   const scopeType = scopeTypeMatch ? scopeTypeMatch[1].trim() : null;
   if (!scopeType) {
-    errors.push(`Scope index frontmatter must include a scope-type field: ${toDisplayPath(scopeIndexPath)}`);
+    errors.push(`Scope index frontmatter must include a scope-type field: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-010.08-def-valid-iff-policy-exists]`);
     return;
   }
   if (scopeType.startsWith('_') && scopeType !== '_local') {
-    errors.push(`Scope type "${scopeType}" uses a reserved "_" prefix; only "_local" is a valid underscore-prefixed scope type: ${toDisplayPath(scopeIndexPath)}`);
+    errors.push(`Scope type "${scopeType}" uses a reserved "_" prefix; only "_local" is a valid underscore-prefixed scope type: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-010.06-def-no-underscore-prefix]`);
     return;
   }
   if (!knownScopeTypes.has(scopeType) && scopeType !== '_local') {
-    errors.push(`Scope index scope-type "${scopeType}" has no corresponding ${scopeType}-scope-type policy in the principles of any scope: ${toDisplayPath(scopeIndexPath)}`);
+    errors.push(`Scope index scope-type "${scopeType}" has no corresponding ${scopeType}-scope-type policy in the principles of any scope: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-010.08-def-valid-iff-policy-exists]`);
     return;
   }
   // Validate inheritance chain: ensure all ancestors exist in knownScopeTypes
@@ -263,11 +292,11 @@ function lintScopeIndexFrontmatter(scopeIndexPath, scopeName, errors, xdrsRoot,
       const parentType = extractParentScopeType(policyPath);
       if (!parentType) break;
       if (visited.has(parentType)) {
-        errors.push(`Scope type "${currentType}" declares parent "${parentType}" which creates a cycle in the scope-type inheritance chain: ${toDisplayPath(scopeIndexPath)}`);
+        errors.push(`Scope type "${currentType}" declares parent "${parentType}" which creates a cycle in the scope-type inheritance chain: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-010.07-def-parent-scope-type]`);
         break;
       }
       if (!knownScopeTypes.has(parentType)) {
-        errors.push(`Scope type "${currentType}" declares parent "${parentType}" but no ${parentType}-scope-type policy exists in any scope: ${toDisplayPath(scopeIndexPath)}`);
+        errors.push(`Scope type "${currentType}" declares parent "${parentType}" but no ${parentType}-scope-type policy exists in any scope: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-010.07-def-parent-scope-type]`);
         break;
       }
       visited.add(parentType);
@@ -275,51 +304,51 @@ function lintScopeIndexFrontmatter(scopeIndexPath, scopeName, errors, xdrsRoot,
     }
   }
   if (scopeName === '_core' && scopeType !== 'core') {
-    errors.push(`Scope "_core" must have scope-type "core": ${toDisplayPath(scopeIndexPath)}`);
+    errors.push(`Scope "_core" must have scope-type "core": ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-011.01-scope-type-name]`);
   }
   if (scopeName === '_local' && scopeType !== '_local') {
-    errors.push(`Scope "_local" must have scope-type "_local": ${toDisplayPath(scopeIndexPath)}`);
+    errors.push(`Scope "_local" must have scope-type "_local": ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-015.01-scope-type-name]`);
   }
   if (scopeType === 'core' && !scopeName.includes('core')) {
-    errors.push(`Scope with type "core" must have "core" in its name: ${toDisplayPath(scopeIndexPath)}`);
+    errors.push(`Scope with type "core" must have "core" in its name: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-011.03-naming-convention]`);
   }
   if (scopeType === '_local' && scopeName !== '_local') {
-    errors.push(`Scope type "_local" is reserved for the "_local" scope: ${toDisplayPath(scopeIndexPath)}`);
+    errors.push(`Scope type "_local" is reserved for the "_local" scope: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-015.03-exclusive-reservation]`);
   }
   if (scopeType === 'reference' && !scopeName.includes('-ref-')) {
-    errors.push(`Scope with type "reference" must follow the naming pattern {domain}-ref-{name} (e.g. "security-ref-baseline"): ${toDisplayPath(scopeIndexPath)}`);
+    errors.push(`Scope with type "reference" must follow the naming pattern {domain}-ref-{name} (e.g. "security-ref-baseline"): ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-012.03-naming-convention]`);
   }
   if (scopeType === 'platform' && !scopeName.includes('-plat-')) {
-    errors.push(`Scope with type "platform" must follow the naming pattern {domain}-plat-{name} (e.g. "cloud-plat-aws"): ${toDisplayPath(scopeIndexPath)}`);
+    errors.push(`Scope with type "platform" must follow the naming pattern {domain}-plat-{name} (e.g. "cloud-plat-aws"): ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-013.03-naming-convention]`);
   }
 
   if (!fm.name) {
-    errors.push(`Scope index frontmatter must include a non-empty name field: ${toDisplayPath(scopeIndexPath)}`);
+    errors.push(`Scope index frontmatter must include a non-empty name field: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-001]`);
   } else if (fm.name !== scopeName) {
-    errors.push(`Scope index frontmatter name must match scope directory name "${scopeName}": ${toDisplayPath(scopeIndexPath)}`);
+    errors.push(`Scope index frontmatter name must match scope directory name "${scopeName}": ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-001]`);
   }
 
   if (!fm.description) {
-    errors.push(`Scope index frontmatter must include a non-empty description field: ${toDisplayPath(scopeIndexPath)}`);
+    errors.push(`Scope index frontmatter must include a non-empty description field: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-001]`);
   } else if (fm.descriptionText && countWords(fm.descriptionText) > 40) {
-    errors.push(`Scope index frontmatter description must be 40 words or fewer: ${toDisplayPath(scopeIndexPath)}`);
+    errors.push(`Scope index frontmatter description must be 40 words or fewer: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-001]`);
   }
 
   if (!fm.appliedTo) {
-    errors.push(`Scope index frontmatter must include an apply-to field: ${toDisplayPath(scopeIndexPath)}`);
+    errors.push(`Scope index frontmatter must include an apply-to field: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-001]`);
   } else {
     const words = countWords(fm.appliedTo);
     if (words === 0) {
-      errors.push(`Scope index frontmatter apply-to must not be empty: ${toDisplayPath(scopeIndexPath)}`);
+      errors.push(`Scope index frontmatter apply-to must not be empty: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-001]`);
     } else if (words > 30) {
-      errors.push(`Scope index frontmatter apply-to must be 30 words or fewer: ${toDisplayPath(scopeIndexPath)}`);
+      errors.push(`Scope index frontmatter apply-to must be 30 words or fewer: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-001]`);
     }
   }
 
   if (!fm.validFrom) {
-    errors.push(`Scope index frontmatter must include a valid-from field: ${toDisplayPath(scopeIndexPath)}`);
+    errors.push(`Scope index frontmatter must include a valid-from field: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-001]`);
   } else if (!isIsoDate(fm.validFrom)) {
-    errors.push(`Scope index frontmatter valid-from must be a valid ISO date YYYY-MM-DD: ${toDisplayPath(scopeIndexPath)}`);
+    errors.push(`Scope index frontmatter valid-from must be a valid ISO date YYYY-MM-DD: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-001]`);
   }
 
   let followsEntries = [];
@@ -330,7 +359,7 @@ function lintScopeIndexFrontmatter(scopeIndexPath, scopeName, errors, xdrsRoot,
     const commaSeparatedPattern = /^[a-zA-Z_][a-zA-Z0-9_-]*(\s*,\s*[a-zA-Z_][a-zA-Z0-9_-]*)+$/;
     if (followsValue) {
       if (!scopeNamePattern.test(followsValue) && !commaSeparatedPattern.test(followsValue)) {
-        errors.push(`Scope index frontmatter follows must be a core scope name or list of core scope names: ${toDisplayPath(scopeIndexPath)}`);
+        errors.push(`Scope index frontmatter follows must be a core scope name or list of core scope names: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-001]`);
       }
     } else {
       const followsStart = block.indexOf(followsLineMatch[0]) + followsLineMatch[0].length;
@@ -341,7 +370,7 @@ function lintScopeIndexFrontmatter(scopeIndexPath, scopeName, errors, xdrsRoot,
         if (itemMatch) {
           const item = (itemMatch[1] || '').trim();
           if (!item || !scopeNamePattern.test(item)) {
-            errors.push(`Scope index frontmatter follows entries must be non-empty scope names: ${toDisplayPath(scopeIndexPath)}`);
+            errors.push(`Scope index frontmatter follows entries must be non-empty scope names: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-001]`);
             hasInvalidEntry = true;
             break;
           }
@@ -351,7 +380,7 @@ function lintScopeIndexFrontmatter(scopeIndexPath, scopeName, errors, xdrsRoot,
         }
       }
       if (!hasInvalidEntry && listItems.length === 0) {
-        errors.push(`Scope index frontmatter follows must be a core scope name or list of core scope names: ${toDisplayPath(scopeIndexPath)}`);
+        errors.push(`Scope index frontmatter follows must be a core scope name or list of core scope names: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-001]`);
       }
     }
     if (xdrsRoot) {
@@ -373,26 +402,26 @@ function lintScopeIndexFrontmatter(scopeIndexPath, scopeName, errors, xdrsRoot,
       const seenFollows = new Set();
       for (const entry of entries) {
         if (seenFollows.has(entry)) {
-          errors.push(`Scope index frontmatter follows has duplicate entry "${entry}": ${toDisplayPath(scopeIndexPath)}`);
+          errors.push(`Scope index frontmatter follows has duplicate entry "${entry}": ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-001]`);
         }
         seenFollows.add(entry);
         if (/^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(entry)) {
           if (entry === scopeName) {
-            errors.push(`Scope index frontmatter follows must not reference the scope itself: ${toDisplayPath(scopeIndexPath)}`);
+            errors.push(`Scope index frontmatter follows must not reference the scope itself: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-001]`);
             continue;
           }
           if (entry === '_core') {
-            errors.push(`Scope index frontmatter follows must not reference "_core" as it is always applied implicitly: ${toDisplayPath(scopeIndexPath)}`);
+            errors.push(`Scope index frontmatter follows must not reference "_core" as it is always applied implicitly: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-001]`);
             continue;
           }
           const followedIndexPath = path.join(xdrsRoot, entry, 'index.md');
           if (!existsFile(followedIndexPath)) {
-            errors.push(`Scope index frontmatter follows references scope "${entry}" which does not exist in the workspace: ${toDisplayPath(scopeIndexPath)}`);
+            readOnlyScopes.add(scopeName);
           } else {
             const followedContent = fs.readFileSync(followedIndexPath, 'utf8');
             const followedTypeMatch = followedContent.match(/^scope-type:\s*(.+)$/m);
             if (!followedTypeMatch || followedTypeMatch[1].trim() !== 'core') {
-              errors.push(`Scope index frontmatter follows references scope "${entry}" which is not a core-type scope: ${toDisplayPath(scopeIndexPath)}`);
+              errors.push(`Scope index frontmatter follows references scope "${entry}" which is not a core-type scope: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-001]`);
             }
           }
         }
@@ -406,7 +435,7 @@ function lintScopeIndexFrontmatter(scopeIndexPath, scopeName, errors, xdrsRoot,
     const scopeNamePattern = /^[a-zA-Z_][a-zA-Z0-9_-]*$/;
     if (relatedScopesValue) {
       if (!scopeNamePattern.test(relatedScopesValue)) {
-        errors.push(`Scope index frontmatter related-scopes must be a scope name or list of scope names: ${toDisplayPath(scopeIndexPath)}`);
+        errors.push(`Scope index frontmatter related-scopes must be a scope name or list of scope names: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-001]`);
       }
     } else {
       const relatedScopesStart = block.indexOf(relatedScopesLineMatch[0]) + relatedScopesLineMatch[0].length;
@@ -417,7 +446,7 @@ function lintScopeIndexFrontmatter(scopeIndexPath, scopeName, errors, xdrsRoot,
         if (itemMatch) {
           const item = (itemMatch[1] || '').trim();
           if (!item || !scopeNamePattern.test(item)) {
-            errors.push(`Scope index frontmatter related-scopes entries must be non-empty scope names: ${toDisplayPath(scopeIndexPath)}`);
+            errors.push(`Scope index frontmatter related-scopes entries must be non-empty scope names: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-001]`);
             hasInvalidEntry = true;
             break;
           }
@@ -427,7 +456,7 @@ function lintScopeIndexFrontmatter(scopeIndexPath, scopeName, errors, xdrsRoot,
         }
       }
       if (!hasInvalidEntry && listItems.length === 0) {
-        errors.push(`Scope index frontmatter related-scopes must be a scope name or list of scope names: ${toDisplayPath(scopeIndexPath)}`);
+        errors.push(`Scope index frontmatter related-scopes must be a scope name or list of scope names: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-001]`);
       }
     }
     if (xdrsRoot) {
@@ -444,20 +473,20 @@ function lintScopeIndexFrontmatter(scopeIndexPath, scopeName, errors, xdrsRoot,
       const seenRelated = new Set();
       for (const entry of entries) {
         if (seenRelated.has(entry)) {
-          errors.push(`Scope index frontmatter related-scopes has duplicate entry "${entry}": ${toDisplayPath(scopeIndexPath)}`);
+          errors.push(`Scope index frontmatter related-scopes has duplicate entry "${entry}": ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-001]`);
         }
         seenRelated.add(entry);
         if (/^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(entry)) {
           if (entry === scopeName) {
-            errors.push(`Scope index frontmatter related-scopes must not reference the scope itself: ${toDisplayPath(scopeIndexPath)}`);
+            errors.push(`Scope index frontmatter related-scopes must not reference the scope itself: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-001]`);
             continue;
           }
           if (followsEntries.includes(entry)) {
-            errors.push(`Scope index frontmatter related-scopes must not repeat scope "${entry}" already declared in follows: ${toDisplayPath(scopeIndexPath)}`);
+            errors.push(`Scope index frontmatter related-scopes must not repeat scope "${entry}" already declared in follows: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-001]`);
             continue;
           }
           if (!existsFile(path.join(xdrsRoot, entry, 'index.md'))) {
-            errors.push(`Scope index frontmatter related-scopes references scope "${entry}" which does not exist in the workspace: ${toDisplayPath(scopeIndexPath)}`);
+            errors.push(`Scope index frontmatter related-scopes references scope "${entry}" which does not exist in the workspace: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-001]`);
           }
         }
       }
@@ -465,7 +494,7 @@ function lintScopeIndexFrontmatter(scopeIndexPath, scopeName, errors, xdrsRoot,
   }
 }
 
-function lintScopeDirectory(xdrsRoot, scopeName, errors, actualTypeIndexes, ignoreExternal, externalScopes, knownScopeTypes = new Map()) {
+function lintScopeDirectory(xdrsRoot, scopeName, errors, actualTypeIndexes, ignoreExternal, externalScopes, knownScopeTypes = new Map(), readOnlyScopes = new Set()) {
   const scopePath = path.join(xdrsRoot, scopeName);
 
   if (ignoreExternal && externalScopes.has(scopeName)) {
@@ -473,7 +502,7 @@ function lintScopeDirectory(xdrsRoot, scopeName, errors, actualTypeIndexes, igno
   }
 
   if (!isValidScopeName(scopeName)) {
-    errors.push(`Invalid scope name: ${toDisplayPath(scopePath)}`);
+    errors.push(`Invalid scope name: ${toDisplayPath(scopePath)} [_core-adr-policy-001]`);
   }
 
   const typeIndexesInScope = [];
@@ -482,7 +511,7 @@ function lintScopeDirectory(xdrsRoot, scopeName, errors, actualTypeIndexes, igno
     const entryPath = path.join(scopePath, entry.name);
     if (entry.isDirectory()) {
       if (!TYPE_NAMES.has(entry.name)) {
-        errors.push(`Unexpected directory under scope ${scopeName}: ${toDisplayPath(entryPath)}`);
+        errors.push(`Unexpected directory under scope ${scopeName}: ${toDisplayPath(entryPath)} [_core-adr-policy-001]`);
         continue;
       }
       lintTypeDirectory(xdrsRoot, scopeName, entry.name, errors, actualTypeIndexes, externalScopes);
@@ -497,15 +526,15 @@ function lintScopeDirectory(xdrsRoot, scopeName, errors, actualTypeIndexes, igno
       continue;
     }
 
-    errors.push(`Unexpected file under scope ${scopeName}: ${toDisplayPath(entryPath)}`);
+    errors.push(`Unexpected file under scope ${scopeName}: ${toDisplayPath(entryPath)} [_core-adr-policy-001]`);
   }
 
   const scopeIndexPath = path.join(scopePath, 'index.md');
   if (!existsFile(scopeIndexPath)) {
-    errors.push(`Missing required scope index: ${toDisplayPath(scopeIndexPath)}`);
+    errors.push(`Missing required scope index: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-001]`);
   } else {
     lintScopeIndex(scopeIndexPath, xdrsRoot, scopeName, typeIndexesInScope, errors, externalScopes);
-    lintScopeIndexFrontmatter(scopeIndexPath, scopeName, errors, xdrsRoot, knownScopeTypes);
+    lintScopeIndexFrontmatter(scopeIndexPath, scopeName, errors, xdrsRoot, knownScopeTypes, readOnlyScopes);
   }
   lintScopeLocalStandards(xdrsRoot, scopeName, errors);
 }
@@ -533,7 +562,7 @@ function lintScopeLocalStandards(xdrsRoot, scopeName, errors) {
   }
   if (foundPolicies.length > 1) {
     const paths = foundPolicies.map((p) => toDisplayPath(p)).join(', ');
-    errors.push(`Scope "${scopeName}" has more than one scope-local standards policy (name ending with "${corePolicySuffix}"): ${paths}`);
+    errors.push(`Scope "${scopeName}" has more than one scope-local standards policy (name ending with "${corePolicySuffix}"): ${paths} [_core-adr-policy-010.10-local-placement]`);
   }
 }
 
@@ -544,7 +573,7 @@ function lintTypeDirectory(xdrsRoot, scopeName, typeName, errors, actualTypeInde
   const artifacts = [];
 
   if (!existsFile(indexPath)) {
-    errors.push(`Missing canonical index: ${toDisplayPath(indexPath)}`);
+    errors.push(`Missing canonical index: ${toDisplayPath(indexPath)} [_core-adr-policy-001]`);
   } else {
     actualTypeIndexes.push(indexPath);
   }
@@ -554,13 +583,13 @@ function lintTypeDirectory(xdrsRoot, scopeName, typeName, errors, actualTypeInde
     const entryPath = path.join(typePath, entry.name);
     if (entry.isFile()) {
       if (entry.name !== 'index.md') {
-        errors.push(`Unexpected file under ${scopeName}/${typeName}: ${toDisplayPath(entryPath)}`);
+        errors.push(`Unexpected file under ${scopeName}/${typeName}: ${toDisplayPath(entryPath)} [_core-adr-policy-001]`);
       }
       continue;
     }
 
     if (!ALLOWED_SUBJECTS[typeName].has(entry.name)) {
-      errors.push(`Invalid subject folder for ${typeName}: ${toDisplayPath(entryPath)}`);
+      errors.push(`Invalid subject folder for ${typeName}: ${toDisplayPath(entryPath)} [_core-adr-policy-001]`);
       continue;
     }
 
@@ -601,12 +630,12 @@ function lintSubjectDirectory(xdrsRoot, scopeName, typeName, subjectName, xdrsNu
         continue;
       }
 
-      errors.push(`Unexpected directory under ${scopeName}/${typeName}/${subjectName}: ${toDisplayPath(entryPath)}`);
+      errors.push(`Unexpected directory under ${scopeName}/${typeName}/${subjectName}: ${toDisplayPath(entryPath)} [_core-adr-policy-001]`);
       continue;
     }
 
     if (!NUMBERED_FILE_RE.test(entry.name)) {
-      errors.push(`Invalid Policy file name: ${toDisplayPath(entryPath)}`);
+      errors.push(`Invalid Policy file name: ${toDisplayPath(entryPath)} [_core-adr-policy-001]`);
       continue;
     }
 
@@ -631,25 +660,26 @@ function lintXdrsElementFile(xdrsRoot, scopeName, typeName, filePath, xdrsNumber
   const number = match[1];
   const previous = xdrsNumbers.get(number);
   if (previous) {
-    errors.push(`Duplicate Policy number ${number} in ${scopeName}/${typeName}: ${toDisplayPath(previous)} and ${toDisplayPath(filePath)}`);
+    errors.push(`Duplicate Policy number ${number} in ${scopeName}/${typeName}: ${toDisplayPath(previous)} and ${toDisplayPath(filePath)} [_core-adr-policy-002]`);
   } else {
     xdrsNumbers.set(number, filePath);
   }
 
   if (baseName !== baseName.toLowerCase()) {
-    errors.push(`Policy file name must be lowercase: ${toDisplayPath(filePath)}`);
+    errors.push(`Policy file name must be lowercase: ${toDisplayPath(filePath)} [_core-adr-policy-002]`);
   }
 
   const content = fs.readFileSync(filePath, 'utf8');
   const expectedHeader = `# ${scopeName}-${TYPE_TO_ID[typeName]}-${number}:`;
   const firstLine = firstNonEmptyLine(stripFrontmatter(content));
   if (!firstLine.startsWith(expectedHeader)) {
-    errors.push(`Policy title must start with "${expectedHeader}": ${toDisplayPath(filePath)}`);
+    errors.push(`Policy title must start with "${expectedHeader}": ${toDisplayPath(filePath)} [_core-adr-policy-002]`);
   }
 
   const expectedName = extractExpectedXdrsNameFromHeading(firstLine)
     || `${scopeName}-${TYPE_TO_ID[typeName]}-${number}-${match[2]}`;
   lintXdrsElementFrontmatter(content, expectedName, filePath, errors);
+  lintStructuredRuleBlocks(content, filePath, errors);
   lintRequiredSections(content, filePath, XDRS_REQUIRED_SECTIONS, 'Policy', errors);
   lintNoEmojis(content, filePath, 'Policy', errors);
   lintWordCount(content, filePath, 'Policy', POLICY_MAX_WORDS, errors);
@@ -684,42 +714,45 @@ function slugifyTitle(title) {
 function lintXdrsElementFrontmatter(content, expectedName, filePath, errors) {
   const fm = extractFrontmatter(content);
   if (!fm.present) {
-    errors.push(`Policy must start with a YAML frontmatter block: ${toDisplayPath(filePath)}`);
+    errors.push(`Policy must start with a YAML frontmatter block: ${toDisplayPath(filePath)} [_core-adr-policy-002]`);
     return;
   }
   if (!fm.name) {
-    errors.push(`Policy frontmatter must include a non-empty name field: ${toDisplayPath(filePath)}`);
+    errors.push(`Policy frontmatter must include a non-empty name field: ${toDisplayPath(filePath)} [_core-adr-policy-002]`);
   } else {
     if (fm.name !== expectedName) {
-      errors.push(`Policy frontmatter name must be "${expectedName}": ${toDisplayPath(filePath)}`);
+      errors.push(`Policy frontmatter name must be "${expectedName}": ${toDisplayPath(filePath)} [_core-adr-policy-002]`);
+    }
+    if (fm.name.endsWith('-')) {
+      errors.push(`Policy frontmatter name must not end with a hyphen: ${toDisplayPath(filePath)} [_core-adr-policy-002]`);
     }
     if (fm.name.length > 64) {
-      errors.push(`Policy frontmatter name must be 64 characters or fewer: ${toDisplayPath(filePath)}`);
+      errors.push(`Policy frontmatter name must be 64 characters or fewer: ${toDisplayPath(filePath)} [_core-adr-policy-002]`);
     }
   }
   if (!fm.description) {
-    errors.push(`Policy frontmatter must include a non-empty description field: ${toDisplayPath(filePath)}`);
+    errors.push(`Policy frontmatter must include a non-empty description field: ${toDisplayPath(filePath)} [_core-adr-policy-002]`);
   } else if (fm.descriptionText && fm.descriptionText.length > 1024) {
-    errors.push(`Policy frontmatter description must be 1024 characters or fewer: ${toDisplayPath(filePath)}`);
+    errors.push(`Policy frontmatter description must be 1024 characters or fewer: ${toDisplayPath(filePath)} [_core-adr-policy-002]`);
   }
   if (!fm.validFrom) {
-    errors.push(`Policy frontmatter must include a valid-from field: ${toDisplayPath(filePath)}`);
+    errors.push(`Policy frontmatter must include a valid-from field: ${toDisplayPath(filePath)} [_core-adr-policy-002]`);
   } else if (!isIsoDate(fm.validFrom)) {
-    errors.push(`Policy frontmatter valid-from must be a valid ISO date YYYY-MM-DD: ${toDisplayPath(filePath)}`);
+    errors.push(`Policy frontmatter valid-from must be a valid ISO date YYYY-MM-DD: ${toDisplayPath(filePath)} [_core-adr-policy-002]`);
   }
   if (!fm.appliedTo) {
-    errors.push(`Policy frontmatter must include an apply-to field: ${toDisplayPath(filePath)}`);
+    errors.push(`Policy frontmatter must include an apply-to field: ${toDisplayPath(filePath)} [_core-adr-policy-002]`);
   } else {
     const words = countWords(fm.appliedTo);
     if (words === 0) {
-      errors.push(`Policy frontmatter apply-to must not be empty: ${toDisplayPath(filePath)}`);
+      errors.push(`Policy frontmatter apply-to must not be empty: ${toDisplayPath(filePath)} [_core-adr-policy-002]`);
     } else if (words >= 40) {
-      errors.push(`Policy frontmatter apply-to must be under 40 words: ${toDisplayPath(filePath)}`);
+      errors.push(`Policy frontmatter apply-to must be under 40 words: ${toDisplayPath(filePath)} [_core-adr-policy-002]`);
     }
   }
   for (const key of fm.topLevelKeys) {
     if (!POLICY_ALLOWED_FRONTMATTER_KEYS.has(key)) {
-      errors.push(`Policy frontmatter has unknown field "${key}": ${toDisplayPath(filePath)}`);
+      errors.push(`Policy frontmatter has unknown field "${key}": ${toDisplayPath(filePath)} [_core-adr-policy-002]`);
     }
   }
 }
@@ -732,26 +765,26 @@ function lintSkillsDirectory(xdrsRoot, scopeName, typeName, subjectName, skillsP
   for (const entry of entries) {
     const entryPath = path.join(skillsPath, entry.name);
     if (!entry.isDirectory()) {
-      errors.push(`Unexpected file in skills directory: ${toDisplayPath(entryPath)}`);
+      errors.push(`Unexpected file in skills directory: ${toDisplayPath(entryPath)} [_core-adr-policy-003]`);
       continue;
     }
 
     const match = entry.name.match(NUMBERED_DIR_RE);
     if (!match) {
-      errors.push(`Invalid skill package name: ${toDisplayPath(entryPath)}`);
+      errors.push(`Invalid skill package name: ${toDisplayPath(entryPath)} [_core-adr-policy-003]`);
       continue;
     }
 
     const number = match[1];
     const previous = skillNumbers.get(number);
     if (previous) {
-      errors.push(`Duplicate skill number ${number} in ${scopeName}/${typeName}/${subjectName}/skills: ${toDisplayPath(previous)} and ${toDisplayPath(entryPath)}`);
+      errors.push(`Duplicate skill number ${number} in ${scopeName}/${typeName}/${subjectName}/skills: ${toDisplayPath(previous)} and ${toDisplayPath(entryPath)} [_core-adr-policy-003]`);
     } else {
       skillNumbers.set(number, entryPath);
     }
 
     if (entry.name !== entry.name.toLowerCase()) {
-      errors.push(`Skill package name must be lowercase: ${toDisplayPath(entryPath)}`);
+      errors.push(`Skill package name must be lowercase: ${toDisplayPath(entryPath)} [_core-adr-policy-003]`);
     }
 
     const skillFilePath = path.join(entryPath, 'SKILL.md');
@@ -768,11 +801,11 @@ function lintSkillsDirectory(xdrsRoot, scopeName, typeName, subjectName, skillsP
         continue;
       }
 
-      errors.push(`Unexpected directory in skill package: ${toDisplayPath(packageEntryPath)}`);
+      errors.push(`Unexpected directory in skill package: ${toDisplayPath(packageEntryPath)} [_core-adr-policy-003]`);
     }
 
     if (!existsFile(skillFilePath)) {
-      errors.push(`Missing SKILL.md in skill package: ${toDisplayPath(entryPath)}`);
+      errors.push(`Missing SKILL.md in skill package: ${toDisplayPath(entryPath)} [_core-adr-policy-003]`);
       continue;
     }
 
@@ -782,27 +815,27 @@ function lintSkillsDirectory(xdrsRoot, scopeName, typeName, subjectName, skillsP
     lintRequiredSections(skillContent, skillFilePath, SKILL_REQUIRED_SECTIONS, 'Skill', errors);
     const skillFm = extractFrontmatter(skillContent);
     if (!skillFm.present) {
-      errors.push(`SKILL.md must start with a YAML frontmatter block: ${toDisplayPath(skillFilePath)}`);
+      errors.push(`SKILL.md must start with a YAML frontmatter block: ${toDisplayPath(skillFilePath)} [_core-adr-policy-003]`);
     } else {
       if (!skillFm.name) {
-        errors.push(`SKILL.md frontmatter must include a non-empty name field: ${toDisplayPath(skillFilePath)}`);
+        errors.push(`SKILL.md frontmatter must include a non-empty name field: ${toDisplayPath(skillFilePath)} [_core-adr-policy-003]`);
       } else {
         const expectedSkillName = `${number}-${match[2]}`;
         if (skillFm.name !== expectedSkillName) {
-          errors.push(`Skill frontmatter name must be "${expectedSkillName}": ${toDisplayPath(skillFilePath)}`);
+          errors.push(`Skill frontmatter name must be "${expectedSkillName}": ${toDisplayPath(skillFilePath)} [_core-adr-policy-003]`);
         }
         if (skillFm.name.length > 64) {
-          errors.push(`SKILL.md frontmatter name must be 64 characters or fewer: ${toDisplayPath(skillFilePath)}`);
+          errors.push(`SKILL.md frontmatter name must be 64 characters or fewer: ${toDisplayPath(skillFilePath)} [_core-adr-policy-003]`);
         }
       }
       if (!skillFm.description) {
-        errors.push(`SKILL.md frontmatter must include a non-empty description field: ${toDisplayPath(skillFilePath)}`);
+        errors.push(`SKILL.md frontmatter must include a non-empty description field: ${toDisplayPath(skillFilePath)} [_core-adr-policy-003]`);
       } else if (skillFm.descriptionText && skillFm.descriptionText.length > 1024) {
-        errors.push(`SKILL.md frontmatter description must be 1024 characters or fewer: ${toDisplayPath(skillFilePath)}`);
+        errors.push(`SKILL.md frontmatter description must be 1024 characters or fewer: ${toDisplayPath(skillFilePath)} [_core-adr-policy-003]`);
       }
       for (const key of skillFm.topLevelKeys) {
         if (!SKILL_ALLOWED_FRONTMATTER_KEYS.has(key)) {
-          errors.push(`SKILL.md frontmatter has unknown field "${key}": ${toDisplayPath(skillFilePath)}`);
+          errors.push(`SKILL.md frontmatter has unknown field "${key}": ${toDisplayPath(skillFilePath)} [_core-adr-policy-003]`);
         }
       }
     }
@@ -828,13 +861,13 @@ function lintArticlesDirectory(xdrsRoot, scopeName, typeName, subjectName, artic
     }
 
     if (!entry.isFile()) {
-      errors.push(`Unexpected directory in articles folder: ${toDisplayPath(entryPath)}`);
+      errors.push(`Unexpected directory in articles folder: ${toDisplayPath(entryPath)} [_core-adr-policy-004]`);
       continue;
     }
 
     const match = entry.name.match(NUMBERED_FILE_RE);
     if (!match) {
-      errors.push(`Invalid article file name: ${toDisplayPath(entryPath)}`);
+      errors.push(`Invalid article file name: ${toDisplayPath(entryPath)} [_core-adr-policy-004]`);
       continue;
     }
 
@@ -843,13 +876,13 @@ function lintArticlesDirectory(xdrsRoot, scopeName, typeName, subjectName, artic
     const number = match[1];
     const previous = articleNumbers.get(number);
     if (previous) {
-      errors.push(`Duplicate article number ${number} in ${scopeName}/${typeName}/${subjectName}/articles: ${toDisplayPath(previous)} and ${toDisplayPath(entryPath)}`);
+      errors.push(`Duplicate article number ${number} in ${scopeName}/${typeName}/${subjectName}/articles: ${toDisplayPath(previous)} and ${toDisplayPath(entryPath)} [_core-adr-policy-004]`);
     } else {
       articleNumbers.set(number, entryPath);
     }
 
     if (entry.name !== entry.name.toLowerCase()) {
-      errors.push(`Article file name must be lowercase: ${toDisplayPath(entryPath)}`);
+      errors.push(`Article file name must be lowercase: ${toDisplayPath(entryPath)} [_core-adr-policy-004]`);
     }
 
     const content = fs.readFileSync(entryPath, 'utf8');
@@ -857,7 +890,7 @@ function lintArticlesDirectory(xdrsRoot, scopeName, typeName, subjectName, artic
     const expectedHeader = `# ${scopeName}-${typeId}-article-${number}:`;
     const firstLine = firstNonEmptyLine(content);
     if (!firstLine.startsWith(expectedHeader)) {
-      errors.push(`Article title must start with "${expectedHeader}": ${toDisplayPath(entryPath)}`);
+      errors.push(`Article title must start with "${expectedHeader}": ${toDisplayPath(entryPath)} [_core-adr-policy-004]`);
     }
 
     lintRequiredSections(content, entryPath, ARTICLE_REQUIRED_SECTIONS, 'Article', errors);
@@ -883,13 +916,13 @@ function lintResearchDirectory(xdrsRoot, scopeName, typeName, subjectName, resea
     }
 
     if (!entry.isFile()) {
-      errors.push(`Unexpected directory in researches folder: ${toDisplayPath(entryPath)}`);
+      errors.push(`Unexpected directory in researches folder: ${toDisplayPath(entryPath)} [_core-adr-policy-006]`);
       continue;
     }
 
     const match = entry.name.match(NUMBERED_FILE_RE);
     if (!match) {
-      errors.push(`Invalid research file name: ${toDisplayPath(entryPath)}`);
+      errors.push(`Invalid research file name: ${toDisplayPath(entryPath)} [_core-adr-policy-006]`);
       continue;
     }
 
@@ -898,13 +931,13 @@ function lintResearchDirectory(xdrsRoot, scopeName, typeName, subjectName, resea
     const number = match[1];
     const previous = researchNumbers.get(number);
     if (previous) {
-      errors.push(`Duplicate research number ${number} in ${scopeName}/${typeName}/${subjectName}/researches: ${toDisplayPath(previous)} and ${toDisplayPath(entryPath)}`);
+      errors.push(`Duplicate research number ${number} in ${scopeName}/${typeName}/${subjectName}/researches: ${toDisplayPath(previous)} and ${toDisplayPath(entryPath)} [_core-adr-policy-006]`);
     } else {
       researchNumbers.set(number, entryPath);
     }
 
     if (entry.name !== entry.name.toLowerCase()) {
-      errors.push(`Research file name must be lowercase: ${toDisplayPath(entryPath)}`);
+      errors.push(`Research file name must be lowercase: ${toDisplayPath(entryPath)} [_core-adr-policy-006]`);
     }
 
     const content = fs.readFileSync(entryPath, 'utf8');
@@ -912,11 +945,12 @@ function lintResearchDirectory(xdrsRoot, scopeName, typeName, subjectName, resea
     const expectedHeader = `# ${scopeName}-${typeId}-research-${number}:`;
     const firstLine = firstNonEmptyLine(content);
     if (!firstLine.startsWith(expectedHeader)) {
-      errors.push(`Research title must start with "${expectedHeader}": ${toDisplayPath(entryPath)}`);
+      errors.push(`Research title must start with "${expectedHeader}": ${toDisplayPath(entryPath)} [_core-adr-policy-006]`);
     }
 
     lintRequiredSections(content, entryPath, RESEARCH_REQUIRED_SECTIONS, 'Research', errors);
     lintResearchIntroductionQuestion(content, entryPath, errors);
+    lintResearchSectionWordLimits(content, entryPath, errors);
     lintNoEmojis(content, entryPath, 'Research', errors);
     lintWordCount(content, entryPath, 'Research', RESEARCH_MAX_WORDS, errors);
     lintDocumentLinks(entryPath, xdrsRoot, scopeName, errors, externalScopes);
@@ -939,13 +973,13 @@ function lintPlansDirectory(xdrsRoot, scopeName, typeName, subjectName, plansPat
     }
 
     if (!entry.isFile()) {
-      errors.push(`Unexpected directory in plans folder: ${toDisplayPath(entryPath)}`);
+      errors.push(`Unexpected directory in plans folder: ${toDisplayPath(entryPath)} [_core-adr-policy-007]`);
       continue;
     }
 
     const match = entry.name.match(NUMBERED_FILE_RE);
     if (!match) {
-      errors.push(`Invalid plan file name: ${toDisplayPath(entryPath)}`);
+      errors.push(`Invalid plan file name: ${toDisplayPath(entryPath)} [_core-adr-policy-007]`);
       continue;
     }
 
@@ -954,13 +988,13 @@ function lintPlansDirectory(xdrsRoot, scopeName, typeName, subjectName, plansPat
     const number = match[1];
     const previous = planNumbers.get(number);
     if (previous) {
-      errors.push(`Duplicate plan number ${number} in ${scopeName}/${typeName}/${subjectName}/plans: ${toDisplayPath(previous)} and ${toDisplayPath(entryPath)}`);
+      errors.push(`Duplicate plan number ${number} in ${scopeName}/${typeName}/${subjectName}/plans: ${toDisplayPath(previous)} and ${toDisplayPath(entryPath)} [_core-adr-policy-007]`);
     } else {
       planNumbers.set(number, entryPath);
     }
 
     if (entry.name !== entry.name.toLowerCase()) {
-      errors.push(`Plan file name must be lowercase: ${toDisplayPath(entryPath)}`);
+      errors.push(`Plan file name must be lowercase: ${toDisplayPath(entryPath)} [_core-adr-policy-007]`);
     }
 
     const content = fs.readFileSync(entryPath, 'utf8');
@@ -968,7 +1002,7 @@ function lintPlansDirectory(xdrsRoot, scopeName, typeName, subjectName, plansPat
     const expectedHeader = `# ${scopeName}-${typeId}-plan-${number}:`;
     const firstLine = firstNonEmptyLine(content);
     if (!firstLine.startsWith(expectedHeader)) {
-      errors.push(`Plan title must start with "${expectedHeader}": ${toDisplayPath(entryPath)}`);
+      errors.push(`Plan title must start with "${expectedHeader}": ${toDisplayPath(entryPath)} [_core-adr-policy-007]`);
     }
 
     lintRequiredSections(content, entryPath, PLAN_REQUIRED_SECTIONS, 'Plan', errors);
@@ -988,7 +1022,7 @@ function lintNoEmojis(content, filePath, docType, errors) {
   for (let i = 0; i < lines.length; i++) {
     if (ignoredLines[i]) continue;
     if (EMOJI_RE.test(lines[i])) {
-      errors.push(`${docType} must not contain emojis: ${toDisplayPath(filePath)}:${i + 1}`);
+      errors.push(`${docType} must not contain emojis: ${toDisplayPath(filePath)}:${i + 1} ${DOC_TYPE_POLICY_REF[docType] || ''}`);
     }
   }
 }
@@ -997,7 +1031,7 @@ function lintWordCount(content, filePath, docType, maxWords, errors) {
   const body = stripFrontmatter(content);
   const wordCount = countWords(body);
   if (wordCount > maxWords) {
-    errors.push(`${docType} exceeds maximum word count of ${maxWords} (${wordCount} words): ${toDisplayPath(filePath)}`);
+    errors.push(`${docType} exceeds maximum word count of ${maxWords} (${wordCount} words): ${toDisplayPath(filePath)} ${DOC_TYPE_POLICY_REF[docType] || ''}`);
   }
 }
 
@@ -1024,7 +1058,7 @@ function lintResearchIntroductionQuestion(content, filePath, errors) {
   }
 
   if (!hasQuestion) {
-    errors.push(`Research ## Introduction must contain a "Question:" line: ${toDisplayPath(filePath)}`);
+    errors.push(`Research ## Introduction must contain a "Question:" line: ${toDisplayPath(filePath)} [_core-adr-policy-006]`);
   }
 }
 
@@ -1039,7 +1073,7 @@ function lintRequiredSections(content, filePath, requiredSections, docType, erro
   const ignoredLines = findIgnoredMarkdownLines(lines);
   for (const section of requiredSections) {
     if (findHeadingLine(lines, ignoredLines, section) === -1) {
-      errors.push(`${docType} is missing required section "${section}": ${toDisplayPath(filePath)}`);
+      errors.push(`${docType} is missing required section "${section}": ${toDisplayPath(filePath)} ${DOC_TYPE_POLICY_REF[docType] || ''}`);
     }
   }
 }
@@ -1050,17 +1084,17 @@ function lintPlanExpectedEndDate(content, filePath, errors) {
   const expectedEndDateLines = findFieldLines(lines, ignoredLines, 'Expected end date:');
 
   if (expectedEndDateLines.length === 0) {
-    errors.push(`Plan must include an Expected end date: field: ${toDisplayPath(filePath)}`);
+    errors.push(`Plan must include an Expected end date: field: ${toDisplayPath(filePath)} [_core-adr-policy-007]`);
     return;
   }
 
   if (expectedEndDateLines.length > 1) {
-    errors.push(`Plan must not repeat Expected end date: ${toDisplayPath(filePath)}`);
+    errors.push(`Plan must not repeat Expected end date: ${toDisplayPath(filePath)} [_core-adr-policy-007]`);
   }
 
   const value = lines[expectedEndDateLines[0]].slice('Expected end date:'.length).trim().replace(/\.$/, '');
   if (!isIsoDate(value)) {
-    errors.push(`Plan Expected end date: must be a valid ISO date in YYYY-MM-DD format: ${toDisplayPath(filePath)}`);
+    errors.push(`Plan Expected end date: must be a valid ISO date in YYYY-MM-DD format: ${toDisplayPath(filePath)} [_core-adr-policy-007]`);
   }
 }
 
@@ -1075,12 +1109,12 @@ function lintTypeIndex(indexPath, xdrsRoot, artifacts, errors, externalScopes =
   for (const linkPath of localLinks) {
     if (!fs.existsSync(linkPath)) {
       if (isExternalScopeLink(linkPath, xdrsRoot, externalScopes)) continue;
-      errors.push(`Broken link in canonical index ${toDisplayPath(indexPath)}: ${displayPath(indexPath, linkPath)}`);
+      errors.push(`Broken link in canonical index ${toDisplayPath(indexPath)}: ${displayPath(indexPath, linkPath)} [_core-adr-policy-001]`);
       continue;
     }
 
     if (scopeName !== '_local' && (isPathInside(localScopePath, linkPath) || normalizePath(linkPath) === localScopePath)) {
-      errors.push(`Non-_local document must not link into _local scope: ${displayPath(indexPath, linkPath)}`);
+      errors.push(`Non-_local document must not link into _local scope: ${displayPath(indexPath, linkPath)} [_core-adr-policy-001]`);
     }
 
     linkedSet.add(normalizePath(linkPath));
@@ -1088,7 +1122,7 @@ function lintTypeIndex(indexPath, xdrsRoot, artifacts, errors, externalScopes =
 
   for (const artifactPath of artifacts) {
     if (!linkedSet.has(normalizePath(artifactPath))) {
-      errors.push(`Canonical index ${toDisplayPath(indexPath)} is missing an entry for ${toDisplayPath(artifactPath)}`);
+      errors.push(`Canonical index ${toDisplayPath(indexPath)} is missing an entry for ${toDisplayPath(artifactPath)} [_core-adr-policy-001]`);
     }
   }
 }
@@ -1120,7 +1154,7 @@ function lintOrphanAssets(assetsDir, documentPaths, xdrsRoot, errors) {
 
   for (const assetPath of assetTree.files) {
     if (!referencedAssets.has(assetPath)) {
-      errors.push(`Orphan asset file not referenced by any document: ${toDisplayPath(assetPath)}`);
+      errors.push(`Orphan asset file not referenced by any document: ${toDisplayPath(assetPath)} [_core-adr-policy-001]`);
     }
   }
 
@@ -1137,23 +1171,23 @@ function lintSlideFile(filePath, documentPaths, xdrsRoot, errors) {
   const fileName = path.basename(filePath);
 
   if (fileName !== fileName.toLowerCase()) {
-    errors.push(`Slide file name must be lowercase: ${toDisplayPath(filePath)}`);
+    errors.push(`Slide file name must be lowercase: ${toDisplayPath(filePath)} [_core-adr-policy-009]`);
   }
 
   if (fileName.length > SLIDE_MAX_NAME_LENGTH) {
-    errors.push(`Slide file name must be ${SLIDE_MAX_NAME_LENGTH} characters or fewer: ${toDisplayPath(filePath)}`);
+    errors.push(`Slide file name must be ${SLIDE_MAX_NAME_LENGTH} characters or fewer: ${toDisplayPath(filePath)} [_core-adr-policy-009]`);
   }
 
   const content = fs.readFileSync(filePath, 'utf8');
 
   const fm = extractFrontmatter(content);
   if (!fm.present) {
-    errors.push(`Slide file must start with a YAML frontmatter block containing marp: true: ${toDisplayPath(filePath)}`);
+    errors.push(`Slide file must start with a YAML frontmatter block containing marp: true: ${toDisplayPath(filePath)} [_core-adr-policy-009]`);
   } else {
     const frontmatterBody = content.match(/^---\r?\n([\s\S]*?)\r?\n---/)[1];
     const firstKey = frontmatterBody.trimStart().split(/\r?\n/)[0];
     if (!/^marp:\s*true$/.test(firstKey)) {
-      errors.push(`Slide frontmatter must include marp: true as the first key: ${toDisplayPath(filePath)}`);
+      errors.push(`Slide frontmatter must include marp: true as the first key: ${toDisplayPath(filePath)} [_core-adr-policy-009]`);
     }
   }
 
@@ -1167,7 +1201,18 @@ function lintSlideFile(filePath, documentPaths, xdrsRoot, errors) {
 
   const linksToParent = documentPaths.some((docPath) => slideLinkSet.has(normalizePath(docPath)));
   if (!linksToParent) {
-    errors.push(`Slide file must contain a link back to its parent document: ${toDisplayPath(filePath)}`);
+    errors.push(`Slide file must contain a link back to its parent document: ${toDisplayPath(filePath)} [_core-adr-policy-009]`);
+  }
+
+  // Check that at least one parent document links to this slide file
+  const parentLinksToSlide = documentPaths.some((docPath) => {
+    if (!existsFile(docPath)) return false;
+    const docContent = fs.readFileSync(docPath, 'utf8');
+    const docLinks = parseLocalLinks(docContent, path.dirname(docPath), repoRoot);
+    return docLinks.some((l) => normalizePath(l) === normalizePath(filePath));
+  });
+  if (!parentLinksToSlide) {
+    errors.push(`Parent document must contain a link to its slide file: ${toDisplayPath(filePath)} [_core-adr-policy-009]`);
   }
 }
 
@@ -1212,25 +1257,25 @@ function lintDocumentLinks(documentPath, xdrsRoot, scopeName, errors, externalSc
       const isResourceLink = shouldValidateResourceLink(link.rawTarget);
 
       if (!isResourceLink && link.isAbsolutePath) {
-        errors.push(`Absolute path links are not allowed; use relative paths in ${toDisplayPath(documentPath)}:${index + 1}: ${link.rawTarget}`);
+        errors.push(`Absolute path links are not allowed; use relative paths in ${toDisplayPath(documentPath)}:${index + 1}: ${link.rawTarget} [_core-adr-policy-001]`);
       }
 
       if (!fs.existsSync(link.resolvedPath)) {
         if (isExternalScopeLink(link.resolvedPath, xdrsRoot, externalScopes)) continue;
         if (isResourceLink) {
-          errors.push(`Broken asset link in ${toDisplayPath(documentPath)}: ${link.rawTarget}`);
+          errors.push(`Broken asset link in ${toDisplayPath(documentPath)}: ${link.rawTarget} [_core-adr-policy-001]`);
         } else {
-          errors.push(`Broken local link in ${toDisplayPath(documentPath)}:${index + 1}: ${link.rawTarget}`);
+          errors.push(`Broken local link in ${toDisplayPath(documentPath)}:${index + 1}: ${link.rawTarget} [_core-adr-policy-001]`);
         }
         continue;
       }
 
       if (scopeName !== '_local' && (isPathInside(localScopePath, link.resolvedPath) || normalizePath(link.resolvedPath) === localScopePath)) {
-        errors.push(`Non-_local document must not link into _local scope in ${toDisplayPath(documentPath)}:${index + 1}: ${link.rawTarget}`);
+        errors.push(`Non-_local document must not link into _local scope in ${toDisplayPath(documentPath)}:${index + 1}: ${link.rawTarget} [_core-adr-policy-001]`);
       }
 
       if (isResourceLink && !isPathInside(resourceDir, link.resolvedPath)) {
-        errors.push(`Asset links in ${toDisplayPath(documentPath)} must point to ${toDisplayPath(resourceDir)}: ${link.rawTarget}`);
+        errors.push(`Asset links in ${toDisplayPath(documentPath)} must point to ${toDisplayPath(resourceDir)}: ${link.rawTarget} [_core-adr-policy-001]`);
       }
     }
   }
@@ -1553,6 +1598,98 @@ function isPathInside(parentPath, childPath) {
   return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
 }
 
+function lintStructuredRuleBlocks(content, filePath, errors) {
+  const body = stripFrontmatter(content);
+  const lines = body.split(/\r?\n/);
+  const ignoredLines = findIgnoredMarkdownLines(lines);
+
+  const ruleNumbers = new Map(); // number -> line index
+  const ruleEntries = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    if (ignoredLines[i]) continue;
+    const m = lines[i].match(/^#### (\d+)-(.*)$/);
+    if (!m) continue;
+    const number = m[1];
+    const title = m[2].trim();
+    ruleEntries.push({ lineIndex: i, number, title });
+  }
+
+  for (let r = 0; r < ruleEntries.length; r++) {
+    const { lineIndex, number, title } = ruleEntries[r];
+
+    if (!/^\d{2}$/.test(number)) {
+      errors.push(`Policy structured rule number must be exactly two digits ("${number}" in "${lines[lineIndex].trim()}"): ${toDisplayPath(filePath)} [_core-adr-policy-008.02-rule-numbering-must-be-stable]`);
+    }
+
+    if (title.length === 0 || !/^[a-z][a-z0-9-]*$/.test(title)) {
+      errors.push(`Policy structured rule title must be in kebab-case ("${title}"): ${toDisplayPath(filePath)} [_core-adr-policy-008.01-always-use-numbered-rules-for-strong-or-referenceable-policies]`);
+    }
+
+    const wordCount = title.split('-').filter(Boolean).length;
+    if (wordCount > 12) {
+      errors.push(`Policy structured rule title must be 12 words or fewer ("${title}"): ${toDisplayPath(filePath)} [_core-adr-policy-008.01-always-use-numbered-rules-for-strong-or-referenceable-policies]`);
+    }
+
+    if (ruleNumbers.has(number)) {
+      errors.push(`Duplicate structured rule number "${number}" in Policy: ${toDisplayPath(filePath)} [_core-adr-policy-008.02-rule-numbering-must-be-stable]`);
+    } else {
+      ruleNumbers.set(number, lineIndex);
+    }
+
+    const bodyStart = lineIndex + 1;
+    let bodyEnd = lines.length;
+    for (let i = bodyStart; i < lines.length; i++) {
+      if (!ignoredLines[i] && /^#{1,4}/.test(lines[i])) {
+        bodyEnd = i;
+        break;
+      }
+    }
+    const ruleBodyText = lines.slice(bodyStart, bodyEnd).join('\n');
+
+    if (!NORMATIVE_KEYWORDS_RE.test(ruleBodyText)) {
+      errors.push(`Policy structured rule body must contain normative language (MUST/SHOULD/MAY) in "${number}-${title}": ${toDisplayPath(filePath)} [_core-adr-policy-008.03-rule-body-must-use-normative-language]`);
+    }
+  }
+}
+
+function lintResearchSectionWordLimits(content, filePath, errors) {
+  const lines = content.split(/\r?\n/);
+  const ignoredLines = findIgnoredMarkdownLines(lines);
+
+  const sectionStarts = {};
+  for (let i = 0; i < lines.length; i++) {
+    if (ignoredLines[i]) continue;
+    const trimmed = lines[i].trim();
+    for (const sectionName of Object.keys(RESEARCH_SECTION_LIMITS)) {
+      if (trimmed === sectionName) {
+        sectionStarts[sectionName] = i;
+      }
+    }
+  }
+
+  for (const sectionName of Object.keys(RESEARCH_SECTION_LIMITS)) {
+    const startLine = sectionStarts[sectionName];
+    if (startLine === undefined) continue;
+
+    let endLine = lines.length;
+    for (let i = startLine + 1; i < lines.length; i++) {
+      if (!ignoredLines[i] && /^## /.test(lines[i].trim())) {
+        endLine = i;
+        break;
+      }
+    }
+
+    const sectionText = lines.slice(startLine + 1, endLine).join(' ');
+    const wordCount = countWords(sectionText);
+    const limit = RESEARCH_SECTION_LIMITS[sectionName];
+
+    if (wordCount > limit) {
+      errors.push(`Research ${sectionName} section exceeds ${limit} words (${wordCount} words): ${toDisplayPath(filePath)} [_core-adr-policy-006]`);
+    }
+  }
+}
+
 module.exports = {
   runLintCli,
   lintWorkspace