structured-context 0.10.0 → 0.12.0

package/dist/space-graph.d.ts

@@ -1,8 +1,10 @@
-import type { HierarchyLevel, SpaceNode } from './types';
+import type { Hierarchy, SpaceNode } from './types';
 /**
  * A navigable graph over a set of SpaceNodes.
  *
- * Built once from SpaceNode[] + hierarchy levels via buildSpaceGraph().
+ * Built once from SpaceNode[] + one selected hierarchy via buildSpaceGraph().
+ * The hierarchy-specific views (roots, orphans, hierarchyChildren, ...) cover only that hierarchy;
+ * nodes of other hierarchies' types are non-hierarchy nodes in this graph.
  * Provides typed access to nodes, edges, traversal, and classification
  * so consumers don't need to build their own indexes.
  */
@@ -15,14 +17,14 @@ export type SpaceGraph = {
     readonly orphans: readonly SpaceNode[];
     /** Non-hierarchy nodes: type not in the hierarchy levels definition. */
     readonly nonHierarchy: readonly SpaceNode[];
-    /** Hierarchy children map: parent title → direct children connected via hierarchy edges only. */
+    /** Hierarchy children map: parent title → direct children connected via this hierarchy's edges only. */
     readonly hierarchyChildren: ReadonlyMap<string, readonly SpaceNode[]>;
     /** All-edges children map: parent title → direct children connected via any edge (hierarchy + relationship). */
     readonly children: ReadonlyMap<string, readonly SpaceNode[]>;
     /** Set of all node titles that are part of the hierarchy (roots + their descendants + orphans). */
     readonly hierarchyTitles: ReadonlySet<string>;
-    /** Hierarchy levels used to build this graph. */
-    readonly levels: readonly HierarchyLevel[];
+    /** The hierarchy used to build this graph, if the schema has one. */
+    readonly hierarchy: Hierarchy | undefined;
 };
-/** Build a SpaceGraph from a flat list of SpaceNodes and hierarchy level definitions. */
-export declare function buildSpaceGraph(nodes: SpaceNode[], levels: readonly HierarchyLevel[]): SpaceGraph;
+/** Build a SpaceGraph from a flat list of SpaceNodes and the hierarchy to structure it by. */
+export declare function buildSpaceGraph(nodes: SpaceNode[], hierarchy: Hierarchy | undefined): SpaceGraph;

package/dist/space-graph.js

