structured-context 0.13.0 → 0.14.0

package/README.md

@@ -27,7 +27,7 @@ Content and structure
   Valid                                   16
   Schema validation errors                 0
   Broken links                             1
-  Duplicate keys                           0
+  Duplicate ids                            0
   Rule violations (error)                  0
   Rule violations (warning)                1
   Rule violations (info)                   1
@@ -138,7 +138,7 @@ Validates markdown files against the JSON schema:
 - Extracts YAML frontmatter from each `.md` file
 - Skips files without frontmatter or without a `type` field
 - Reports validation results with counts and per-file errors
-- Runs executable rules (`$metadata.rules`) with **cascade gating**: a schema, hierarchy, or blocking-rule failure on a node suppresses rule evaluation for that node's hierarchy subtree. Gated rules are reported in a Coverage section so you know what wasn't evaluated and why. See [docs/rules.md](docs/rules.md#cascade-gating) for details.
+- Runs executable rules (`$metadata.rules`) with **cascade gating**: a schema, hierarchy or gating rule violation on a node suppresses rule evaluation for that node's hierarchy subtree. Gated rules are reported in a Coverage section so you know what wasn't evaluated and why. See [docs/rules.md](docs/rules.md#cascade-gating) for details.
 - `--depth <n>` limits evaluation to hierarchy nodes within `n` breadth-first levels from the top — useful for staged agentic fix loops (fix the top level, then request the next).
 - `--include-gated` evaluates rules even on gated nodes (still reported as gated) — for surfacing cheap bottom-up checks on request.
 - `--semantic` also evaluates the `semantic` part of rules with the configured model provider (Jev, Anthropic or OpenAI-compatible); `--semantic <provider>` uses that configured model provider instead; `--rule-filter` narrows which rules run. See [docs/semantic-rules.md](docs/semantic-rules.md) (`sctx docs semantic-rules`).

package/dist/api.d.ts

@@ -3,8 +3,8 @@
  *
  * Import from this module to use structured-context as a library:
  *
- *   import { loadConfig, loadSpaceGraph, validateSpace, validateFile } from './api.js';
- *   import type { StructuredContextPlugin, PluginContext, ParseResult } from './api.js';
+ *   import { loadConfig, loadSpaceGraph, validateSpace, validateFile } from 'structured-context/api';
+ *   import type { StructuredContextPlugin, PluginContext, ParseResult } from 'structured-context/api';
  *
  * Common patterns:
  *
@@ -18,18 +18,18 @@
  *   const validation = await validateSpace(ctx, { readResult });
  */
 export type { AnySchemaObject, SchemaObject, ValidateFunction } from 'ajv';
-export type { Config, SpaceConfig } from './config.js';
-export { loadConfig, resolveSchema, resolveSchemaPath, setConfigPath } from './config.js';
-export { PLUGIN_PREFIX } from './constants.js';
-export { assembleSpaceGraph, loadSpaceGraph } from './load-space-graph.js';
-export type { ParseHook, ParseResult, PluginContext, RenderFileOutput, RenderFormat, RenderHook, RenderMultiFileOutput, RenderOptions, RenderResult, StructuredContextPlugin, TemplateSyncHook, TemplateSyncOptions, } from './plugins/util.js';
-export { isRenderMultiFileOutput, resolvePluginDir, resolvePluginSchemasDir, resolveSpacePluginSchemas, } from './plugins/util.js';
-export { readSpace } from './read/read-space.js';
-export { buildTargetIndex, formatWikilink, type ParsedWikilink, parseWikilink, wikilinkToTarget, } from './read/wikilink-utils.js';
-export type { SharedEmbeddingFields } from './schema/metadata-contract.js';
-export { bundledSchemasDir, loadSchema, type PluginSchemaSource, setBundledSchemasDir } from './schema/schema.js';
-export { createSpaceContext, SpaceNotFoundError } from './space-context.js';
-export { buildSpaceGraph, type SpaceGraph } from './space-graph.js';
-export type { BaseNode, ContentLink, EdgeDefinition, FileNotInSpaceResult, FileValidationIssue, FileValidationResult, Hierarchy, HierarchyLevel, ParseIssue, ReadSpaceResult, Relationship, ResolvedContentLink, RuleCategory, RuleSeverity, RuleViolation, SchemaMetadata, SchemaWithMetadata, SourceLocation, SpaceContext, SpaceNode, UnresolvedRef, ValidateFileOutput, } from './types.js';
-export type { ValidationResult } from './validate.js';
-export { validateFile, validateSpace } from './validate.js';
+export type { Config, SpaceConfig } from './config';
+export { loadConfig, resolveSchema, resolveSchemaPath, setConfigPath } from './config';
+export { PLUGIN_PREFIX } from './constants';
+export { assembleSpaceGraph, loadSpaceGraph } from './load-space-graph';
+export type { ParseHook, ParseResult, PluginContext, RenderFileOutput, RenderFormat, RenderHook, RenderMultiFileOutput, RenderOptions, RenderResult, StructuredContextPlugin, TemplateSyncHook, TemplateSyncOptions, } from './plugins/util';
+export { isRenderMultiFileOutput, resolvePluginDir, resolvePluginSchemasDir, resolveSpacePluginSchemas, } from './plugins/util';
+export { readSpace } from './read/read-space';
+export { buildTargetIndex, formatWikilink, type ParsedWikilink, parseWikilink, wikilinkToTarget, } from './read/wikilink-utils';
+export type { SharedEmbeddingFields } from './schema/metadata-contract';
+export { bundledSchemasDir, loadSchema, type PluginSchemaSource, setBundledSchemasDir } from './schema/schema';
+export { createSpaceContext, SpaceNotFoundError } from './space-context';
+export { buildSpaceGraph, type SpaceGraph } from './space-graph';
+export type { BaseNode, ContentLink, EdgeDefinition, FileNotInSpaceResult, FileValidationIssue, FileValidationResult, Hierarchy, HierarchyLevel, ParseIssue, ReadSpaceResult, Relationship, ResolvedContentLink, RuleCategory, RuleSeverity, RuleViolation, SchemaMetadata, SchemaWithMetadata, SourceLocation, SpaceContext, SpaceNode, UnresolvedRef, ValidateFileOutput, } from './types';
+export type { ValidationResult } from './validate';
+export { validateFile, validateSpace } from './validate';

package/dist/api.js

@@ -3,8 +3,8 @@
  *
  * Import from this module to use structured-context as a library:
  *
- *   import { loadConfig, loadSpaceGraph, validateSpace, validateFile } from './api.js';
- *   import type { StructuredContextPlugin, PluginContext, ParseResult } from './api.js';
+ *   import { loadConfig, loadSpaceGraph, validateSpace, validateFile } from 'structured-context/api';
+ *   import type { StructuredContextPlugin, PluginContext, ParseResult } from 'structured-context/api';
  *
  * Common patterns:
  *
@@ -17,13 +17,13 @@
  *   const graph = await assembleSpaceGraph(ctx, { readResult });
  *   const validation = await validateSpace(ctx, { readResult });
  */
-export { loadConfig, resolveSchema, resolveSchemaPath, setConfigPath } from './config.js';
-export { PLUGIN_PREFIX } from './constants.js';
-export { assembleSpaceGraph, loadSpaceGraph } from './load-space-graph.js';
-export { isRenderMultiFileOutput, resolvePluginDir, resolvePluginSchemasDir, resolveSpacePluginSchemas, } from './plugins/util.js';
-export { readSpace } from './read/read-space.js';
-export { buildTargetIndex, formatWikilink, parseWikilink, wikilinkToTarget, } from './read/wikilink-utils.js';
-export { bundledSchemasDir, loadSchema, setBundledSchemasDir } from './schema/schema.js';
-export { createSpaceContext, SpaceNotFoundError } from './space-context.js';
-export { buildSpaceGraph } from './space-graph.js';
-export { validateFile, validateSpace } from './validate.js';
+export { loadConfig, resolveSchema, resolveSchemaPath, setConfigPath } from './config';
+export { PLUGIN_PREFIX } from './constants';
+export { assembleSpaceGraph, loadSpaceGraph } from './load-space-graph';
+export { isRenderMultiFileOutput, resolvePluginDir, resolvePluginSchemasDir, resolveSpacePluginSchemas, } from './plugins/util';
+export { readSpace } from './read/read-space';
+export { buildTargetIndex, formatWikilink, parseWikilink, wikilinkToTarget, } from './read/wikilink-utils';
+export { bundledSchemasDir, loadSchema, setBundledSchemasDir } from './schema/schema';
+export { createSpaceContext, SpaceNotFoundError } from './space-context';
+export { buildSpaceGraph } from './space-graph';
+export { validateFile, validateSpace } from './validate';

package/dist/commands/dump.js

@@ -11,7 +11,7 @@ export async function buildDump(context, options = {}) {
     if (!options.filter)
         return readResult;
     const graph = await assembleSpaceGraph(context, { ...options, readResult });
-    const nodes = readResult.nodes.filter((node) => graph.nodes.get(node.title) === node);
+    const nodes = readResult.nodes.filter((node) => graph.nodes.get(node.id) === node);
     return { ...readResult, nodes };
 }
 export async function dump(context, options = {}) {

package/dist/commands/validate.js

@@ -34,10 +34,10 @@ export async function validate(context, options = {}) {
         for (const { file, parent, error } of result.refErrors) {
             addError(file, `broken-link:${parent}`, 'broken-link', `${parent} → ${error}`);
         }
-        for (const { title, files } of result.duplicateErrors) {
+        for (const { id, files } of result.duplicateErrors) {
             for (const file of files) {
                 const others = files.filter((f) => f !== file);
-                addError(file, `duplicate:${title}`, 'duplicate', `Duplicate title "${title}" also exists in: ${others.join(', ')}`);
+                addError(file, `duplicate:${id}`, 'duplicate', `Duplicate id "${id}" also exists in: ${others.join(', ')}`);
             }
         }
         for (const v of result.ruleViolations) {
@@ -97,7 +97,7 @@ export async function validate(context, options = {}) {
     console.log(fmt('  Valid', result.validCount));
     console.log(fmt('  Schema validation errors', result.nodeErrorCount, true));
     console.log(fmt('  Broken links', result.refErrors.length, true));
-    console.log(fmt('  Duplicate keys', result.duplicateErrors.length, true));
+    console.log(fmt('  Duplicate ids', result.duplicateErrors.length, true));
     console.log(fmt('  Rule violations (error)', ruleCounts.error, true));
     console.log(fmt('  Rule violations (warning)', ruleCounts.warning, true, true));
     console.log(fmt('  Rule violations (info)', ruleCounts.info, true, true));
@@ -114,7 +114,7 @@ export async function validate(context, options = {}) {
     if (result.orphans.length > 0) {
         console.log(`\nOrphans (hierarchy nodes - no parent):`);
         for (const node of result.orphans)
-            console.log(`   ${node.label}`);
+            console.log(`   ${node.id}`);
     }
     if (result.unresolvedContentLinks.length > 0) {
         console.log(`\nUnresolved content links (may be outside-space or broken):`);
@@ -157,9 +157,9 @@ export async function validate(context, options = {}) {
         });
     }
     if (result.duplicateErrors.length > 0) {
-        console.log(`\nDuplicate keys (same title in multiple files):`);
-        result.duplicateErrors.forEach(({ title, files }) => {
-            console.log(`   "${title}":`);
+        console.log(`\nDuplicate ids (same id on multiple nodes):`);
+        result.duplicateErrors.forEach(({ id, files }) => {
+            console.log(`   "${id}":`);
             for (const f of files) {
                 console.log(`      ${f}`);
             }
@@ -194,7 +194,7 @@ export async function validate(context, options = {}) {
         console.log(`\nCoverage — rule checks gated by cascade (use --include-gated to evaluate anyway):`);
         for (const gate of result.coverageGates) {
             const cause = gate.reason === 'rule' ? `blocking rule "${gate.ruleId}"` : `${gate.reason} failure`;
-            console.log(`   ${gate.file} (${gate.nodeTitle}) — ${cause} gated ${gate.gatedFiles.length} node(s):`);
+            console.log(`   ${gate.file} (${gate.nodeId}) — ${cause} gated ${gate.gatedFiles.length} node(s):`);
             for (const file of gate.gatedFiles)
                 console.log(`      ${file}`);
         }

package/dist/config.d.ts

@@ -1,4 +1,4 @@
-import { type JudgeConfig, type ModelProviderConfig } from './judge/types.js';
+import { type JudgeConfig, type ModelProviderConfig } from './judge/types';
 export type SpaceConfig = {
     name: string;
     path: string;

package/dist/config.js

@@ -3,10 +3,10 @@ import { homedir } from 'node:os';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
 import Ajv2020 from 'ajv/dist/2020';
 import JSON5 from 'json5';
-import { ENV_CONFIG_VAR, XDG_CONFIG_DIR } from './constants.js';
-import { MODEL_PROVIDER_APIS } from './judge/types.js';
-import { normalizePluginName, resolvePluginSchemasDir, resolveSpacePluginSchemas, shortenPluginName, } from './plugins/util.js';
-import { bundledSchemasDir } from './schema/schema.js';
+import { ENV_CONFIG_VAR, XDG_CONFIG_DIR } from './constants';
+import { MODEL_PROVIDER_APIS } from './judge/types';
+import { normalizePluginName, resolvePluginSchemasDir, resolveSpacePluginSchemas, shortenPluginName, } from './plugins/util';
+import { bundledSchemasDir } from './schema/schema';
 const MODEL_PROVIDER_SCHEMA = {
     type: 'object',
     properties: {

package/dist/filter/augment-nodes.d.ts

@@ -1,4 +1,4 @@
-import type { SpaceNode } from '../types';
+import type { NodeId, SpaceNode } from '../types';
 /** Edge metadata merged into each ancestor/descendant entry. */
 export type EdgeMetadata = {
     _field: string;
@@ -11,6 +11,7 @@ export type EdgeMetadata = {
 export type AugmentedFlatNode = Record<string, unknown> & {
     resolvedType: string;
     resolvedParentTitles: string[];
+    resolvedParentIds: NodeId[];
     ancestors: Array<Record<string, unknown> & EdgeMetadata>;
     descendants: Array<Record<string, unknown> & EdgeMetadata>;
 };
@@ -18,8 +19,8 @@ export type AugmentedFlatNode = Record<string, unknown> & {
  * Build the augmented flat representation of a node, including pre-computed
  * ancestors[] and descendants[] arrays with edge metadata.
  *
- * - ancestors: BFS from node via resolvedParents, nearest first, deduplicated by title.
- * - descendants: BFS via childrenIndex, nearest first, deduplicated by title.
+ * - ancestors: BFS from node via resolvedParents, nearest first, deduplicated by id.
+ * - descendants: BFS via childrenIndex, nearest first, deduplicated by id.
  * - Each entry merges the parent/child node's fields with edge metadata (_field, _source, _hierarchy, _selfRef).
  */
-export declare function augmentNode(node: SpaceNode, nodeIndex: ReadonlyMap<string, SpaceNode>, childrenIndex: ReadonlyMap<string, readonly SpaceNode[]>): AugmentedFlatNode;
+export declare function augmentNode(node: SpaceNode, nodeIndex: ReadonlyMap<NodeId, SpaceNode>, childrenIndex: ReadonlyMap<NodeId, readonly SpaceNode[]>): AugmentedFlatNode;

package/dist/filter/augment-nodes.js

@@ -11,7 +11,7 @@ function edgeMetadata(ref) {
 function flattenData(node) {
     return {
         ...node.schemaData,
-        label: node.label,
+        id: node.id,
         title: node.title,
         resolvedType: node.resolvedType,
     };
@@ -20,8 +20,8 @@ function flattenData(node) {
  * Build the augmented flat representation of a node, including pre-computed
  * ancestors[] and descendants[] arrays with edge metadata.
  *
- * - ancestors: BFS from node via resolvedParents, nearest first, deduplicated by title.
- * - descendants: BFS via childrenIndex, nearest first, deduplicated by title.
+ * - ancestors: BFS from node via resolvedParents, nearest first, deduplicated by id.
+ * - descendants: BFS via childrenIndex, nearest first, deduplicated by id.
  * - Each entry merges the parent/child node's fields with edge metadata (_field, _source, _hierarchy, _selfRef).
  */
 export function augmentNode(node, nodeIndex, childrenIndex) {
@@ -30,7 +30,8 @@ export function augmentNode(node, nodeIndex, childrenIndex) {
     return {
         ...flattenData(node),
         resolvedType: node.resolvedType,
-        resolvedParentTitles: node.resolvedParents.map((r) => r.title),
+        resolvedParentTitles: node.resolvedParents.map((r) => nodeIndex.get(r.id)?.title ?? r.id),
+        resolvedParentIds: node.resolvedParents.map((r) => r.id),
         ancestors,
         descendants,
     };
@@ -41,24 +42,24 @@ function buildAncestors(node, nodeIndex) {
     // BFS queue holds: { parentRef that led to this node, the node itself }
     const queue = [];
     for (const ref of node.resolvedParents) {
-        const parentNode = nodeIndex.get(ref.title);
+        const parentNode = nodeIndex.get(ref.id);
         if (parentNode)
             queue.push({ ref, node: parentNode });
     }
     while (queue.length > 0) {
         const item = queue.shift();
-        const title = item.node.title;
-        if (visited.has(title))
+        const id = item.node.id;
+        if (visited.has(id))
             continue;
-        visited.add(title);
+        visited.add(id);
         result.push({
             ...flattenData(item.node),
             ...edgeMetadata(item.ref),
         });
         // Continue BFS upward
         for (const ref of item.node.resolvedParents) {
-            const parentNode = nodeIndex.get(ref.title);
-            if (parentNode && !visited.has(ref.title)) {
+            const parentNode = nodeIndex.get(ref.id);
+            if (parentNode && !visited.has(ref.id)) {
                 queue.push({ ref, node: parentNode });
             }
         }
@@ -66,31 +67,31 @@ function buildAncestors(node, nodeIndex) {
     return result;
 }
 function buildDescendants(node, childrenIndex) {
-    const nodeTitle = node.title;
+    const nodeId = node.id;
     const visited = new Set();
     const result = [];
     // BFS queue holds: child node + the resolvedParents entry on that child that points to its parent
     const queue = [];
-    const directChildren = childrenIndex.get(nodeTitle) ?? [];
+    const directChildren = childrenIndex.get(nodeId) ?? [];
     for (const child of directChildren) {
-        const ref = child.resolvedParents.find((r) => r.title === nodeTitle);
+        const ref = child.resolvedParents.find((r) => r.id === nodeId);
         if (ref)
             queue.push({ childNode: child, ref });
     }
     while (queue.length > 0) {
         const item = queue.shift();
-        const title = item.childNode.title;
-        if (visited.has(title))
+        const id = item.childNode.id;
+        if (visited.has(id))
             continue;
-        visited.add(title);
+        visited.add(id);
         result.push({
             ...flattenData(item.childNode),
             ...edgeMetadata(item.ref),
         });
-        const grandchildren = childrenIndex.get(title) ?? [];
+        const grandchildren = childrenIndex.get(id) ?? [];
         for (const grandchild of grandchildren) {
-            if (!visited.has(grandchild.title)) {
-                const ref = grandchild.resolvedParents.find((r) => r.title === title);
+            if (!visited.has(grandchild.id)) {
+                const ref = grandchild.resolvedParents.find((r) => r.id === id);
                 if (ref)
                     queue.push({ childNode: grandchild, ref });
             }

package/dist/filter/expand-include.d.ts

@@ -1,4 +1,4 @@
-import type { SpaceNode } from '../types';
+import type { NodeId, SpaceNode } from '../types';
 import type { AugmentedFlatNode } from './augment-nodes';
 export type AncestorsDirective = {
     kind: 'ancestors';
@@ -59,4 +59,4 @@ export declare function parseIncludeSpec(spec: string): IncludeDirective[];
  * @param childrenIndex - Title → direct children (all edges)
  * @param augmented - Title → AugmentedFlatNode with pre-computed ancestors/descendants
  */
-export declare function expandInclude(matchedNodes: SpaceNode[], directives: IncludeDirective[], nodeIndex: ReadonlyMap<string, SpaceNode>, childrenIndex: ReadonlyMap<string, readonly SpaceNode[]>, augmented: Map<string, AugmentedFlatNode>): SpaceNode[];
+export declare function expandInclude(matchedNodes: SpaceNode[], directives: IncludeDirective[], nodeIndex: ReadonlyMap<NodeId, SpaceNode>, childrenIndex: ReadonlyMap<NodeId, readonly SpaceNode[]>, augmented: Map<NodeId, AugmentedFlatNode>): SpaceNode[];

package/dist/filter/expand-include.js

@@ -85,34 +85,33 @@ function parseDirective(item) {
 export function expandInclude(matchedNodes, directives, nodeIndex, childrenIndex, augmented) {
     if (directives.length === 0)
         return matchedNodes;
-    const seen = new Set(matchedNodes.map((n) => n.title));
+    const seen = new Set(matchedNodes.map((n) => n.id));
     const result = [...matchedNodes];
-    function addByTitle(title) {
-        if (seen.has(title))
+    function addById(id) {
+        if (seen.has(id))
             return;
-        const node = nodeIndex.get(title);
+        const node = nodeIndex.get(id);
         if (node) {
-            seen.add(title);
+            seen.add(id);
             result.push(node);
         }
     }
     for (const node of matchedNodes) {
-        const title = node.title;
-        const aug = augmented.get(title);
+        const aug = augmented.get(node.id);
         if (!aug)
             continue;
         for (const directive of directives) {
-            applyDirective(node, aug, directive, childrenIndex, addByTitle);
+            applyDirective(node, aug, directive, childrenIndex, addById);
         }
     }
     return result;
 }
-function applyDirective(node, aug, directive, childrenIndex, addByTitle) {
+function applyDirective(node, aug, directive, childrenIndex, addById) {
     switch (directive.kind) {
         case 'ancestors': {
             for (const a of aug.ancestors) {
                 if (!directive.typeFilter || a.resolvedType === directive.typeFilter) {
-                    addByTitle(a.title);
+                    addById(a.id);
                 }
             }
             break;
@@ -120,7 +119,7 @@ function applyDirective(node, aug, directive, childrenIndex, addByTitle) {
         case 'descendants': {
             for (const d of aug.descendants) {
                 if (!directive.typeFilter || d.resolvedType === directive.typeFilter) {
-                    addByTitle(d.title);
+                    addById(d.id);
                 }
             }
             break;
@@ -128,11 +127,10 @@ function applyDirective(node, aug, directive, childrenIndex, addByTitle) {
         case 'siblings': {
             // Nodes that share at least one parent with the matched node (any edge type)
             for (const parentRef of node.resolvedParents) {
-                const siblings = childrenIndex.get(parentRef.title) ?? [];
+                const siblings = childrenIndex.get(parentRef.id) ?? [];
                 for (const sibling of siblings) {
-                    const siblingTitle = sibling.title;
-                    if (siblingTitle !== node.title) {
-                        addByTitle(siblingTitle);
+                    if (sibling.id !== node.id) {
+                        addById(sibling.id);
                     }
                 }
             }
@@ -142,13 +140,13 @@ function applyDirective(node, aug, directive, childrenIndex, addByTitle) {
             // Relationship-sourced ancestors (matched node is the child side)
             for (const a of aug.ancestors) {
                 if (a._source === 'relationship' && matchesRelSpec(node, a, directive, true)) {
-                    addByTitle(a.title);
+                    addById(a.id);
                 }
             }
             // Relationship-sourced descendants (matched node is the parent side)
             for (const d of aug.descendants) {
                 if (d._source === 'relationship' && matchesRelSpec(node, d, directive, false)) {
-                    addByTitle(d.title);
+                    addById(d.id);
                 }
             }
             break;

package/dist/filter/filter-nodes.js

@@ -30,7 +30,7 @@ export async function filterNodes(expression, graph) {
     // Pre-augment all nodes once (ancestors/descendants needed for WHERE predicates and SELECT expansion)
     const augmented = new Map();
     for (const node of nodeIndex.values()) {
-        augmented.set(node.title, augmentNode(node, nodeIndex, childrenIndex));
+        augmented.set(node.id, augmentNode(node, nodeIndex, childrenIndex));
     }
     // Step 1: apply WHERE clause to get the matched set
     let matched;
@@ -48,7 +48,7 @@ export async function filterNodes(expression, graph) {
         }
         matched = [];
         for (const node of nodeIndex.values()) {
-            const current = augmented.get(node.title);
+            const current = augmented.get(node.id);
             if (!current)
                 continue;
             // Spread current node fields at root level so bare field names work in expressions

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 #!/usr/bin/env bun
-import type { SpaceContext } from './types.js';
+import type { SpaceContext } from './types';
 export declare function buildSpaceContext(spaceName: string): SpaceContext;

package/dist/index.js

@@ -2,22 +2,22 @@
 import { createRequire } from 'node:module';
 import { format } from 'node:util';
 import { Command } from 'commander';
-import { diagram } from './commands/diagram.js';
-import { docs } from './commands/docs.js';
-import { dump } from './commands/dump.js';
-import { miroSyncCommand } from './commands/miro-sync.js';
-import { listPlugins } from './commands/plugins.js';
-import { render, renderList } from './commands/render.js';
-import { listSchemas, showSchema } from './commands/schemas.js';
-import { show } from './commands/show.js';
-import { listSpaces } from './commands/spaces.js';
-import { templateSync } from './commands/template-sync.js';
-import { validate, watchValidate } from './commands/validate.js';
-import { validateFileCommand } from './commands/validate-file.js';
-import { loadConfig, setConfigPath } from './config.js';
-import { CLI_NAME } from './constants.js';
-import { JudgeConfigError } from './judge/factory.js';
-import { createSpaceContext, SpaceNotFoundError } from './space-context.js';
+import { diagram } from './commands/diagram';
+import { docs } from './commands/docs';
+import { dump } from './commands/dump';
+import { miroSyncCommand } from './commands/miro-sync';
+import { listPlugins } from './commands/plugins';
+import { render, renderList } from './commands/render';
+import { listSchemas, showSchema } from './commands/schemas';
+import { show } from './commands/show';
+import { listSpaces } from './commands/spaces';
+import { templateSync } from './commands/template-sync';
+import { validate, watchValidate } from './commands/validate';
+import { validateFileCommand } from './commands/validate-file';
+import { loadConfig, setConfigPath } from './config';
+import { CLI_NAME } from './constants';
+import { JudgeConfigError } from './judge/factory';
+import { createSpaceContext, SpaceNotFoundError } from './space-context';
 // Once node:process is loaded (vfile, via unified, loads it), Bun's console.log drops piped output
 // past 64KB when the reader is slow. process.stdout.write delivers all of it before exit.
 console.log = (...args) => {
@@ -157,7 +157,7 @@ providersCmd
     .description('List bundled and configured model providers; keys are never shown')
     .option('--json', 'Output as JSON')
     .action(async (options) => {
-    const { listProviders } = await import('./commands/providers.js');
+    const { listProviders } = await import('./commands/providers');
     listProviders(options);
 });
 program.addCommand(providersCmd);

package/dist/judge/context.d.ts

@@ -1,7 +1,7 @@
 import { SEMANTIC_SCOPES } from '../schema/metadata-contract';
 import type { SpaceGraph } from '../space-graph';
 import type { Rule, SpaceNode } from '../types';
-import type { RelatedNode, SemanticJudgeInput } from '../types.js';
+import type { RelatedNode, SemanticJudgeInput } from './types';
 export type SemanticScope = Exclude<(typeof SEMANTIC_SCOPES)[number], 'branch'>;
 export type ContentMode = 'none' | 'nodeOnly' | 'fullScope';
 /** What a rule asks to send besides the evaluated node's data. */

package/dist/judge/context.js

@@ -25,14 +25,14 @@ function dataWithBody(node, withBody) {
     return data;
 }
 /** The evaluated node as a judge sees it. */
-function judgeNodeView(node, withBody) {
+function judgeNodeView(node, withBody, graph) {
     return {
-        label: node.label,
+        id: node.id,
         title: node.title,
         type: node.type,
         resolvedType: node.resolvedType,
         schemaData: dataWithBody(node, withBody),
-        resolvedParents: node.resolvedParents,
+        parentTitles: node.resolvedParents.map((p) => graph.nodes.get(p.id)?.title ?? p.id),
     };
 }
 function relatedView(node, relation, withBody) {
@@ -50,28 +50,28 @@ export function relatedNodes(graph, node, context) {
         ? []
         : n.resolvedParents
             .filter((p) => p.source === 'hierarchy' && p.hierarchy === hierarchyName)
-            .map((p) => graph.nodes.get(p.title))
+            .map((p) => graph.nodes.get(p.id))
             .filter((p) => p !== undefined);
-    const childrenOf = (n) => graph.hierarchyChildren.get(n.title) ?? [];
+    const childrenOf = (n) => graph.hierarchyChildren.get(n.id) ?? [];
     const found = new Map();
     const add = (other, relation) => {
-        if (other.title === node.title)
+        if (other.id === node.id)
             return;
-        const existing = found.get(other.title);
+        const existing = found.get(other.id);
         if (!existing)
-            found.set(other.title, relatedView(other, relation, withBody));
+            found.set(other.id, relatedView(other, relation, withBody));
         else if (!existing.relations.includes(relation))
             existing.relations.push(relation);
     };
     const reach = (next, relation) => {
-        const seen = new Set([node.title]);
+        const seen = new Set([node.id]);
         let level = next(node);
         while (level.length > 0) {
             const following = [];
             for (const n of level) {
-                if (seen.has(n.title))
+                if (seen.has(n.id))
                     continue;
-                seen.add(n.title);
+                seen.add(n.id);
                 add(n, relation);
                 following.push(...next(n));
             }
@@ -99,7 +99,7 @@ export function relatedNodes(graph, node, context) {
 export function judgeContext(graph, node, context) {
     const related = relatedNodes(graph, node, context);
     return {
-        node: judgeNodeView(node, context.content !== 'none'),
+        node: judgeNodeView(node, context.content !== 'none', graph),
         ...(related.length > 0 && { related }),
     };
 }

package/dist/judge/factory.d.ts

@@ -1,4 +1,4 @@
-import { type HydratedProvider, type ModelProviderConfig, type SemanticJudgeProvider } from '../types.js';
+import { type HydratedProvider, type ModelProviderConfig, type SemanticJudgeProvider } from './types';
 type Env = Record<string, string | undefined>;
 /**
  * Bundled providers: usable as a judge by name, without a `modelProviders` entry. A user entry of the

package/dist/judge/factory.js

@@ -3,7 +3,7 @@ import { FakeJudgeProvider } from './provider/fake';
 import { JEV_LATEST, JevJudgeProvider } from './provider/jev';
 import { OpenAIJudgeProvider, RECOMMENDED_OPENAI_MODEL } from './provider/openai';
 import { OpenAIDecisionsJudgeProvider, RECOMMENDED_OPENAI_DECISIONS_MODEL } from './provider/openai-decisions';
-import { MODEL_PROVIDER_APIS, } from '../types.js';
+import { MODEL_PROVIDER_APIS, } from './types';
 const OPENROUTER_COMPLETIONS_ENDPOINT = 'https://openrouter.ai/api/v1';
 const RECOMMENDED_OPENROUTER_OPENAI_DECISIONS_MODEL = `openai/${RECOMMENDED_OPENAI_DECISIONS_MODEL}-decisions`;
 const RECOMMENDED_OPENROUTER_OPENAI_MODEL = `openai/${RECOMMENDED_OPENAI_MODEL}`;

package/dist/judge/index.d.ts

@@ -9,5 +9,5 @@ export { JevJudgeProvider } from './provider/jev';
 export type { OpenAIJudgeProviderOptions } from './provider/openai';
 export { OpenAIJudgeProvider } from './provider/openai';
 export { PerRuleJudgeProvider } from './provider/per-rule';
-export type { JudgeConfig, ModelProviderConfig, SemanticJudgeInput, SemanticJudgeProvider, SemanticJudgeResult, SemanticJudgeVerdict, SemanticRuleSpec, } from '../types.js';
+export type { JudgeConfig, ModelProviderConfig, SemanticJudgeInput, SemanticJudgeProvider, SemanticJudgeResult, SemanticJudgeVerdict, SemanticRuleSpec, } from './types';
 export { DEFAULT_VERDICTS, isJudgeError, semanticRuleSpec } from './verdicts';

package/dist/judge/judge-node.d.ts

@@ -1,12 +1,12 @@
 import type { SpaceGraph } from '../space-graph';
 import type { Rule, RuleSeverity, SpaceNode } from '../types';
 import { type TrimReport } from './trim';
-import type { SemanticJudgeProvider } from '../types.js';
+import type { SemanticJudgeProvider } from './types';
 export type NodeJudgement = {
     rule: Rule;
-    /** True when the verdict fails the rule (it has a severity), or the provider errored. */
-    failed: boolean;
-    /** Severity of the failing verdict; unset for a judge error, which takes the rule's own severity. */
+    /** True when the verdict has a severity (so it reports a violation), or the provider errored. */
+    violated: boolean;
+    /** Severity of the verdict; unset for a judge error, which takes the rule's own severity. */
     severity?: RuleSeverity;
     verdict?: string;
     /** User-facing guidance declared for the failing verdict. */