xdrs-core 0.52.2 → 0.52.3

package/.xdrs/_core/adrs/principles/001-xdrs-standards.md

@@ -50,7 +50,7 @@ ADR and EDR share the same six technical subject names (see [`_core-adr-policy-0
   `[xdrs-root]/[scope]/[type]/[subject]/[number]-[short-title].md`
   where `[xdrs-root]` is the XDRS root folder (default: `.xdrs/`).
 - MUST ignore symlinks paths. MUST NOT create or update documents inside symlinked folders.
-- **Files listed in `.filedist.lock` are external XDRs.** A file whose path appears in the workspace root `.filedist.lock` file was distributed from an external source repository. It MUST NOT be modified locally. To change it, submit the change to the source repository and re-extract the updated package. The `.filedist.lock` format is one entry per line: `<relative-path>|<package>|<version>`. A scope is considered external when any of its files appear in `.filedist.lock`, and tools (such as `xdrs-core lint`) will skip external scopes by default. The `.filedist.lock` file can also be used to detect which files changed when bumping an external scope to a newer version: compare the version field in `.filedist.lock` entries before and after the upgrade and diff the affected paths to understand what decisions were added, updated, or removed.
+- **Files listed in `.filedist.lock` are external XDRs.** A file whose path appears in the workspace root `.filedist.lock` file was distributed from an external source repository. It MUST NOT be modified locally. To change it, submit the change to the source repository and re-extract the updated package. The `.filedist.lock` format is one entry per line: `<relative-path>|<package>|<version>`. A scope is considered external when any of its files appear in `.filedist.lock`. The `.filedist.lock` file can also be used to detect which files changed when bumping an external scope to a newer version: compare the version field in `.filedist.lock` entries before and after the upgrade and diff the affected paths to understand what decisions were added, updated, or removed.
 - Optional supporting artifacts under the same subject:
   - `[xdrs-root]/[scope]/[type]/[subject]/researches/[number]-[short-title].md`
   - `[xdrs-root]/[scope]/[type]/[subject]/skills/[skill-name]/SKILL.md`
@@ -91,8 +91,8 @@ ADR and EDR share the same six technical subject names (see [`_core-adr-policy-0
     - `apply-to` (required): Declares in which contexts — teams, systems, codebases, or environments — the decisions in this scope are relevant. Max 30 words.
     - `valid-from` (required): ISO date (YYYY-MM-DD) from which this scope became active.
     - `metadata` (optional): Arbitrary key-value map for additional scope metadata.
-    - `follows` (optional): Core scope names whose Policies apply as mandatory governance conventions to this scope, beyond `_core`. Last-listed takes precedence on conflicts (e.g., `follows: myarea-core, shared-standards`). All referenced scopes MUST exist in the workspace; if any is absent, READ/WRITE/REVIEW operations MUST fail.
-    - `extends` (optional): Scope names whose **policy documents** (decision records only — not skills, articles, research, or initiatives) are inherited by this scope as if they were authored here. Any scope type except `_local` and `_core` may be referenced. Last-listed extended scope takes precedence on conflicts; the extending scope's own policies always take highest precedence. Depth-first transitive resolution applies: if A extends [B, C] and B extends [D], the effective precedence order is D < B < C < A. `extends:` and `follows:` MUST reference disjoint scope sets. All referenced scopes MUST exist in the workspace; if any is absent, READ/WRITE/REVIEW operations MUST fail. When an extending scope's policy overrides an inherited policy on the same topic, a `## Conflicts` section MUST document the override. Extended scopes are still linked in the root index; tag them `extends-only` to apply them only via `extends:` (see `_core-adr-policy-022.01-root-index-completeness`). `extends:` takes precedence over root index ordering for conflict resolution between the scopes involved; root index ordering is the fallback for all other scope pairs. See `_core-adr-policy-010` Section D (rules 27–35) and Section E (rule 36) for full normative rules.
+    - `follows` (optional): Core scope names whose Policies apply as mandatory governance conventions to this scope, beyond `_core`. Last-listed takes precedence on conflicts (e.g., `follows: myarea-core, shared-standards`). A missing scope MUST be fixed in local scopes and makes external scopes READ-ONLY (see `_core-adr-policy-022.06-read-only-dependencies`).
+    - `extends` (optional): Scope names whose **policy documents** (decision records only — not skills, articles, research, or initiatives) are inherited by this scope as if they were authored here. Any scope type except `_local` and `_core` may be referenced. Last-listed extended scope takes precedence on conflicts; the extending scope's own policies always take highest precedence. Depth-first transitive resolution applies: if A extends [B, C] and B extends [D], the effective precedence order is D < B < C < A. `extends:` and `follows:` MUST reference disjoint scope sets. A missing scope MUST be fixed in local scopes and makes external scopes READ-ONLY (see `_core-adr-policy-022.06-read-only-dependencies`). When an extending scope's policy overrides an inherited policy on the same topic, a `## Conflicts` section MUST document the override. Extended scopes are still linked in the root index; tag them `extends-only` to apply them only via `extends:` (see `_core-adr-policy-022.01-root-index-completeness`). `extends:` takes precedence over root index ordering for conflict resolution between the scopes involved; root index ordering is the fallback for all other scope pairs. See `_core-adr-policy-010` Section D (rules 27–35) and Section E (rule 36) for full normative rules.
     - `extends-only` (optional): See `_core-adr-policy-022.07-extends-only-field`.
     - `license` (optional): SPDX identifier for the scope's content license.
 - **Subjects:** The subject folder MUST be chosen per [`_core-adr-policy-016`](016-policy-subjects.md), which defines allowed subjects, full descriptions, examples, and disambiguation tiebreakers.

package/.xdrs/_core/adrs/principles/010-scope-governance.md

@@ -81,9 +81,9 @@ A scope-type definition policy MAY declare a parent scope type by including a ru
 
 #### 10-def-valid-iff-policy-exists
 
-A `scope-type` value in a scope `index.md` is valid if and only if a policy file whose name ends with `{scope-type}-scope-type` exists in the `principles` subject of any `core`-type scope in the workspace. Tools (such as `xdrs-core lint`) MUST enforce this for every element when `scope-type` is an array.
+A `scope-type` value in a scope `index.md` is valid if and only if a policy file whose name ends with `{scope-type}-scope-type` exists in the `principles` subject of any `core`-type scope in the workspace. When `scope-type` is an array, this applies to every element.
 
-When a scope declares a `scope-type` but any corresponding `{scope-type}-scope-type.md` policy is absent from the workspace or defined only in a `disabled` scope, the scope MUST be treated as READ-ONLY (see `_core-adr-policy-022.06-read-only-dependencies`). Missing types are a lint error for local scopes.
+When a scope declares a `scope-type` but any corresponding `{scope-type}-scope-type.md` policy is absent from the workspace or defined only in a `disabled` scope, the scope MUST be treated as READ-ONLY (see `_core-adr-policy-022.06-read-only-dependencies`). Missing or disabled-only types MUST be fixed in local scopes.
 
 #### 11-def-scope-type-must-be-structured
 
@@ -103,7 +103,7 @@ The word `core` as a hyphen-delimited segment in a policy filename title is rese
 
 #### 14-local-placement
 
-Local meta-policy files MUST be placed in the `principles` subject of any type folder within the scope they govern (e.g., `my-team/adrs/principles/001-core.md`). They apply implicitly to that scope — no declaration in `index.md` is required. Local meta-policies MUST NOT be placed in any other subject folder; a file whose title starts with `core` in a non-`principles` subject is a lint error.
+Local meta-policy files MUST be placed in the `principles` subject of any type folder within the scope they govern (e.g., `my-team/adrs/principles/001-core.md`). They apply implicitly to that scope — no declaration in `index.md` is required. Local meta-policies MUST NOT be placed in any other subject folder; a file whose title starts with `core` in a non-`principles` subject is invalid.
 
 #### 15-local-primary-required
 
@@ -180,7 +180,7 @@ When a policy (scope-type definition, local meta-policy, or companion) overrides
 - The policy file where the original rule is defined.
 - A short explanation of why the override is required for this scope or type.
 
-A `## Conflicts` section MAY also document cross-scope-type incompatibilities for informational purposes. Tools and agents MUST detect undeclared conflicts at review time and surface them as errors. Semantic conflict detection is the responsibility of the authoring agent, not the lint tool.
+A `## Conflicts` section MAY also document cross-scope-type incompatibilities for informational purposes. Tools and agents MUST detect undeclared conflicts at review time and surface them as errors. Semantic conflict detection is the responsibility of the authoring agent.
 
 ## References
 
@@ -213,7 +213,7 @@ A scope `extends:` declaration MUST NOT reference the declaring scope itself. To
 
 #### 32-extends-mandatory-presence
 
-Every scope listed in a scope's `extends:` field MUST exist in the workspace with an accessible `index.md`. If any referenced scope is absent or its `index.md` cannot be read, all READ, WRITE, and REVIEW operations on the extending scope MUST fail immediately. Tools MUST surface a clear message naming the missing scope and citing code `_core-adr-policy-010.32-extends-mandatory-presence`.
+Every scope listed in a scope's `extends:` field MUST exist in the workspace with an accessible `index.md`. If any referenced scope is absent or its `index.md` cannot be read, the extending scope MUST be fixed when local and is READ-ONLY when external (`_core-adr-policy-022.06-read-only-dependencies`).
 
 #### 33-extends-content-precedence
 

package/.xdrs/_core/adrs/principles/011-core-scope-type.md

@@ -73,7 +73,7 @@ Distributing `-core` scopes alongside their companion consumable scope to downst
 
 #### 10-no-type-combination
 
-A scope is core-type when its resolved scope-type chain, including parent types (see `_core-adr-policy-010.09-def-parent-scope-type`), contains `core`. A core-type scope MUST declare exactly one scope type; combining a core-type with any other type (e.g., `scope-type: core, standard`) is a lint error. Core-type scopes hold meta governance only, so mixing them with consumable types would blur rules 04 and 05.
+A scope is core-type when its resolved scope-type chain, including parent types (see `_core-adr-policy-010.09-def-parent-scope-type`), contains `core`. A core-type scope MUST declare exactly one scope type; combining a core-type with any other type (e.g., `scope-type: core, standard`) is invalid. Core-type scopes hold meta governance only, so mixing them with consumable types would blur rules 04 and 05.
 
 ## References
 

package/.xdrs/_core/adrs/principles/022-scope-activation.md

@@ -9,21 +9,21 @@ valid-from: 2026-07-20
 
 ## Context and Problem Statement
 
-Packages install scope folders into a workspace, but nothing guaranteed that every installed scope was listed in the root `index.md`. Scopes that were meant to be reused only through `extends:` were hidden from the root index, so agents could not discover them, and consumers had no way to switch off a scope they installed but did not want to apply. When a scope depended on another scope that was absent, the result was either a hard lint error or silent misbehaviour.
+Packages install scope folders into a workspace, but nothing guaranteed that every installed scope was listed in the root `index.md`. Scopes that were meant to be reused only through `extends:` were hidden from the root index, so agents could not discover them, and consumers had no way to switch off a scope they installed but did not want to apply. When a scope depended on another scope that was absent, the result was either a hard failure or silent misbehaviour.
 
 How does a consumer control which installed scopes apply globally, which apply only through `extends:`, and which are ignored, while keeping every scope discoverable?
 
 ## Decision Outcome
 
-**Every installed scope is listed once in the root index; the consumer controls activation with an inline activation tag next to the scope link, and the scope author declares intent with an `extends-only` frontmatter field that lint checks for coherence.**
+**Every installed scope is listed once in the root index; the consumer controls activation with an inline activation tag next to the scope link, and the scope author declares intent with an `extends-only` frontmatter field that MUST be coherent with the tag.**
 
-Policies of listed scopes apply globally by default. An activation tag narrows a scope to `extends-only` or turns it off with `disabled`. Agents rely only on the tags. Scopes whose dependencies are missing, disabled, or invalid become read-only.
+Policies of listed scopes apply globally by default. An activation tag narrows a scope to `extends-only` or turns it off with `disabled`. Agents rely only on the tags. Scopes whose dependencies are missing, disabled, or invalid become read-only; local scopes MUST NOT stay in that state.
 
 ### Details
 
 #### 01-root-index-completeness
 
-Every scope folder under the XDRS root that contains an `index.md`, including scopes installed from external packages, MUST be linked exactly once from the root `index.md`. The `_local` scope MUST NOT be linked (see `_core-adr-policy-001`). A scope folder with no link, or a scope linked more than once, is a lint error. Links that resolve to the same scope index (e.g. `./x/index.md` and `x/index.md`) count as the same link. Links inside fenced code blocks are ignored.
+Every scope folder under the XDRS root that contains an `index.md`, including scopes installed from external packages, MUST be linked exactly once from the root `index.md`. The `_local` scope MUST NOT be linked (see `_core-adr-policy-001`). A scope folder with no link, or a scope linked more than once, is invalid. Links that resolve to the same scope index (e.g. `./x/index.md` and `x/index.md`) count as the same link. Links inside fenced code blocks are ignored.
 
 #### 02-global-applicability
 
@@ -31,23 +31,26 @@ Policies of a listed scope without an activation tag MUST be applied globally, n
 
 #### 03-activation-tag-syntax
 
-An activation tag is an inline code span placed immediately after a scope link on the same line, optionally separated by spaces or tabs, for example a link to `payments-ref/index.md` followed by `` `extends-only` ``. Allowed values are `extends-only` and `disabled`, lowercase only. A scope link line MUST NOT contain any other inline code: an unknown value, a second tag, or inline code placed elsewhere on the line is a lint error. A tag on the next line is not a tag. `_core` MUST NOT be tagged.
+An activation tag is an inline code span placed immediately after a scope link on the same line, optionally separated by spaces or tabs, for example a link to `payments-ref/index.md` followed by `` `extends-only` ``. Allowed values are `extends-only` and `disabled`, lowercase only. A scope link line MUST NOT contain any other inline code: an unknown value, a second tag, or inline code placed elsewhere on the line is invalid. A tag on the next line is not a tag. `_core` MUST NOT be tagged.
 
 #### 04-extends-only
 
-Policies of a scope tagged `extends-only` MUST be applied only through the `extends:` chain of an active scope (untagged, including read-only scopes, or `_local`). Reach is transitive: if A extends B and B extends C, both B and C apply to A. The root index position of a tagged scope never matters for conflict resolution; `extends:` precedence applies (see `_core-adr-policy-010.33-extends-content-precedence`). Skills, articles, research, and initiatives of the scope remain usable. Tools SHOULD warn when no active scope reaches an `extends-only` scope; reach only through a `disabled` scope does not count.
+Policies of a scope tagged `extends-only` MUST be applied only through the `extends:` chain of an active scope (untagged, including read-only scopes, or `_local`). Reach is transitive: if A extends B and B extends C, both B and C apply to A. The root index position of a tagged scope never matters for conflict resolution; `extends:` precedence applies (see `_core-adr-policy-010.33-extends-content-precedence`). Skills, articles, research, and initiatives of the scope remain usable. Every `extends-only` scope MUST be reached by at least one active scope; reach only through a `disabled` scope does not count. Fix it by adding the scope to the `extends:` of an active scope or by tagging it `disabled`.
 
 #### 05-disabled
 
-All content of a scope tagged `disabled` MUST be ignored by agents: its policies, skills, articles, research, and initiatives are not applied, and nothing is inherited from it through `extends:` or `follows:`. The scope is still linted and MAY be edited. Skills of a disabled scope that are symlinked into `.agents/skills` (see `_core-adr-policy-018`) stay loaded by tools and MUST be removed by the consumer.
+All content of a scope tagged `disabled` MUST be ignored by agents: its policies, skills, articles, research, and initiatives are not applied, and nothing is inherited from it through `extends:` or `follows:`. The scope is still validated and MAY be edited; a disabled local scope follows rule 06 like any other local scope. Skills of a disabled scope that are symlinked into `.agents/skills` (see `_core-adr-policy-018`) stay loaded by tools and MUST be removed by the consumer.
 
 #### 06-read-only-dependencies
 
-A scope MUST be treated as READ-ONLY when a scope it follows or extends, or the scope that defines one of its scope types (including parent types), is missing, disabled, or invalid, or when it is an external scope and its own `index.md` is invalid. Content in a READ-ONLY scope MUST NOT be added, changed, or removed. For local scopes, missing dependencies and invalid indexes remain lint errors (see `_core-adr-policy-010.32-extends-mandatory-presence`); a disabled dependency only makes the scope read-only. Tools MUST report each cause and how to fix it, citing this rule.
+A scope MUST be treated as READ-ONLY when a scope it follows or extends, or the scope that defines one of its scope types (including parent types), is missing, disabled, or invalid, or when it is an external scope and its own `index.md` is invalid. Content in a READ-ONLY scope MUST NOT be added, changed, or removed.
+
+- **Local scope** (not tracked in `.filedist.lock`, including `_local` and disabled scopes): a read-only local scope is frozen and cannot be maintained, so each cause is invalid and MUST be fixed.
+- **External scope** (tracked in `.filedist.lock`): the scope is READ-ONLY; agents MUST tell the user when they skip a change because of it, naming the cause and fix.
 
 #### 07-extends-only-field
 
-A scope author MAY declare `extends-only: true` or `extends-only: false` in the scope index frontmatter. Only unquoted lowercase `true` and `false` are valid. An invalid value is a lint error in a local scope; in an external scope it makes the scope read-only and the value is treated as absent. `extends-only` (field `true` or tag) on `_core`, `_local`, or a core-type scope is a lint error. Coherence: when the field is `true`, the root index link MUST carry the tag `extends-only` or `disabled`; when the field is `false` or absent, the consumer MAY add either tag (narrowing), and MUST NOT widen a scope beyond what the author declared. The field is a lint aid only.
+A scope author MAY declare `extends-only: true` or `extends-only: false` in the scope index frontmatter. Only unquoted lowercase `true` and `false` are valid. An invalid value in a local scope MUST be fixed; in an external scope it makes the scope READ-ONLY and the value is treated as absent. `extends-only` (field `true` or tag) MUST NOT be used on `_core`, `_local`, or a core-type scope. Coherence: when the field is `true`, the root index link MUST carry the tag `extends-only` or `disabled`; when the field is `false` or absent, the consumer MAY add either tag (narrowing), and MUST NOT widen a scope beyond what the author declared. Agents MUST NOT use the field for activation (rule 08).
 
 #### 08-agent-resolution
 

package/.xdrs/_core/adrs/principles/skills/.assets/lint-verification.md

@@ -9,4 +9,3 @@ This module is shared across all XDRS writing skills. Run these steps after all
    npx -y xdrs-core@latest lint
    ```
 2. Fix all reported errors before considering the task complete.
-3. Review warnings; fix straightforward ones and note intentional deviations explicitly.

package/.xdrs/_core/adrs/principles/skills/compile-scope/SKILL.md

@@ -138,7 +138,7 @@ After writing each policy:
 ### Phase 6: Lint
 
 1. Run `npx xdrs-core lint` from the workspace root (or `make lint` if a `Makefile` is present with a `lint` target).
-2. Review all reported errors and warnings.
+2. Review all reported errors.
 3. Fix only mechanical and structural errors (missing required frontmatter fields, naming violations, index link mismatches). Do NOT invent content to satisfy content-level findings.
 4. Re-run lint after fixes until it passes or only unfixable findings remain.
 

package/lib/lint.js

@@ -99,18 +99,6 @@ function runLintCli(args) {
   const targetPath = pathArgs[0] || '.';
   const result = lintWorkspace(targetPath, { ignoreExternal: !all });
 
-  if (result.warnings.length > 0) {
-    for (const warning of result.warnings) {
-      console.warn(`- [warning] ${warning}`);
-    }
-  }
-
-  for (const [scopeName, causes] of result.readOnlyScopes) {
-    for (const cause of causes) {
-      console.log(`- READ-ONLY scope "${scopeName}": ${cause}; no changes must be made to this scope [_core-adr-policy-022.06-read-only-dependencies]`);
-    }
-  }
-
   if (result.errors.length === 0) {
     console.log(`Lint passed for ${toDisplayPath(result.xdrsRoot)}`);
     return 0;
@@ -147,12 +135,10 @@ function lintWorkspace(targetPath, options = {}) {
   const resolvedTarget = path.resolve(targetPath);
   const xdrsRoot = resolveXdrsRoot(resolvedTarget);
   const errors = [];
-  const warnings = [];
-  const readOnlyScopes = new Map(); // scopeName -> [cause, ...] per _core-adr-policy-022.06
 
   if (!existsDirectory(xdrsRoot)) {
     errors.push(`Missing XDRS root directory: ${toDisplayPath(xdrsRoot)} [_core-adr-policy-001]`);
-    return { xdrsRoot, errors, warnings, readOnlyScopes };
+    return { xdrsRoot, errors };
   }
 
   const repoRoot = path.dirname(xdrsRoot);
@@ -247,13 +233,13 @@ function lintWorkspace(targetPath, options = {}) {
     }
   }
 
-  collectReadOnlyScopes(scopeMeta, activation, externalScopes, knownScopeTypes, scopeTypeDefiningScopes, readOnlyScopes);
+  lintLocalReadOnlyDependencies(xdrsRoot, scopeMeta, activation, externalScopes, knownScopeTypes, scopeTypeDefiningScopes, errors);
 
   // Populated during lintScopeIndexFrontmatter: scopeName -> [extendedScopeNames...]
   const extendsRelationships = new Map();
 
   for (const scopeEntry of scopeEntries) {
-    lintScopeDirectory(xdrsRoot, scopeEntry.name, errors, warnings, actualTypeIndexes, ignoreExternal, effectiveExternalScopes, knownScopeTypes, extendsRelationships, externalScopes);
+    lintScopeDirectory(xdrsRoot, scopeEntry.name, errors, actualTypeIndexes, ignoreExternal, effectiveExternalScopes, knownScopeTypes, extendsRelationships, externalScopes);
   }
 
   // Detect cycles in extends: chains (DFS)
@@ -283,13 +269,13 @@ function lintWorkspace(targetPath, options = {}) {
   if (!existsFile(rootIndexPath)) {
     errors.push('Missing required root index: .xdrs/index.md [_core-adr-policy-001]');
   } else {
-    lintRootIndex(rootIndexPath, xdrsRoot, errors, warnings, effectiveExternalScopes, { activation, scopeMeta, knownScopeTypes });
+    lintRootIndex(rootIndexPath, xdrsRoot, errors, effectiveExternalScopes, { activation, scopeMeta, knownScopeTypes });
   }
 
-  return { xdrsRoot, errors, warnings, readOnlyScopes };
+  return { xdrsRoot, errors };
 }
 
-function lintRootIndex(rootIndexPath, xdrsRoot, errors, warnings, externalScopes, ctx) {
+function lintRootIndex(rootIndexPath, xdrsRoot, errors, externalScopes, ctx) {
   const content = fs.readFileSync(rootIndexPath, 'utf8');
   const repoRoot = path.dirname(xdrsRoot);
 
@@ -360,7 +346,7 @@ function lintRootIndex(rootIndexPath, xdrsRoot, errors, warnings, externalScopes
   }
   for (const [scopeName, entry] of activation) {
     if (entry.tag === 'extends-only' && !reached.has(scopeName)) {
-      warnings.push(`Scope "${scopeName}" is tagged \`extends-only\` but no active scope extends it, so its policies never apply: ${display} [_core-adr-policy-022.04-extends-only]`);
+      errors.push(`Scope "${scopeName}" is tagged \`extends-only\` but no active scope extends it, so its policies never apply; add it to the extends: of an active scope or tag it \`disabled\`: ${display} [_core-adr-policy-022.04-extends-only]`);
     }
   }
 }
