structured-context 0.13.0 → 0.14.0

package/dist/read/resolve-graph-edges.js

@@ -31,11 +31,11 @@ function resolveEdge(nodesByType, targetIndex, edge, source, hierarchy, selfRef,
     const { type: rawChildType, parent: rawParentType, field, fieldOn, multiple } = edge;
     const childType = resolveNodeType(rawChildType, typeAliases);
     const parentType = resolveNodeType(rawParentType, typeAliases);
-    function pushParentRef(childNode, parentTitle) {
-        // Deduplicate by (field, title) — same parent via different fields is intentional
-        if (!childNode.resolvedParents.some((r) => r.field === field && r.title === parentTitle)) {
+    function pushParentRef(childNode, parentId) {
+        // Deduplicate by (field, id) — same parent via different fields is intentional
+        if (!childNode.resolvedParents.some((r) => r.field === field && r.id === parentId)) {
             childNode.resolvedParents.push({
-                title: parentTitle,
+                id: parentId,
                 field,
                 fieldOn,
                 source,
@@ -47,7 +47,7 @@ function resolveEdge(nodesByType, targetIndex, edge, source, hierarchy, selfRef,
     function checkShape(ownerNode, rawField) {
         if (multiple && !Array.isArray(rawField)) {
             unresolvedRefs.push({
-                label: ownerNode.label,
+                id: ownerNode.id,
                 ref: String(rawField),
                 field,
                 reason: 'invalid_shape',
@@ -57,7 +57,7 @@ function resolveEdge(nodesByType, targetIndex, edge, source, hierarchy, selfRef,
         }
         if (!multiple && typeof rawField !== 'string') {
             unresolvedRefs.push({
-                label: ownerNode.label,
+                id: ownerNode.id,
                 ref: String(rawField),
                 field,
                 reason: 'invalid_shape',
@@ -73,7 +73,7 @@ function resolveEdge(nodesByType, targetIndex, edge, source, hierarchy, selfRef,
         const resolved = targetIndex.get(target);
         if (resolved === undefined) {
             unresolvedRefs.push({
-                label: ownerNode.label,
+                id: ownerNode.id,
                 ref,
                 field,
                 reason: 'not_found',
@@ -84,7 +84,7 @@ function resolveEdge(nodesByType, targetIndex, edge, source, hierarchy, selfRef,
         }
         if (resolved === null) {
             unresolvedRefs.push({
-                label: ownerNode.label,
+                id: ownerNode.id,
                 ref,
                 field,
                 reason: 'ambiguous',
@@ -109,10 +109,7 @@ function resolveEdge(nodesByType, targetIndex, edge, source, hierarchy, selfRef,
                 const childNode = checkAndRecordRef(parentNode, ref);
                 if (!childNode)
                     continue;
-                const parentTitle = parentNode.schemaData.title;
-                if (typeof parentTitle !== 'string')
-                    continue;
-                pushParentRef(childNode, parentTitle);
+                pushParentRef(childNode, parentNode.id);
             }
         }
     }
@@ -129,10 +126,7 @@ function resolveEdge(nodesByType, targetIndex, edge, source, hierarchy, selfRef,
                 const parentNode = checkAndRecordRef(childNode, ref);
                 if (!parentNode)
                     continue;
-                const parentTitle = parentNode.schemaData.title;
-                if (typeof parentTitle !== 'string')
-                    continue;
-                pushParentRef(childNode, parentTitle);
+                pushParentRef(childNode, parentNode.id);
             }
         }
     }
@@ -237,12 +231,12 @@ export function resolveGraphEdges(nodes, metadata) {
     for (const node of spaceNodes) {
         node.resolvedLinks = (node.contentLinks ?? []).map((link) => classifyContentLink(link, targetIndex));
     }
-    // Deduplicate by (label, field, ref) — the same broken link may be encountered across
+    // Deduplicate by (id, field, ref) — the same broken link may be encountered across
     // multiple resolveEdge calls (e.g. selfRef + regular hierarchy share the same field).
     const seen = new Set();
     const deduped = [];
     for (const u of unresolvedRefs) {
-        const key = `${u.label}\0${u.field}\0${u.ref}`;
+        const key = `${u.id}\0${u.field}\0${u.ref}`;
         if (!seen.has(key)) {
             seen.add(key);
             deduped.push(u);

package/dist/render/render.d.ts

@@ -1,4 +1,4 @@
-import { type RenderResult } from '../plugins/util.js';
+import { type RenderResult } from '../plugins/util';
 import type { SpaceContext } from '../types';
 export declare function executeRender(formatName: string, context: SpaceContext, options: {
     filter?: string;

package/dist/render/render.js

@@ -1,7 +1,7 @@
-import { shortenPluginName } from '../plugins/util.js';
 import { updateSpaceField } from '../config';
 import { assembleSpaceGraph } from '../load-space-graph';
 import { loadPlugins } from '../plugins/loader';
+import { shortenPluginName } from '../plugins/util';
 import { buildFormatRegistry } from './registry';
 export async function executeRender(formatName, context, options) {
     const pluginMap = context.space?.plugins ?? {};

package/dist/schema/evaluate-rule.d.ts

@@ -1,4 +1,4 @@
-import type { Rule, RuleViolation, SpaceNode } from '../types';
+import type { NodeId, Rule, RuleViolation, SpaceNode } from '../types';
 /** Evaluation context for JSONata expressions */
 export interface EvalContext {
     /** All nodes in the space (flattened) */
@@ -37,10 +37,10 @@ export declare function tryEvaluateExpression(expr: string, context: EvalContext
  *
  * @param node - The node to build context for
  * @param allNodes - All nodes in the space
- * @param nodeIndex - Map of node titles to nodes for efficient lookup
+ * @param nodeIndex - Map of node ids to nodes for efficient lookup
  * @returns Evaluation context for the node
  */
-export declare function buildEvalContext(node: SpaceNode, allNodes: SpaceNode[], nodeIndex: Map<string, SpaceNode>): EvalContext;
+export declare function buildEvalContext(node: SpaceNode, allNodes: SpaceNode[], nodeIndex: Map<NodeId, SpaceNode>): EvalContext;
 /** The violation reported when a rule's `expression` or `when` cannot be evaluated: an authoring error, so always `error`. */
 export declare function expressionErrorViolation(rule: Rule, file: string, error: string): RuleViolation;
 /** The outcome of a rule's `expression` on one node. */
@@ -58,4 +58,4 @@ export type ExpressionRuleResult = {
  * reports the rule's severity; a rule with a semantic part names the expression in the evidence, so the
  * violation is not mistaken for a verdict. An evaluation error reports `error` and is not a `failed` result.
  */
-export declare function evaluateRuleExpression(rule: Rule, node: SpaceNode, allNodes: SpaceNode[], nodeIndex: Map<string, SpaceNode>, file?: string): Promise<ExpressionRuleResult>;
+export declare function evaluateRuleExpression(rule: Rule, node: SpaceNode, allNodes: SpaceNode[], nodeIndex: Map<NodeId, SpaceNode>, file?: string): Promise<ExpressionRuleResult>;

package/dist/schema/evaluate-rule.js

@@ -64,12 +64,16 @@ export async function tryEvaluateExpression(expr, context) {
  * @param node - The node to flatten
  * @returns Flattened node with properties directly accessible
  */
-function flattenNode(node) {
+function flattenNode(node, nodeIndex) {
+    const parentTitle = (r) => nodeIndex.get(r.id)?.title ?? r.id;
     return {
         ...node.schemaData,
+        id: node.id,
         resolvedType: node.resolvedType,
-        resolvedParentTitle: node.resolvedParents[0]?.title, // first parent or undefined, provided for convenience
-        resolvedParentTitles: node.resolvedParents.map((r) => r.title), // full array of parent titles
+        resolvedParentId: node.resolvedParents[0]?.id, // first parent or undefined, provided for convenience
+        resolvedParentIds: node.resolvedParents.map((r) => r.id), // full array of parent ids
+        resolvedParentTitle: node.resolvedParents[0] && parentTitle(node.resolvedParents[0]), // display title of the first parent
+        resolvedParentTitles: node.resolvedParents.map(parentTitle), // display titles of all parents
         resolvedLinks: node.resolvedLinks,
     };
 }
@@ -78,23 +82,23 @@ function flattenNode(node) {
  *
  * @param node - The node to build context for
  * @param allNodes - All nodes in the space
- * @param nodeIndex - Map of node titles to nodes for efficient lookup
+ * @param nodeIndex - Map of node ids to nodes for efficient lookup
  * @returns Evaluation context for the node
  */
 export function buildEvalContext(node, allNodes, nodeIndex) {
     // Flatten all nodes for JSONata access
-    const flattenedNodes = allNodes.map(flattenNode);
+    const flattenedNodes = allNodes.map((n) => flattenNode(n, nodeIndex));
     // Build all parent objects from resolvedParents array
     const flattenedParents = [];
-    for (const { title: parentTitle } of node.resolvedParents) {
-        const parentNode = nodeIndex.get(parentTitle);
+    for (const { id: parentId } of node.resolvedParents) {
+        const parentNode = nodeIndex.get(parentId);
         if (parentNode) {
-            flattenedParents.push(flattenNode(parentNode));
+            flattenedParents.push(flattenNode(parentNode, nodeIndex));
         }
     }
     return {
         nodes: flattenedNodes,
-        $$: flattenNode(node),
+        $$: flattenNode(node, nodeIndex),
         parent: flattenedParents[0],
         parents: flattenedParents.length > 0 ? flattenedParents : undefined,
     };
@@ -114,7 +118,7 @@ export function expressionErrorViolation(rule, file, error) {
  * reports the rule's severity; a rule with a semantic part names the expression in the evidence, so the
  * violation is not mistaken for a verdict. An evaluation error reports `error` and is not a `failed` result.
  */
-export async function evaluateRuleExpression(rule, node, allNodes, nodeIndex, file = node.label) {
+export async function evaluateRuleExpression(rule, node, allNodes, nodeIndex, file = node.id) {
     const expression = rule.expression;
     const outcome = await tryEvaluateExpression(expression, buildEvalContext(node, allNodes, nodeIndex));
     if ('error' in outcome) {

package/dist/schema/gating.d.ts

@@ -1,10 +1,10 @@
 import type { TrimReport } from '../judge/trim';
 import type { SemanticJudgeProvider } from '../judge/types';
 import type { SpaceGraph } from '../space-graph';
-import type { Rule, RuleSeverity, RuleViolation, SpaceNode } from '../types';
+import type { NodeId, Rule, RuleSeverity, RuleViolation, SpaceNode } from '../types';
 /**
- * Whether a failure of this rule gates its subtree: explicit `gatesDescendants`, else true only for `error` severity.
- * `severity` is that of the failure: the rule's own for an expression, the verdict's for a semantic part.
+ * Whether a violation of this rule gates its subtree: explicit `gatesDescendants`, else true only for `error` severity.
+ * `severity` is that of the violation: the rule's own for an expression, the verdict's for a semantic part.
  */
 export declare function ruleGatesDescendants(rule: Rule, severity?: RuleSeverity): boolean;
 /**
@@ -12,10 +12,10 @@ export declare function ruleGatesDescendants(rule: Rule, severity?: RuleSeverity
  * (schema validation or hierarchy structure) that failed on a specific node.
  */
 export type GatingSeed = {
-    /** Label (file) of the failing node. */
+    /** Id (file) of the failing node. */
     file: string;
-    /** Title of the failing node. */
-    title: string;
+    /** Id of the failing node. */
+    id: NodeId;
     /** Which always-run layer produced the failure. */
     reason: 'schema' | 'hierarchy';
 };
@@ -24,10 +24,10 @@ export type GatingSeed = {
  * rule evaluation for itself (if schema/hierarchy caused it) and/or its hierarchy subtree.
  */
 export type CoverageGate = {
-    /** Label (file) of the node whose failure triggered this gate. */
+    /** Id (file) of the node whose failure triggered this gate. */
     file: string;
-    /** Title of the blocking node. */
-    nodeTitle: string;
+    /** Id of the blocking node. */
+    nodeId: NodeId;
     /** What kind of check triggered the gate. */
     reason: 'schema' | 'hierarchy' | 'rule';
     /** Rule id responsible, when `reason` is `'rule'`. */
@@ -56,7 +56,7 @@ export interface GatingOptions {
  * Compute breadth-first depth (1-based, from hierarchy roots and orphans) for every
  * hierarchy-typed node in the graph. Non-hierarchy nodes are not included.
  */
-export declare function computeHierarchyDepths(graph: SpaceGraph): Map<string, number>;
+export declare function computeHierarchyDepths(graph: SpaceGraph): Map<NodeId, number>;
 /**
  * Evaluate executable rules with cascade gating: a schema, hierarchy, or blocking-rule
  * failure on a node suppresses rule evaluation for that node (when the failure is

package/dist/schema/gating.js

@@ -2,8 +2,8 @@ import { judgeNodes } from '../judge/judge-node';
 import { buildEvalContext, evaluateRuleExpression, expressionErrorViolation, tryEvaluateExpression, } from './evaluate-rule';
 import { ruleSeverities, ruleSeverity } from './rule-severity';
 /**
- * Whether a failure of this rule gates its subtree: explicit `gatesDescendants`, else true only for `error` severity.
- * `severity` is that of the failure: the rule's own for an expression, the verdict's for a semantic part.
+ * Whether a violation of this rule gates its subtree: explicit `gatesDescendants`, else true only for `error` severity.
+ * `severity` is that of the violation: the rule's own for an expression, the verdict's for a semantic part.
  */
 export function ruleGatesDescendants(rule, severity = ruleSeverity(rule)) {
     return rule.gatesDescendants ?? severity === 'error';
@@ -20,17 +20,17 @@ export function computeHierarchyDepths(graph) {
     const depths = new Map();
     const queue = [];
     for (const node of [...graph.hierarchyRoots, ...graph.orphans]) {
-        queue.push({ title: node.title, depth: 1 });
+        queue.push({ id: node.id, depth: 1 });
     }
     let i = 0;
     while (i < queue.length) {
-        const { title, depth } = queue[i++];
-        if (depths.has(title))
+        const { id, depth } = queue[i++];
+        if (depths.has(id))
             continue;
-        depths.set(title, depth);
-        for (const child of graph.hierarchyChildren.get(title) ?? []) {
-            if (!depths.has(child.title))
-                queue.push({ title: child.title, depth: depth + 1 });
+        depths.set(id, depth);
+        for (const child of graph.hierarchyChildren.get(id) ?? []) {
+            if (!depths.has(child.id))
+                queue.push({ id: child.id, depth: depth + 1 });
         }
     }
     return depths;
@@ -48,24 +48,24 @@ export async function evaluateRulesWithGating(nodes, rules, graph, seeds, option
     const includeGated = options.includeGated ?? false;
     const nodeIndex = new Map();
     for (const node of nodes) {
-        if (node.title)
-            nodeIndex.set(node.title, node);
+        if (node.id)
+            nodeIndex.set(node.id, node);
     }
     // When a node has both a schema and hierarchy failure, report schema as the reason.
-    const seedByTitle = new Map();
+    const seedById = new Map();
     for (const seed of seeds) {
-        if (!seedByTitle.has(seed.title) || seed.reason === 'schema') {
-            seedByTitle.set(seed.title, seed);
+        if (!seedById.has(seed.id) || seed.reason === 'schema') {
+            seedById.set(seed.id, seed);
         }
     }
     const judge = options.provider;
     const violations = [];
     const gateOrigins = new Map();
-    function originFor(title, seed) {
-        let origin = gateOrigins.get(title);
+    function originFor(id, seed) {
+        let origin = gateOrigins.get(id);
         if (!origin) {
-            origin = { file: seed.file, nodeTitle: title, reason: seed.reason, ruleId: seed.ruleId, gatedFiles: [] };
-            gateOrigins.set(title, origin);
+            origin = { file: seed.file, nodeId: id, reason: seed.reason, ruleId: seed.ruleId, gatedFiles: [] };
+            gateOrigins.set(id, origin);
         }
         return origin;
     }
@@ -85,10 +85,10 @@ export async function evaluateRulesWithGating(nodes, rules, graph, seeds, option
         const parentsOf = new Map();
         for (const [parent, children] of graph.hierarchyChildren) {
             for (const child of children)
-                parentsOf.set(child.title, [...(parentsOf.get(child.title) ?? []), parent]);
+                parentsOf.set(child.id, [...(parentsOf.get(child.id) ?? []), parent]);
         }
-        const target = nodes.find((n) => n.label === options.judgeTarget);
-        const pending = target ? [target.title] : [];
+        const target = nodes.find((n) => n.id === options.judgeTarget);
+        const pending = target ? [target.id] : [];
         while (pending.length > 0) {
             for (const parent of parentsOf.get(pending.pop()) ?? []) {
                 if (!targetAncestors.has(parent)) {
@@ -104,12 +104,9 @@ export async function evaluateRulesWithGating(nodes, rules, graph, seeds, option
         for (const r of perNodeRules) {
             if (r.type && r.type !== node.resolvedType)
                 continue;
-            if (judge &&
-                r.semantic !== undefined &&
-                options.judgeTarget !== undefined &&
-                node.label !== options.judgeTarget) {
+            if (judge && r.semantic !== undefined && options.judgeTarget !== undefined && node.id !== options.judgeTarget) {
                 // Ancestors only matter through the gates they could raise.
-                if (!(targetAncestors.has(node.title) && ruleCanGate(r)))
+                if (!(targetAncestors.has(node.id) && ruleCanGate(r)))
                     continue;
             }
             if (r.when) {
@@ -128,11 +125,11 @@ export async function evaluateRulesWithGating(nodes, rules, graph, seeds, option
     async function prepareNode(node) {
         const local = [];
         const prepared = { violations: local, semantic: [], judged: () => { } };
-        const applicable = await applicableRules(node, (rule, error) => local.push(expressionErrorViolation(rule, node.label, error)));
+        const applicable = await applicableRules(node, (rule, error) => local.push(expressionErrorViolation(rule, node.id, error)));
         function report(rule, detail = {}) {
             const severity = detail.severity ?? ruleSeverities(rule)[0] ?? ruleSeverity(rule);
             local.push({
-                file: node.label,
+                file: node.id,
                 ruleId: rule.id,
                 category: rule.category,
                 severity,
@@ -148,7 +145,9 @@ export async function evaluateRulesWithGating(nodes, rules, graph, seeds, option
                 prepared.blockingRuleId = rule.id;
             }
         }
-        // Cheap expressions first; a semantic part is only evaluated when its own expression passes.
+        // Cheap expressions first. A semantic part is evaluated only when its own expression passes, and not at all
+        // on a node with a gating violation.
+        const semantic = [];
         for (const rule of applicable) {
             if (rule.expression !== undefined) {
                 const result = await evaluateRuleExpression(rule, node, nodes, nodeIndex);
@@ -161,11 +160,13 @@ export async function evaluateRulesWithGating(nodes, rules, graph, seeds, option
                 }
             }
             if (rule.semantic !== undefined && judge)
-                prepared.semantic.push(rule);
+                semantic.push(rule);
         }
+        if (!prepared.blockingRuleId)
+            prepared.semantic = semantic;
         prepared.judged = (judgements) => {
             for (const j of judgements) {
-                if (j.failed) {
+                if (j.violated) {
                     report(j.rule, {
                         severity: j.severity,
                         verdict: j.verdict,
@@ -209,38 +210,38 @@ export async function evaluateRulesWithGating(nodes, rules, graph, seeds, option
     while (depthNodes.length > 0) {
         const current = [];
         for (const entry of depthNodes) {
-            if (visited.has(entry.node.title))
+            if (visited.has(entry.node.id))
                 continue;
-            visited.add(entry.node.title);
+            visited.add(entry.node.id);
             current.push(entry);
         }
-        const isGated = (e) => e.ancestorOrigin !== undefined || seedByTitle.has(e.node.title);
+        const isGated = (e) => e.ancestorOrigin !== undefined || seedById.has(e.node.id);
         const toEvaluate = current.filter((e) => !isGated(e) || includeGated);
         const evaluated = await evaluateNodeSet(toEvaluate.map((e) => e.node));
-        const blockingByTitle = new Map(toEvaluate.map((e, i) => [e.node.title, evaluated[i].blockingRuleId]));
+        const blockingById = new Map(toEvaluate.map((e, i) => [e.node.id, evaluated[i].blockingRuleId]));
         const next = [];
         for (const { node, ancestorOrigin } of current) {
-            const selfSeed = seedByTitle.get(node.title);
+            const selfSeed = seedById.get(node.id);
             const isGatedByAncestor = ancestorOrigin !== undefined;
             const isSelfBlocked = selfSeed !== undefined;
-            const blockingRuleId = blockingByTitle.get(node.title);
+            const blockingRuleId = blockingById.get(node.id);
             let childOrigin = ancestorOrigin;
             if (isGatedByAncestor) {
-                gateOrigins.get(ancestorOrigin).gatedFiles.push(node.label);
+                gateOrigins.get(ancestorOrigin).gatedFiles.push(node.id);
             }
             else if (isSelfBlocked) {
-                const origin = originFor(node.title, { file: selfSeed.file, reason: selfSeed.reason });
-                origin.gatedFiles.push(node.label);
-                childOrigin = node.title;
+                const origin = originFor(node.id, { file: selfSeed.file, reason: selfSeed.reason });
+                origin.gatedFiles.push(node.id);
+                childOrigin = node.id;
             }
             else if (blockingRuleId) {
-                originFor(node.title, { file: node.label, reason: 'rule', ruleId: blockingRuleId });
-                childOrigin = node.title;
+                originFor(node.id, { file: node.id, reason: 'rule', ruleId: blockingRuleId });
+                childOrigin = node.id;
             }
             else {
                 childOrigin = undefined;
             }
-            for (const child of graph.hierarchyChildren.get(node.title) ?? []) {
+            for (const child of graph.hierarchyChildren.get(node.id) ?? []) {
                 next.push({ node: child, ancestorOrigin: childOrigin });
             }
         }

package/dist/schema/validate-graph.js

@@ -5,7 +5,7 @@ import { resolveNodeType } from '../schema/schema';
  */
 export function validateGraph(nodes, metadata, unresolvedRefs = []) {
     const refErrors = unresolvedRefs.map((u) => ({
-        file: u.source?.file ?? u.label,
+        file: u.source?.file ?? u.id,
         ...(u.source?.line !== undefined ? { line: u.source.line } : {}),
         parent: u.ref,
         error: u.message,
@@ -69,20 +69,17 @@ export function validateHierarchyStructure(nodes, metadata) {
         }
     }
     const nodeIndex = new Map();
-    for (const node of nodes) {
-        const title = node.title;
-        if (title)
-            nodeIndex.set(title, node);
-    }
+    for (const node of nodes)
+        nodeIndex.set(node.id, node);
     for (const node of nodes) {
         const nodeType = node.resolvedType;
         const nodeTitle = node.title;
         for (const parentRef of node.resolvedParents) {
-            const parentNode = nodeIndex.get(parentRef.title);
+            const parentNode = nodeIndex.get(parentRef.id);
             if (!parentNode)
                 continue;
             const parentType = parentNode.resolvedType;
-            const parentTitle = parentRef.title;
+            const parentTitle = parentNode.title;
             if (parentRef.fieldOn === 'parent') {
                 // Field is on the parent node; validate that this node's type matches the expected child type.
                 // Violation is attributed to the field-owner (parent) node.
@@ -90,7 +87,7 @@ export function validateHierarchyStructure(nodes, metadata) {
                 if (allowedChildTypes && !allowedChildTypes.has(nodeType)) {
                     const expected = [...allowedChildTypes].join(' or ');
                     violations.push({
-                        file: parentNode.label,
+                        file: parentNode.id,
                         nodeType: parentType,
                         nodeTitle: parentTitle,
                         parentType: nodeType,
@@ -105,7 +102,7 @@ export function validateHierarchyStructure(nodes, metadata) {
                 if (allowedTypes && !allowedTypes.has(parentType)) {
                     const expected = [...allowedTypes].join(' or ');
                     violations.push({
-                        file: node.label,
+                        file: node.id,
                         nodeType,
                         nodeTitle,
                         parentType,
@@ -143,7 +140,7 @@ export function validateHierarchyStructure(nodes, metadata) {
                 }
                 if (!isValidHierarchy) {
                     violations.push({
-                        file: node.label,
+                        file: node.id,
                         nodeType,
                         nodeTitle,
                         parentType,

package/dist/schema/validate-rules.d.ts

@@ -1,14 +1,14 @@
 import type { TrimReport } from '../judge/trim';
 import type { SemanticJudgeProvider } from '../judge/types';
-import type { Rule, RuleViolation, SpaceNode } from '../types';
+import type { NodeId, Rule, RuleViolation, SpaceNode } from '../types';
 export { DEFAULT_SEVERITY_BY_CATEGORY, ruleSeverity } from './rule-severity';
 export interface ValidateRulesOptions {
     /** Evaluates semantic rules. Without one, a rule runs only its `expression`, and a semantic-only rule is skipped. */
     judge?: SemanticJudgeProvider;
-    /** Label of the only node to judge (`validate-file`); other nodes' semantic rules are skipped. */
+    /** Id of the only node to judge (`validate-file`); other nodes' semantic rules are skipped. */
     judgeTarget?: string;
-    /** Set of node labels that have already failed upstream structural checks. */
-    gatedNodeLabels?: Set<string>;
+    /** Set of node ids that have already failed upstream structural checks. */
+    gatedNodeIds?: Set<NodeId>;
     trimReport?: TrimReport;
 }
 /**

package/dist/schema/validate-rules.js

@@ -1,6 +1,7 @@
 import { judgeNodes } from '../judge/judge-node';
 import { buildSpaceGraph } from '../space-graph';
 import { buildEvalContext, evaluateRuleExpression, expressionErrorViolation, tryEvaluateExpression, } from './evaluate-rule';
+import { ruleGatesDescendants } from './gating';
 import { ruleSeverities, ruleSeverity } from './rule-severity';
 export { DEFAULT_SEVERITY_BY_CATEGORY, ruleSeverity } from './rule-severity';
 /**
@@ -18,10 +19,7 @@ export async function validateRules(nodes, rules, options = {}) {
     // Build node index for efficient lookups
     const nodeIndex = new Map();
     for (const node of nodes) {
-        const title = node.title;
-        if (title) {
-            nodeIndex.set(title, node);
-        }
+        nodeIndex.set(node.id, node);
     }
     const sentinel = nodes[0];
     const runnable = rules.filter((r) => r.expression !== undefined || (r.semantic !== undefined && judge));
@@ -37,7 +35,7 @@ export async function validateRules(nodes, rules, options = {}) {
             if (rule.when) {
                 const when = await tryEvaluateExpression(rule.when, buildEvalContext(node, nodes, nodeIndex));
                 if ('error' in when) {
-                    violations.push(expressionErrorViolation(rule, node.label, when.error));
+                    violations.push(expressionErrorViolation(rule, node.id, when.error));
                     continue;
                 }
                 if (when.value !== true)
@@ -49,8 +47,8 @@ export async function validateRules(nodes, rules, options = {}) {
     }
     // 1. Expressions, in rule order. A global rule is evaluated once against the full node set; a sentinel node
     // provides the evaluation context (the nodes array is what matters).
-    const failedNodeLabels = new Set(options.gatedNodeLabels); // nodes that failed an expression (or upstream)
-    const notEvaluable = new Set(); // `${rule.id}\0${label}` whose own expression failed or errored
+    const gatedNodeIds = new Set(options.gatedNodeIds); // nodes with a gating violation (or gated upstream)
+    const notEvaluable = new Set(); // `${rule.id}\0${id}` whose own expression failed or errored
     for (const rule of runnable) {
         if (rule.expression === undefined)
             continue;
@@ -67,24 +65,24 @@ export async function validateRules(nodes, rules, options = {}) {
             if (result.passed)
                 continue;
             violations.push(result.violation);
-            notEvaluable.add(`${rule.id}\0${node.label}`);
-            if (result.failed)
-                failedNodeLabels.add(node.label);
+            notEvaluable.add(`${rule.id}\0${node.id}`);
+            if (result.failed && ruleGatesDescendants(rule, result.violation.severity))
+                gatedNodeIds.add(node.id);
         }
     }
-    // 2. Semantic parts, for nodes that passed their own expression. A node that failed an expression or
-    // upstream is left out (safe cascading default).
+    // 2. Semantic parts, for nodes that passed their own expression. A node with a gating violation, or gated
+    // upstream, is left out.
     if (judge) {
         const perNode = []; // kept in node order
         const pending = [];
         for (const node of nodes) {
-            if (options.judgeTarget !== undefined && node.label !== options.judgeTarget)
+            if (options.judgeTarget !== undefined && node.id !== options.judgeTarget)
                 continue;
             const found = [];
             perNode.push(found);
-            if (failedNodeLabels.has(node.label))
+            if (gatedNodeIds.has(node.id))
                 continue;
-            const semantic = runnable.filter((r) => r.semantic !== undefined && applicable.get(r)?.includes(node) && !notEvaluable.has(`${r.id}\0${node.label}`));
+            const semantic = runnable.filter((r) => r.semantic !== undefined && applicable.get(r)?.includes(node) && !notEvaluable.has(`${r.id}\0${node.id}`));
             if (semantic.length > 0)
                 pending.push({ node, rules: semantic, found });
         }
@@ -92,10 +90,10 @@ export async function validateRules(nodes, rules, options = {}) {
         const judged = await judgeNodes(judge, pending, buildSpaceGraph(nodes, undefined), options.trimReport);
         pending.forEach(({ node, found }, i) => {
             for (const j of judged[i] ?? []) {
-                if (!j.failed)
+                if (!j.violated)
                     continue;
                 found.push({
-                    file: node.label,
+                    file: node.id,
                     ruleId: j.rule.id,
                     category: j.rule.category,
                     severity: j.severity ?? ruleSeverities(j.rule)[0] ?? ruleSeverity(j.rule),

package/dist/schemas/_ost_strict.json

@@ -34,7 +34,7 @@
         "category": "best-practice",
         "description": "Explore multiple candidate solutions (aim for at least three) for the target opportunity",
         "type": "opportunity",
-        "expression": "(current.status != 'exploring' and current.status != 'active') or $count(nodes[resolvedParentTitle=$$.current.title and resolvedType='solution']) >= 3"
+        "expression": "(current.status != 'exploring' and current.status != 'active') or $count(nodes[resolvedParentId=$$.current.id and resolvedType='solution']) >= 3"
       },
       {
         "id": "opportunity-customer-voice",

package/dist/space-context.d.ts

@@ -1,5 +1,5 @@
-import { type Config } from './config.js';
-import type { SpaceContext } from './types.js';
+import { type Config } from './config';
+import type { SpaceContext } from './types';
 /** Thrown by createSpaceContext when no space matches the given name. */
 export declare class SpaceNotFoundError extends Error {
     readonly spaceName: string;

package/dist/space-context.js

@@ -1,6 +1,6 @@
-import { resolveSchema } from './config.js';
-import { resolveSpacePluginSchemas } from './plugins/util.js';
-import { loadSchema } from './schema/schema.js';
+import { resolveSchema } from './config';
+import { resolveSpacePluginSchemas } from './plugins/util';
+import { loadSchema } from './schema/schema';
 /** Thrown by createSpaceContext when no space matches the given name. */
 export class SpaceNotFoundError extends Error {
     spaceName;