@@ -1,7 +1,9 @@
-/** Build a SpaceGraph from a flat list of SpaceNodes and hierarchy level definitions. */
-export function buildSpaceGraph(nodes, levels) {
+/** Build a SpaceGraph from a flat list of SpaceNodes and the hierarchy to structure it by. */
+export function buildSpaceGraph(nodes, hierarchy) {
+    const levels = hierarchy?.levels ?? [];
     const hierarchyTypes = new Set(levels.map((l) => l.type));
     const rootType = levels[0]?.type;
+    const isHierarchyEdge = (r) => r.source === 'hierarchy' && r.hierarchy === hierarchy?.name;
     const nodesMap = new Map();
     const hierarchyChildrenMap = new Map();
     const childrenMap = new Map();
@@ -22,7 +24,7 @@ export function buildSpaceGraph(nodes, levels) {
                 childrenMap.set(parentRef.title, []);
             childrenMap.get(parentRef.title).push(node);
             // Hierarchy-only map
-            if (parentRef.source === 'hierarchy') {
+            if (isHierarchyEdge(parentRef)) {
                 if (!hierarchyChildrenMap.has(parentRef.title))
                     hierarchyChildrenMap.set(parentRef.title, []);
                 hierarchyChildrenMap.get(parentRef.title).push(node);
@@ -37,7 +39,7 @@ export function buildSpaceGraph(nodes, levels) {
             continue;
         }
         // Only hierarchy-sourced parents determine structural position in the DAG
-        const hierarchyParents = node.resolvedParents.filter((r) => r.source === 'hierarchy');
+        const hierarchyParents = node.resolvedParents.filter(isHierarchyEdge);
         if (hierarchyParents.length === 0) {
             if (nodeType === rootType) {
                 hierarchyRoots.push(node);
@@ -77,6 +79,6 @@ export function buildSpaceGraph(nodes, levels) {
         hierarchyChildren: hierarchyChildrenMap,
         children: childrenMap,
         hierarchyTitles,
-        levels,
+        hierarchy,
     };
 }

package/dist/testing.d.ts

@@ -0,0 +1,33 @@
+import type { BaseNode, Hierarchy, HierarchyLevel, Relationship, ResolvedParentRef, SpaceNode } from './types';
+/**
+ * Creates a ResolvedParentRef with sensible defaults for use in tests.
+ * Override any field to represent specific edge contexts.
+ */
+export declare const makeParentRef: (title: string, overrides?: Partial<ResolvedParentRef>) => ResolvedParentRef;
+/**
+ * Creates a HierarchyLevel with defaults matching schema metadata normalization.
+ */
+export declare const makeLevel: (type: string, overrides?: Partial<HierarchyLevel>) => HierarchyLevel;
+/**
+ * Creates a named Hierarchy (default name 'main') from normalized levels.
+ */
+export declare const makeHierarchy: (levels: HierarchyLevel[], overrides?: Partial<Hierarchy>) => Hierarchy;
+/**
+ * SchemaMetadata fields for a schema whose only hierarchy is its main hierarchy.
+ */
+export declare const withHierarchy: (levels: HierarchyLevel[], overrides?: Partial<Hierarchy>) => {
+    hierarchy: Hierarchy;
+    hierarchies: Hierarchy[];
+};
+/**
+ * Creates a Relationship with defaults matching schema metadata normalization.
+ */
+export declare const makeRelationship: (parent: string, type: string, overrides?: Partial<Relationship>) => Relationship;
+/**
+ * Creates a BaseNode with sensible defaults for use in tests.
+ */
+export declare const makeNode: (title: string, type: string, extra?: Record<string, unknown>, linkTargets?: string[]) => BaseNode;
+/**
+ * Creates a SpaceNode with sensible defaults for use in tests.
+ */
+export declare const makeSpaceNode: (title: string, type: string, extra?: Record<string, unknown>, linkTargets?: string[], resolvedParents?: ResolvedParentRef[], resolvedLinks?: SpaceNode["resolvedLinks"]) => SpaceNode;

package/dist/testing.js

@@ -0,0 +1,72 @@
+/**
+ * Creates a ResolvedParentRef with sensible defaults for use in tests.
+ * Override any field to represent specific edge contexts.
+ */
+export const makeParentRef = (title, overrides = {}) => {
+    const source = overrides.source ?? 'hierarchy';
+    return {
+        title,
+        field: 'parent',
+        source,
+        ...(source === 'hierarchy' ? { hierarchy: 'main' } : {}),
+        selfRef: false,
+        fieldOn: 'child',
+        ...overrides,
+    };
+};
+/**
+ * Creates a HierarchyLevel with defaults matching schema metadata normalization.
+ */
+export const makeLevel = (type, overrides = {}) => ({
+    type,
+    field: 'parent',
+    fieldOn: 'child',
+    multiple: false,
+    selfRef: false,
+    ...overrides,
+});
+/**
+ * Creates a named Hierarchy (default name 'main') from normalized levels.
+ */
+export const makeHierarchy = (levels, overrides = {}) => ({
+    name: 'main',
+    levels,
+    ...overrides,
+});
+/**
+ * SchemaMetadata fields for a schema whose only hierarchy is its main hierarchy.
+ */
+export const withHierarchy = (levels, overrides = {}) => {
+    const hierarchy = makeHierarchy(levels, overrides);
+    return { hierarchy, hierarchies: [hierarchy] };
+};
+/**
+ * Creates a Relationship with defaults matching schema metadata normalization.
+ */
+export const makeRelationship = (parent, type, overrides = {}) => ({
+    parent,
+    type,
+    field: 'parent',
+    fieldOn: 'child',
+    multiple: false,
+    ...overrides,
+});
+/**
+ * Creates a BaseNode with sensible defaults for use in tests.
+ */
+export const makeNode = (title, type, extra = {}, linkTargets) => ({
+    label: `${title}.md`,
+    title,
+    schemaData: { title, type, ...extra },
+    linkTargets: linkTargets ?? [title],
+    type,
+});
+/**
+ * Creates a SpaceNode with sensible defaults for use in tests.
+ */
+export const makeSpaceNode = (title, type, extra = {}, linkTargets, resolvedParents = [], resolvedLinks = []) => ({
+    ...makeNode(title, type, extra, linkTargets),
+    resolvedType: type,
+    resolvedParents,
+    resolvedLinks,
+});

package/dist/types.d.ts

@@ -40,11 +40,21 @@ export type ResolvedParentRef = {
     field: string;
     /** Whether this edge originates from a hierarchy level or a relationship definition. */
     source: 'hierarchy' | 'relationship';
+    /** Name of the hierarchy the edge belongs to. Set only when source is 'hierarchy'. */
+    hierarchy?: string;
     /** Whether the parent and child are the same node type (self-referential edge). */
     selfRef: boolean;
     /** Whether the edge field is on the child node (default) or on the parent node (fieldOn:'parent' edges). */
     fieldOn: 'child' | 'parent';
 };
+export type SourceLocation = {
+    /** File path relative to the space root. */
+    file: string;
+    /** 1-indexed starting line number in the source file, if available. */
+    line?: number;
+    /** 1-indexed starting column number in the source file, if available. */
+    column?: number;
+};
 export type UnresolvedRef = {
     /** Source identifier of the node containing the broken link. */
     label: string;
@@ -55,6 +65,44 @@ export type UnresolvedRef = {
     reason: 'not_found' | 'ambiguous' | 'invalid_shape';
     /** Human-readable message matching validate-graph output format. */
     message: string;
+    /** Source location of the node containing the broken link, if available. */
+    source?: SourceLocation;
+};
+/**
+ * Shared fields for all content link variants.
+ */
+type ContentLinkBase = {
+    /** Display text of the link (text content for markdown links, inner text or target for wikilinks). */
+    text: string;
+    /** Raw link target: URL for markdown links, wikilink path (without [[ ]]) for wikilinks. */
+    target: string;
+    /** Whether the link navigates to a resource or transcludes/embeds it. */
+    action: 'link' | 'embed';
+    /** Anchor fragment (heading or block ref, e.g. 'heading-title' or '^blockid') if present. */
+    anchor?: string;
+};
+/**
+ * A link extracted from node content at parse time, before location classification.
+ * Populated by plugins that support content link extraction (e.g. the markdown plugin).
+ */
+export type ContentLink = ContentLinkBase & {
+    /** Link syntax — used during resolution to determine how to classify the target. */
+    linkSyntax: 'wikilink' | 'markdown';
+};
+/**
+ * A fully classified link from node content, after location resolution.
+ * Present on SpaceNode after graph resolution.
+ */
+export type ResolvedContentLink = ContentLinkBase & {
+    /**
+     * Resolved location classification:
+     * - 'node'     — wikilink resolved to a known space node
+     * - 'internal' — wikilink or relative path, in the source system but not a space node
+     * - 'external' — http/https URL
+     * - 'system'   — file:// URL
+     * - 'protocol' — other scheme (e.g. obsidian://)
+     */
+    location: 'node' | 'internal' | 'external' | 'system' | 'protocol';
 };
 /**
  * A node as produced by a parse plugin — raw type from content, no graph resolution applied.
@@ -71,6 +119,15 @@ export type BaseNode = {
     linkTargets: string[];
     /** Raw type string from content, as written by the user. */
     type: string;
+    /** Body content of the node, if any. First-class accessor mirroring schemaData.content. */
+    content?: string;
+    /**
+     * Links extracted from content body and non-edge string fields at parse time.
+     * Populated by plugins that support content link extraction; absent if not populated.
+     */
+    contentLinks?: ContentLink[];
+    /** Source location of the node definition in the filesystem. */
+    source?: SourceLocation;
 };
 /**
  * A fully resolved node — enriched by core after plugin parsing.
@@ -85,6 +142,11 @@ export type SpaceNode = BaseNode & {
      * Always present, empty if no parents resolved.
      */
     resolvedParents: ResolvedParentRef[];
+    /**
+     * Links from content body and non-edge fields, with location classified after graph resolution.
+     * Always present, empty if the plugin did not populate rawContentLinks.
+     */
+    resolvedLinks: ResolvedContentLink[];
 };
 export type ParseIssue = {
     /** Source identifier of the file or item (filename or heading title). */
@@ -97,14 +159,25 @@ export type ParseIssue = {
     type: 'no-type' | 'parse' | string;
     /** Human-readable detail. */
     message?: string;
+    /** 1-indexed line number in source file, if available. */
+    line?: number;
+    /** 1-indexed column number in source file, if available. */
+    column?: number;
 };
 /** Rule categories for organizing executable validation rules */
 export type RuleCategory = 'validation' | 'coherence' | 'workflow' | 'best-practice';
+/**
+ * Rule violation severity. Only `error` fails validation; `warning` and `info` are reported only.
+ * A rule's severity defaults from its category and may be overridden per rule.
+ */
+export type RuleSeverity = 'error' | 'warning' | 'info';
 export type { Rule } from './schema/metadata-contract';
 export type RuleViolation = {
+    /** Node label, or empty string for global-scope rules. */
     file: string;
     ruleId: string;
     category: RuleCategory;
+    severity: RuleSeverity;
     description: string;
 };
 export type GraphViolation = {
@@ -115,11 +188,18 @@ export type GraphViolation = {
     parentTitle: string;
     description: string;
 };
+/** A named hierarchy, normalized from a schema's `$metadata.hierarchy`. */
+export type Hierarchy = {
+    /** Declared short name, defaulting to the declaring schema's file stem. */
+    name: string;
+    levels: HierarchyLevel[];
+    allowSkipLevels?: boolean;
+};
 export type SchemaMetadata = {
-    hierarchy?: {
-        levels: HierarchyLevel[];
-        allowSkipLevels?: boolean;
-    };
+    /** Main hierarchy: used for space_on_a_page parsing, embedding, template-sync and default rendering. */
+    hierarchy?: Hierarchy;
+    /** Every hierarchy in the composed schema (main included), in composition order. Each type belongs to at most one. */
+    hierarchies?: Hierarchy[];
     typeAliases?: Record<string, string>;
     rules?: Rule[];
     relationships?: Relationship[];
@@ -155,16 +235,29 @@ export type SpaceContext = {
     /** Directory of the config file that defines this space. Used for resolving relative paths in plugin configs. */
     configDir: string;
 };
+export interface FileValidationIssue {
+    kind: string;
+    message: string;
+    /** Present for rule violations (`kind: 'rule'`). */
+    severity?: RuleSeverity;
+    /** 1-indexed line number in source file, if available. */
+    line?: number;
+    /** 1-indexed column number in source file, if available. */
+    column?: number;
+}
 export interface FileValidationResult {
     file: string;
     label: string;
     space: string;
     /** Errors keyed by composite id (e.g. `schema:/status:enum:active`, `rule:my-rule-id`). */
-    errors: Record<string, {
-        kind: string;
-        message: string;
-    }>;
+    errors: Record<string, FileValidationIssue>;
     errorCount: number;
+    /**
+     * Warnings keyed by composite id, including `warning` and `info` severity rule violations.
+     * Do not affect exit code or errorCount.
+     */
+    warnings: Record<string, FileValidationIssue>;
+    warningCount: number;
     inSpace: true;
 }
 export interface FileNotInSpaceResult {

package/dist/validate.d.ts

@@ -1,7 +1,7 @@
 import type { ErrorObject } from 'ajv';
 import type { Config } from './config';
 import { extractEntityInfo } from './schema/schema';
-import type { GraphViolation, ParseIssue, RuleViolation, SchemaWithMetadata, SpaceContext, SpaceNode, ValidateFileOutput } from './types';
+import type { GraphViolation, ParseIssue, ReadSpaceResult, RuleViolation, SchemaWithMetadata, SpaceContext, SpaceNode, ValidateFileOutput } from './types';
 export interface FormattedError {
     message: string;
     dedupeKey: string;
@@ -11,11 +11,13 @@ export interface ValidationResult {
     nodeErrorCount: number;
     nodeErrors: Array<{
         file: string;
+        line?: number;
         errors: ErrorObject[];
         nodeData: Record<string, unknown>;
     }>;
     refErrors: Array<{
         file: string;
+        line?: number;
         parent: string;
         error: string;
     }>;
@@ -23,10 +25,16 @@ export interface ValidationResult {
         title: string;
         files: string[];
     }>;
+    /** All rule violations with their effective severity. Only `error` severity fails validation. */
     ruleViolations: RuleViolation[];
     hierarchyViolations: GraphViolation[];
     orphans: SpaceNode[];
     parseIssues: ParseIssue[];
+    /** Content links that could not be resolved to a space node. Warning only — not counted in errors. */
+    unresolvedContentLinks: Array<{
+        file: string;
+        target: string;
+    }>;
 }
 /**
  * Format AJV errors for better readability.
@@ -37,7 +45,9 @@ export declare function formatErrors(errors: ErrorObject[], schema: SchemaWithMe
  * Run full validation on a space and return a structured result.
  * Does not output to console or call process.exit.
  */
-export declare function validateSpace(context: SpaceContext): Promise<ValidationResult>;
+export declare function validateSpace(context: SpaceContext, options?: {
+    readResult?: ReadSpaceResult;
+}): Promise<ValidationResult>;
 /**
  * Validate a single file within its space.
  *
@@ -47,4 +57,6 @@ export declare function validateSpace(context: SpaceContext): Promise<Validation
  * Returns a result object — does not output to console or call process.exit.
  * If the file is not in any configured space, returns a result with `inSpace: false`.
  */
-export declare function validateFile(filePath: string, config: Config): Promise<ValidateFileOutput>;
+export declare function validateFile(filePath: string, config: Config, options?: {
+    configDir?: string;
+}): Promise<ValidateFileOutput>;

package/dist/validate.js

@@ -1,9 +1,9 @@
 import { isAbsolute, relative, resolve } from 'node:path';
-import { getSpaceConfigDir, resolveSchema } from './config';
 import { readSpace } from './read/read-space';
-import { extractEntityInfo, loadSchema } from './schema/schema';
+import { extractEntityInfo } from './schema/schema';
 import { validateGraph } from './schema/validate-graph';
 import { validateRules } from './schema/validate-rules';
+import { createSpaceContext } from './space-context';
 import { buildSpaceGraph } from './space-graph';
 /**
  * Format AJV errors for better readability.
@@ -96,10 +96,10 @@ export function formatErrors(errors, schema, schemaRefRegistry, nodeData) {
  * Run full validation on a space and return a structured result.
  * Does not output to console or call process.exit.
  */
-export async function validateSpace(context) {
+export async function validateSpace(context, options = {}) {
     const { schema, schemaRefRegistry, schemaValidator } = context;
     const metadata = schema.metadata;
-    const readResult = await readSpace(context);
+    const readResult = options.readResult ?? (await readSpace(context));
     const { nodes, parseIssues } = readResult;
     // Pre-extract valid types for early type validation
     const validTypes = Array.isArray(schema.oneOf) ? extractEntityInfo(schema, schemaRefRegistry).map((e) => e.type) : [];
@@ -113,6 +113,7 @@ export async function validateSpace(context) {
         hierarchyViolations: [],
         orphans: [],
         parseIssues,
+        unresolvedContentLinks: [],
     };
     for (const node of nodes) {
         // Early type validation - check before full AJV validation to prevent cascading errors
@@ -120,7 +121,8 @@ export async function validateSpace(context) {
         if (nodeType !== undefined && validTypes.length > 0 && !validTypes.includes(nodeType)) {
             result.nodeErrorCount++;
             result.nodeErrors.push({
-                file: node.label,
+                file: node.source?.file ?? node.label,
+                ...(node.source?.line !== undefined ? { line: node.source.line } : {}),
                 errors: [
                     {
                         instancePath: '/type',
@@ -142,7 +144,8 @@ export async function validateSpace(context) {
         else {
             result.nodeErrorCount++;
             result.nodeErrors.push({
-                file: node.label,
+                file: node.source?.file ?? node.label,
+                ...(node.source?.line !== undefined ? { line: node.source.line } : {}),
                 errors: schemaValidator.errors || [],
                 nodeData: node.schemaData,
             });
@@ -166,14 +169,27 @@ export async function validateSpace(context) {
     const hierarchyValidation = validateGraph(nodes, metadata, readResult.unresolvedRefs);
     result.refErrors.push(...hierarchyValidation.refErrors);
     result.hierarchyViolations = [...hierarchyValidation.violations];
-    // Calculate orphan count (informational, not a validation error)
-    if (metadata.hierarchy) {
-        result.orphans = [...buildSpaceGraph(nodes, metadata.hierarchy.levels).orphans];
+    // Calculate orphans across every hierarchy (informational, not a validation error)
+    for (const hierarchy of metadata.hierarchies ?? []) {
+        result.orphans.push(...buildSpaceGraph(nodes, hierarchy).orphans);
     }
     // Load and execute rules validation if schema defines rules
     if (metadata.rules) {
         result.ruleViolations = await validateRules(nodes, metadata.rules);
     }
+    // Collect unresolved content links (warnings — not errors)
+    const seen = new Set();
+    for (const node of nodes) {
+        for (const link of node.resolvedLinks) {
+            if (link.location === 'internal') {
+                const key = `${node.label}::${link.target}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    result.unresolvedContentLinks.push({ file: node.label, target: link.target });
+                }
+            }
+        }
+    }
     return result;
 }
 /** Find which space a file belongs to by checking directory containment. */
@@ -189,12 +205,6 @@ function resolveFileSpace(filePath, config) {
     }
     return null;
 }
-function buildContextForSpace(space, config) {
-    const resolvedSchemaPath = resolveSchema(config, space);
-    const { schema, schemaRefRegistry, schemaValidator } = loadSchema(resolvedSchemaPath);
-    const configDir = getSpaceConfigDir(space.name);
-    return { space, config, resolvedSchemaPath, schema, schemaRefRegistry, schemaValidator, configDir };
-}
 /**
  * Validate a single file within its space.
  *
@@ -204,7 +214,7 @@ function buildContextForSpace(space, config) {
  * Returns a result object — does not output to console or call process.exit.
  * If the file is not in any configured space, returns a result with `inSpace: false`.
  */
-export async function validateFile(filePath, config) {
+export async function validateFile(filePath, config, options = {}) {
     const resolved = resolveFileSpace(filePath, config);
     if (!resolved) {
         return {
@@ -214,7 +224,7 @@ export async function validateFile(filePath, config) {
         };
     }
     const { space, label } = resolved;
-    const context = buildContextForSpace(space, config);
+    const context = createSpaceContext(space.name, config, { configDir: options.configDir });
     const { schema, schemaRefRegistry, schemaValidator } = context;
     const metadata = schema.metadata;
     const readResult = await readSpace(context);
@@ -222,6 +232,7 @@ export async function validateFile(filePath, config) {
     // Pre-extract valid types for early type validation
     const validTypes = Array.isArray(schema.oneOf) ? extractEntityInfo(schema, schemaRefRegistry).map((e) => e.type) : [];
     const errors = {};
+    const warnings = {};
     // Schema validation errors for this node
     for (const node of nodes) {
         if (node.label !== label)
@@ -232,6 +243,8 @@ export async function validateFile(filePath, config) {
             errors[`schema:type:${validTypes.join(',')}`] = {
                 kind: 'schema',
                 message: `Invalid type "${nodeType}". Valid types are: ${validTypes.sort().join(', ')}`,
+                ...(node.source?.line !== undefined ? { line: node.source.line } : {}),
+                ...(node.source?.column !== undefined ? { column: node.source.column } : {}),
             };
             continue;
         }
@@ -239,7 +252,12 @@ export async function validateFile(filePath, config) {
         if (!valid) {
             const formatted = formatErrors(schemaValidator.errors ?? [], schema, schemaRefRegistry, node.schemaData);
             for (const { message, dedupeKey } of formatted) {
-                errors[`schema:${dedupeKey}`] = { kind: 'schema', message };
+                errors[`schema:${dedupeKey}`] = {
+                    kind: 'schema',
+                    message,
+                    ...(node.source?.line !== undefined ? { line: node.source.line } : {}),
+                    ...(node.source?.column !== undefined ? { column: node.source.column } : {}),
+                };
             }
         }
     }
@@ -271,12 +289,27 @@ export async function validateFile(filePath, config) {
             errors[`hierarchy:${v.description}`] = { kind: 'hierarchy', message: v.description };
         }
     }
-    // Rule violations for this node
+    // Rule violations for this node — only error severity counts as an error
     if (metadata.rules) {
         const ruleViolations = await validateRules(nodes, metadata.rules);
         for (const v of ruleViolations) {
             if (v.file === label) {
-                errors[`rule:${v.ruleId}`] = { kind: 'rule', message: `[${v.ruleId}] ${v.description}` };
+                const target = v.severity === 'error' ? errors : warnings;
+                target[`rule:${v.ruleId}`] = { kind: 'rule', message: `[${v.ruleId}] ${v.description}`, severity: v.severity };
+            }
+        }
+    }
+    // Unresolved content links for this node (warnings — do not affect errorCount)
+    const targetNode = nodes.find((n) => n.label === label);
+    if (targetNode) {
+        const seen = new Set();
+        for (const link of targetNode.resolvedLinks) {
+            if (link.location === 'internal' && !seen.has(link.target)) {
+                seen.add(link.target);
+                warnings[`content-link:${link.target}`] = {
+                    kind: 'content-link',
+                    message: `Unresolved content link: ${link.target}`,
+                };
             }
         }
     }
@@ -286,6 +319,8 @@ export async function validateFile(filePath, config) {
         space: space.name,
         errors,
         errorCount: Object.keys(errors).length,
+        warnings,
+        warningCount: Object.keys(warnings).length,
         inSpace: true,
     };
 }