@@ -443,30 +429,19 @@ function readScopeMeta(scopeIndexPath) {
   };
 }
 
-// Computes read-only scopes and their causes per _core-adr-policy-022.06. Missing dependencies of
-// local scopes are reported as lint errors elsewhere; here they only make external scopes read-only.
-function collectReadOnlyScopes(scopeMeta, activation, externalScopes, knownScopeTypes, scopeTypeDefiningScopes, readOnlyScopes) {
+// Reports local scopes that would be READ-ONLY per _core-adr-policy-022.06 because of a disabled or
+// invalid dependency. Missing dependencies are reported by lintScopeIndexFrontmatter; external scopes are never reported.
+function lintLocalReadOnlyDependencies(xdrsRoot, scopeMeta, activation, externalScopes, knownScopeTypes, scopeTypeDefiningScopes, errors) {
   const isDisabled = (scopeName) => (activation.get(scopeName) || {}).tag === 'disabled';
   for (const [scopeName, meta] of scopeMeta) {
-    if (!meta) continue;
-    const isExternal = externalScopes.has(scopeName);
+    if (!meta || externalScopes.has(scopeName)) continue;
     const causes = [];
-    if (isExternal && !meta.hasFrontmatter) {
-      causes.push('its scope index has no frontmatter; fix it in the source package');
-    }
-    if (isExternal && meta.extendsOnly !== null && meta.extendsOnly !== 'true' && meta.extendsOnly !== 'false') {
-      causes.push(`its scope index has an invalid extends-only value "${meta.extendsOnly}" (treated as absent); fix it in the source package`);
-    }
-    if (isExternal && meta.hasFrontmatter && meta.scopeTypes.length === 0) {
-      causes.push('its scope index has no scope-type; fix it in the source package');
-    }
     for (const [field, targets] of [['follows', meta.follows], ['extends', meta.extends]]) {
       for (const target of targets) {
         if (target === scopeName || RESERVED_SCOPES.has(target)) continue;
         const targetMeta = scopeMeta.get(target);
-        if (!targetMeta) {
-          if (isExternal) causes.push(`${field}: scope "${target}" is not present in this workspace; install it`);
-        } else if (isDisabled(target)) {
+        if (!targetMeta) continue;
+        if (isDisabled(target)) {
           causes.push(`${field}: scope "${target}" is tagged \`disabled\` in the root index; enable it or remove the ${field}: reference`);
         } else if (!targetMeta.hasFrontmatter) {
           causes.push(`${field}: scope "${target}" has an invalid scope index; fix it`);
@@ -474,18 +449,15 @@ function collectReadOnlyScopes(scopeMeta, activation, externalScopes, knownScope
       }
     }
     for (const scopeType of resolveScopeTypeChain(meta.scopeTypes, knownScopeTypes)) {
-      if (scopeType === '_local') continue;
-      if (!knownScopeTypes.has(scopeType)) {
-        if (isExternal) causes.push(`scope type "${scopeType}" has no ${scopeType}-scope-type policy in this workspace; install the scope that defines it`);
-        continue;
-      }
+      if (scopeType === '_local' || !knownScopeTypes.has(scopeType)) continue;
       const definers = [...scopeTypeDefiningScopes.get(scopeType)].filter((s) => s !== scopeName);
       if (definers.length > 0 && definers.every(isDisabled)) {
         causes.push(`scope type "${scopeType}" is defined only in disabled scope(s) ${definers.map((s) => `"${s}"`).join(', ')}; enable one of them`);
       }
     }
-    if (causes.length > 0) {
-      readOnlyScopes.set(scopeName, causes);
+    const display = toDisplayPath(path.join(xdrsRoot, scopeName, 'index.md'));
+    for (const cause of causes) {
+      errors.push(`Local scope "${scopeName}" is frozen (read-only) because ${cause}: ${display} [_core-adr-policy-022.06-read-only-dependencies]`);
     }
   }
 }
@@ -787,8 +759,7 @@ function lintScopeIndexFrontmatter(scopeIndexPath, scopeName, errors, xdrsRoot,
           }
           const followedIndexPath = path.join(xdrsRoot, entry, 'index.md');
           if (!existsFile(followedIndexPath)) {
-            // Missing -core is expected for an external companion scope: it becomes read-only
-            // (collected by collectReadOnlyScopes per _core-adr-policy-022.06), not a lint error.
+            // A missing dependency of an external scope makes it READ-ONLY (_core-adr-policy-022.06); lint does not report it.
             if (!isExternal) {
               errors.push(`Scope index frontmatter follows references scope "${entry}" which does not exist in the workspace: ${toDisplayPath(scopeIndexPath)} [_core-adr-policy-001]`);
             }
@@ -858,7 +829,7 @@ function lintScopeIndexFrontmatter(scopeIndexPath, scopeName, errors, xdrsRoot,
 }
 
 
-function lintScopeDirectory(xdrsRoot, scopeName, errors, warnings, actualTypeIndexes, ignoreExternal, externalScopes, knownScopeTypes = new Map(), extendsRelationships = new Map(), trackedExternalScopes = new Set()) {
+function lintScopeDirectory(xdrsRoot, scopeName, errors, actualTypeIndexes, ignoreExternal, externalScopes, knownScopeTypes = new Map(), extendsRelationships = new Map(), trackedExternalScopes = new Set()) {
   const scopePath = path.join(xdrsRoot, scopeName);
 
   if (ignoreExternal && externalScopes.has(scopeName)) {
@@ -897,7 +868,7 @@ function lintScopeDirectory(xdrsRoot, scopeName, errors, warnings, actualTypeInd
         errors.push(`Unexpected directory under scope ${scopeName}: ${toDisplayPath(entryPath)} [_core-adr-policy-001]`);
         continue;
       }
-      lintTypeDirectory(xdrsRoot, scopeName, entry.name, errors, warnings, actualTypeIndexes, externalScopes, isCoreTypeNonExempt, isCompiledScope);
+      lintTypeDirectory(xdrsRoot, scopeName, entry.name, errors, actualTypeIndexes, externalScopes, isCoreTypeNonExempt, isCompiledScope);
       const typeIndexPath = path.join(entryPath, 'index.md');
       if (existsFile(typeIndexPath)) {
         typeIndexesInScope.push(typeIndexPath);
@@ -1028,7 +999,7 @@ function lintLocalMetaPolicies(xdrsRoot, scopeName, errors, isCompiledScope = fa
   }
 }
 
-function lintTypeDirectory(xdrsRoot, scopeName, typeName, errors, warnings, actualTypeIndexes, externalScopes = new Set(), enforceStructured = false, isCompiledScope = false) {
+function lintTypeDirectory(xdrsRoot, scopeName, typeName, errors, actualTypeIndexes, externalScopes = new Set(), enforceStructured = false, isCompiledScope = false) {
   const typePath = path.join(xdrsRoot, scopeName, typeName);
   const indexPath = path.join(typePath, 'index.md');
   const xdrsNumbers = new Map();
@@ -1055,11 +1026,10 @@ function lintTypeDirectory(xdrsRoot, scopeName, typeName, errors, warnings, actu
         errors.push(`Invalid subject folder for ${typeName}: ${toDisplayPath(entryPath)} [_core-adr-policy-001]`);
         continue;
       }
-      // All policies are frozen: emit a warning and still process for content-level checks.
-      warnings.push(`Invalid subject folder for ${typeName}: ${toDisplayPath(entryPath)} [_core-adr-policy-001] [exempt: freeze-reference]`);
+      // All policies are frozen (_core-adr-policy-002.01): skip the check, keep content-level checks.
     }
 
-    artifacts.push(...lintSubjectDirectory(xdrsRoot, scopeName, typeName, entry.name, xdrsNumbers, errors, warnings, externalScopes, enforceStructured, isCompiledScope));
+    artifacts.push(...lintSubjectDirectory(xdrsRoot, scopeName, typeName, entry.name, xdrsNumbers, errors, externalScopes, enforceStructured, isCompiledScope));
   }
 
   if (existsFile(indexPath)) {
@@ -1067,7 +1037,7 @@ function lintTypeDirectory(xdrsRoot, scopeName, typeName, errors, warnings, actu
   }
 }
 
-function lintSubjectDirectory(xdrsRoot, scopeName, typeName, subjectName, xdrsNumbers, errors, warnings, externalScopes = new Set(), enforceStructured = false, isCompiledScope = false) {
+function lintSubjectDirectory(xdrsRoot, scopeName, typeName, subjectName, xdrsNumbers, errors, externalScopes = new Set(), enforceStructured = false, isCompiledScope = false) {
   const subjectPath = path.join(xdrsRoot, scopeName, typeName, subjectName);
   const artifacts = [];
   const entries = safeReadDir(subjectPath, errors, `read subject directory ${scopeName}/${typeName}/${subjectName}`);
@@ -1106,7 +1076,7 @@ function lintSubjectDirectory(xdrsRoot, scopeName, typeName, subjectName, xdrsNu
     }
 
     artifacts.push(entryPath);
-    lintXdrsElementFile(xdrsRoot, scopeName, typeName, subjectName, entryPath, xdrsNumbers, errors, warnings, externalScopes, enforceStructured, isCompiledScope);
+    lintXdrsElementFile(xdrsRoot, scopeName, typeName, subjectName, entryPath, xdrsNumbers, errors, externalScopes, enforceStructured, isCompiledScope);
   }
 
   const subjectAssetsDir = path.join(subjectPath, RESOURCE_DIR_NAME);
@@ -1116,7 +1086,7 @@ function lintSubjectDirectory(xdrsRoot, scopeName, typeName, subjectName, xdrsNu
   return artifacts;
 }
 
-function lintXdrsElementFile(xdrsRoot, scopeName, typeName, subjectName, filePath, xdrsNumbers, errors, warnings, externalScopes = new Set(), enforceStructured = false, isCompiledScope = false) {
+function lintXdrsElementFile(xdrsRoot, scopeName, typeName, subjectName, filePath, xdrsNumbers, errors, externalScopes = new Set(), enforceStructured = false, isCompiledScope = false) {
   const baseName = path.basename(filePath);
   const match = baseName.match(NUMBERED_FILE_RE);
   if (!match) {
@@ -1136,26 +1106,23 @@ function lintXdrsElementFile(xdrsRoot, scopeName, typeName, subjectName, filePat
   }
 
   const content = fs.readFileSync(filePath, 'utf8');
-  lintPolicyNumberRange(number, subjectName, content, filePath, errors, warnings);
+  lintPolicyNumberRange(number, subjectName, content, filePath, errors);
   const { freezeReference } = extractFrontmatter(content);
   const expectedHeader = `# ${scopeName}-${TYPE_TO_ID[typeName]}-${number}:`;
   const firstLine = firstNonEmptyLine(stripFrontmatter(content));
   if (!freezeReference && !firstLine.startsWith(expectedHeader)) {
     errors.push(`Policy title must start with "${expectedHeader}": ${toDisplayPath(filePath)} [_core-adr-policy-002]`);
-  } else if (freezeReference && !firstLine.startsWith(expectedHeader)) {
-    warnings.push(`Policy title must start with "${expectedHeader}": ${toDisplayPath(filePath)} [_core-adr-policy-002] [exempt: freeze-reference]`);
   }
 
   // Enforce 'core' word reservation: only allowed as first word of filename title in principles/
   const titleParts = match[2].split('-');
-  if (titleParts.includes('core') && !(subjectName === 'principles' && titleParts[0] === 'core')) {
-    const msg = `Policy filename must not use "core" as a name word unless it is a local meta-policy in "principles/" starting with "core" (e.g., "NNN-core.md" or "NNN-core-{qualifier}.md"): ${toDisplayPath(filePath)} [_core-adr-policy-010.13-local-naming]`;
-    if (freezeReference) { warnings.push(`${msg} [exempt: freeze-reference]`); } else { errors.push(msg); }
+  if (!freezeReference && titleParts.includes('core') && !(subjectName === 'principles' && titleParts[0] === 'core')) {
+    errors.push(`Policy filename must not use "core" as a name word unless it is a local meta-policy in "principles/" starting with "core" (e.g., "NNN-core.md" or "NNN-core-{qualifier}.md"): ${toDisplayPath(filePath)} [_core-adr-policy-010.13-local-naming]`);
   }
 
   const expectedName = extractExpectedXdrsNameFromHeading(firstLine)
     || `${scopeName}-${TYPE_TO_ID[typeName]}-${number}-${match[2]}`;
-  lintXdrsElementFrontmatter(content, expectedName, filePath, errors, warnings, freezeReference);
+  lintXdrsElementFrontmatter(content, expectedName, filePath, errors, freezeReference);
   if (enforceStructured) {
     validateStructuredFormatContent(content, filePath, errors, '_core-adr-policy-010.12-def-core-scope-policies-must-be-structured');
   } else if (isCompiledScope) {
@@ -1198,7 +1165,7 @@ function slugifyTitle(title) {
     .replace(/--+/g, '-');
 }
 
-function lintXdrsElementFrontmatter(content, expectedName, filePath, errors, warnings, freezeReference = false) {
+function lintXdrsElementFrontmatter(content, expectedName, filePath, errors, freezeReference = false) {
   const fm = extractFrontmatter(content);
   if (!fm.present) {
     errors.push(`Policy must start with a YAML frontmatter block: ${toDisplayPath(filePath)} [_core-adr-policy-002]`);
@@ -1207,9 +1174,8 @@ function lintXdrsElementFrontmatter(content, expectedName, filePath, errors, war
   if (!fm.name) {
     errors.push(`Policy frontmatter must include a non-empty name field: ${toDisplayPath(filePath)} [_core-adr-policy-002]`);
   } else {
-    if (fm.name !== expectedName) {
-      const msg = `Policy frontmatter name must be "${expectedName}": ${toDisplayPath(filePath)} [_core-adr-policy-002]`;
-      if (freezeReference) { warnings.push(`${msg} [exempt: freeze-reference]`); } else { errors.push(msg); }
+    if (fm.name !== expectedName && !freezeReference) {
+      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]`);
@@ -1915,19 +1881,17 @@ function hasAnyNonFrozenPolicy(dirPath) {
   return false;
 }
 
-function lintPolicyNumberRange(number, subjectName, content, filePath, errors, warnings) {
-  const fm = extractFrontmatter(content);
+function lintPolicyNumberRange(number, subjectName, content, filePath, errors) {
+  if (extractFrontmatter(content).freezeReference) return;
   const num = parseInt(number, 10);
   if (num >= RESERVED_NUMBER_RANGE_MIN && num <= RESERVED_NUMBER_RANGE_MAX) {
-    const msg = `Policy number ${number} is in the reserved range (801–900) which MUST NOT be assigned: ${toDisplayPath(filePath)} [_core-adr-policy-017.05-reserved-gap-must-not-be-assigned]`;
-    if (fm.freezeReference) { warnings.push(`${msg} [exempt: freeze-reference]`); } else { errors.push(msg); }
+    errors.push(`Policy number ${number} is in the reserved range (801–900) which MUST NOT be assigned: ${toDisplayPath(filePath)} [_core-adr-policy-017.05-reserved-gap-must-not-be-assigned]`);
     return;
   }
   if (num < OVERFLOW_RANGE_MIN) {
     const range = SUBJECT_NUMBER_RANGES[subjectName];
     if (range && (num < range[0] || num > range[1])) {
-      const msg = `Policy number ${number} is outside the ${range[0]}–${range[1]} block reserved for subject "${subjectName}": ${toDisplayPath(filePath)} [_core-adr-policy-017.01-numbering-blocks-per-subject]`;
-      if (fm.freezeReference) { warnings.push(`${msg} [exempt: freeze-reference]`); } else { errors.push(msg); }
+      errors.push(`Policy number ${number} is outside the ${range[0]}–${range[1]} block reserved for subject "${subjectName}": ${toDisplayPath(filePath)} [_core-adr-policy-017.01-numbering-blocks-per-subject]`);
     }
   }
 }

package/lib/lint.test.js

@@ -2245,22 +2245,35 @@ test('reports error when follows references a scope not in workspace', () => {
   const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
 
   expect(result.errors.join('\n')).toContain('follows references scope "nonexistent-core" which does not exist in the 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', {
+test.each([[true], [false]])('does not report a missing follows target of an external scope (ignoreExternal=%s) [022.06]', (ignoreExternal) => {
+  const workspaceRoot = createWorkspace(`follows-missing-scope-external-${ignoreExternal}`, {
     '.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',
+    '.filedist.lock': '.xdrs/myteam/index.md|some-package|1.0.0\n.xdrs/myteam/adrs/index.md|some-package|1.0.0\n.xdrs/myteam/adrs/principles/001-team.md|some-package|1.0.0\n',
+  });
+
+  const result = lintWorkspace(workspaceRoot, { ignoreExternal });
+
+  expect(result.errors.join('\n')).not.toContain('nonexistent-core');
+  expect(result.errors.join('\n')).not.toContain('022.06');
+});
+
+test('does not report a missing extends target of an external scope [022.06]', () => {
+  const workspaceRoot = createWorkspace('extends-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\nextends: ghost-lib\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/index.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);
+  expect(result.errors.join('\n')).not.toContain('ghost-lib');
 });
 
 test('accepts follows scope that exists in workspace', () => {
@@ -2525,7 +2538,6 @@ test('does not warn 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')).not.toContain('[_core-adr-policy-010.35-extends-index]');
   expect(result.errors.join('\n')).not.toContain('_core-adr-policy-022');
 });
 
@@ -5563,7 +5575,6 @@ function scopeFiles(name, extraFields = '', scopeType = 'standard') {
 }
 
 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', {
@@ -5572,7 +5583,7 @@ test('passes activation checks when only _core is installed and linked (smoke)',
   });
   const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
   expect(activationErrors(result)).toBe('');
-  expect(result.readOnlyScopes.size).toBe(0);
+  expect(Object.keys(result).sort()).toEqual(['errors', 'xdrsRoot']);
 });
 
 test('reports unlisted scope without type indexes with a paste-ready line [022.01]', () => {
@@ -5691,7 +5702,6 @@ test('accepts consumer narrowing: extends-only: false with an extends-only tag [
   });
   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) => {
@@ -5703,7 +5713,7 @@ test.each([['quoted', '"true"'], ['capitalised', 'True']])('reports %s extends-o
   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]', () => {
+test('does not report an invalid extends-only value in an external scope [022.07]', () => {
   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'),
@@ -5711,7 +5721,6 @@ test('marks external scope with invalid extends-only value read-only, treated as
   });
   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]', () => {
@@ -5728,17 +5737,18 @@ test('reports extends-only on core-type and _local scopes [022.07]', () => {
   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]', () => {
+test('reports an error 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');
+  expect(activationErrors(result)).toContain('Scope "lib" is tagged `extends-only` but no active scope extends it');
+  expect(activationErrors(result)).toContain('add it to the extends: of an active scope or tag it `disabled`');
+  expect(activationErrors(result)).toContain('[_core-adr-policy-022.04-extends-only]');
 });
 
-test('warns when an extends-only scope is reached only through a disabled scope [022.04]', () => {
+test('reports an extends-only scope reached only through a disabled scope, and the frozen extender [022.04, 022.06]', () => {
   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'),
@@ -5746,11 +5756,11 @@ test('warns when an extends-only scope is reached only through a disabled scope
     ...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`');
+  expect(activationErrors(result)).toContain('Scope "lib" is tagged `extends-only`');
+  expect(activationErrors(result)).toContain('Local scope "myteam" is frozen (read-only) because 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]', () => {
+test('reports a local scope following a disabled scope as frozen 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'),
@@ -5758,22 +5768,24 @@ test('makes a scope following a disabled scope read-only while it still reaches
     ...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');
+  const errors = activationErrors(result);
+  expect(errors).not.toContain('022.04');
+  expect(errors).toContain('Local scope "myteam" is frozen (read-only) because follows: scope "area-core" is tagged `disabled` in the root index; enable it or remove the follows: reference: ');
+  expect(errors).toContain('myteam/index.md [_core-adr-policy-022.06-read-only-dependencies]');
 });
 
-test('makes an external scope extending a disabled scope read-only [022.06]', () => {
+test('does not report an external scope extending a disabled scope [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);
+  expect(activationErrors(lintWorkspace(workspaceRoot))).toBe('');
+  expect(activationErrors(lintWorkspace(workspaceRoot, { ignoreExternal: false }))).toBe('');
 });
 
-test('makes _local extending a disabled scope read-only [022.06]', () => {
+test('reports _local extending a disabled scope as frozen [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'),
@@ -5781,10 +5793,10 @@ test('makes _local extending a disabled scope read-only [022.06]', () => {
     ...coreWithScopeTypes(['standard', '_local']),
   });
   const result = lintWorkspace(workspaceRoot, { ignoreExternal: false });
-  expect(result.readOnlyScopes.has('_local')).toBe(true);
+  expect(activationErrors(result)).toContain('Local scope "_local" is frozen (read-only)');
 });
 
-test('makes a scope whose type is defined only in a disabled scope read-only [022.06]', () => {
+test('reports a local scope whose type is defined only in a disabled scope as frozen [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'),
@@ -5795,10 +5807,22 @@ test('makes a scope whose type is defined only in a disabled scope read-only [02
   });
   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"');
+  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]', () => {
+  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');
 });
 
-test('prints one read-only line per cause citing 022.06', () => {
+test('prints frozen local scopes as errors and never prints warning or READ-ONLY lines [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'),
@@ -5806,22 +5830,40 @@ test('prints one read-only line per cause citing 022.06', () => {
     ...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(() => {});
+  const out = [];
+  const errOut = [];
+  const logSpy = jest.spyOn(console, 'log').mockImplementation((msg) => out.push(msg));
+  const errSpy = jest.spyOn(console, 'error').mockImplementation((msg) => errOut.push(msg));
+  const warnSpy = jest.spyOn(console, 'warn').mockImplementation((msg) => out.push(msg));
+  let code;
   try {
-    runLintCli(['--all', workspaceRoot]);
+    code = 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);
+  expect(code).toBe(1);
+  const frozenLines = errOut.filter((l) => l.includes('Local scope "myteam" is frozen (read-only)'));
+  expect(frozenLines).toHaveLength(2);
+  expect(frozenLines.every((l) => l.includes('[_core-adr-policy-022.06-read-only-dependencies]'))).toBe(true);
+  expect([...out, ...errOut].join('\n')).not.toMatch(/\[warning\]|READ-ONLY/);
+});
+
+test('silently skips freeze-reference exempt checks [002.01]', () => {
+  const frozen = (name) => teamXdrDocument('Frozen decision.')
+    .replace(/^---\n/, `---\nfreeze-reference: true\n`)
+    .replace(/^name: .*$/m, `name: ${name}`);
+  const workspaceRoot = createWorkspace('freeze-reference-silent', {
+    '.xdrs/index.md': rootIndex(['[_core](_core/index.md)', '[View scope myteam](myteam/index.md)']),
+    '.xdrs/myteam/index.md': scopeIndexWith('myteam'),
+    '.xdrs/myteam/adrs/index.md': teamAdrIndex(['- [850-frozen](principles/850-frozen.md) - Frozen']),
+    '.xdrs/myteam/adrs/principles/850-frozen.md': frozen('wrong-name'),
+  });
+  const errors = lintWorkspace(workspaceRoot, { ignoreExternal: false }).errors.join('\n');
+  expect(errors).not.toContain('017.05');
+  expect(errors).not.toContain('Policy frontmatter name must be');
+  expect(errors).not.toContain('Policy title must start with');
 });
 
 test('dry-run workspace: disabled core, extends-only ref, unlisted legacy scope', () => {
@@ -5834,10 +5876,10 @@ test('dry-run workspace: disabled core, extends-only ref, unlisted legacy scope'
   });
   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);
+  const errors = activationErrors(result).split('\n');
+  expect(errors).toHaveLength(2);
+  expect(errors.join('\n')).toContain('[View scope legacy](legacy/index.md)');
+  expect(errors.join('\n')).toContain('Local scope "checkout" is frozen (read-only) because follows: scope "ecomm-core" is tagged `disabled`');
   expect(fs.readFileSync(path.join(workspaceRoot, '.xdrs/ecomm-core/index.md'), 'utf8')).toBe(disabledIndexBefore);
 });
 
@@ -5872,7 +5914,7 @@ test('treats a type whose parent chain reaches core as core-type (naming, follow
   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]', () => {
+test('reports missing scope-type for local scopes 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)']),
@@ -5885,10 +5927,10 @@ test('reports missing scope-type for local scopes and marks external ones read-o
   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');
+  expect(result.errors.join('\n')).not.toContain('022.06');
 });
 
-test('reports missing parent type for local scopes and marks external ones read-only [010.09, 022.06]', () => {
+test('reports missing parent type for local scopes 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'),
@@ -5900,7 +5942,7 @@ test('reports missing parent type for local scopes and marks external ones read-
   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"');
+  expect(result.errors.join('\n')).not.toMatch(/vendor\/index\.md.*ghost/);
 });
 
 test('accepts compiled combined with a non-core type [011.10]', () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xdrs-core",
-  "version": "0.52.2",
+  "version": "0.52.3",
   "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",