structured-context 0.9.0 → 0.9.2

package/README.md

@@ -1,11 +1,58 @@
 # structured-context
 
-Tools for working with Opportunity Solution Tree structures and other product management and strategy frameworks
+Keep your content clean and your thinking clear.
+
+`structured-context` provides assistive tools for working with structured content, including knowledge wikis (a la [Karpathy](https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f)), product/strategy frameworks (like [Teresa Torres' Opportunity Solution Trees](https://www.producttalk.org/opportunity-solution-trees/) and [Martin et al's strategy cascade](https://rogerlmartin.com/thought-pillars/strategy), and more. Great for flat sets of documents, hierarchical or layered context trees, or any kind of knowledge graph.
+
+Assign a schema to your markdown content to give humans and AI agents consistent structure and content guidelines. 
+
+In Claude Code:
+```
+❯ Use /structured-context to configure 'my-research' as a knowledge wiki, then organise it
+
+⏺ Skill(structured-context)
+  ⎿  Successfully loaded skill
+
+...
+
+```
+
+Command line tools:
+```
+> sctx validate strategy
+
+Space Validation Results
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Content and structure
+  Valid                                   16
+  Schema validation errors                 0
+  Broken links                             1
+  Duplicate keys                           0
+  Rule violations                          2
+  Hierarchy violations                     0
+  Orphans (hierarchy nodes - no parent)    1
+  Ignored during parsing                   0
+
+Orphans (hierarchy nodes - no parent):
+   Solution looking for a problem.md
+
+Broken links:
+   Steal underpants.md: [[Gnome goals]] → Link target "Gnome goals" in field "related" not found
+
+Rule violations:
+  workflow (1):
+    Build Death Star.md: Opportunities should contribute to at least one Outcome
+  
+  best-practice (1):
+    High tech juice press.md: Explore multiple candidate solutions (aim for at least three) for an active target opportunity
+```
 
 ## Installation
 
 Requires [Bun](https://bun.sh) runtime.
 
+Install globally (recommended):
+
 ```bash
 bun install -g structured-context
 ```
@@ -18,10 +65,11 @@ bunx structured-context validate <space>
 
 ## Setup for AI Agents
 
-A Claude Code plugin is included at `plugin/`. It provides validation hooks, slash commands, and agent skills. Install it with:
+Claude Code plugin, providing validation hooks, slash commands, and agent skills. Install it with:
 
 ```
-claude plugin install mindsocket/structured-context
+claude plugin marketplace add mindsocket/structured-context
+claude plugin install structured-context
 ```
 
 Skills can also be installed standalone without the plugin:
@@ -38,31 +86,24 @@ See [docs/concepts.md](docs/concepts.md) for the full terminology reference, inc
 
 `structured-context` looks for its config file in this order:
 
-1. `$SCTX_CONFIG` — explicit path override
-2. `~/.config/structured-context/config.json` (or `$XDG_CONFIG_HOME/structured-context/config.json`)
-3. `./config.json` in the current working directory
+1. `--config` command line argument
+2. `$SCTX_CONFIG` env var
+3. `~/.config/structured-context/config.json` (or `$XDG_CONFIG_HOME/structured-context/config.json`)
+4. `./config.json` in the current working directory
 
-See `config.example.json` for the full structure. The config maps space names to paths, with optional Miro integration fields and global defaults. Paths in config files are resolved relative to the config file.
+See `config.example.json` for the full structure. The config maps space names to paths, with optional additional configuration options for parsing and integrations. Paths in config files are resolved relative to the config file.
 
 **Including spaces from other configs:** Use `includeSpacesFrom` to import space definitions from other config files. This is useful for aggregating spaces from multiple projects into a central config, reducing the need to specify `--config` on CLI commands. Duplicate space names are not allowed.
 
 **Plugins and markdown plugin config:** See `sctx docs config` for the full reference including `fieldMap`, `typeInference`, `templateDir`, filter views, and plugin loading rules.
 
-### Spaces
-
-A space is a named directory or single file registered in the config. Spaces let you reference content by name instead of path:
-
-```bash
-sctx validate ProductX
-```
-
 ### Schemas
 
 Schemas define the structure and rules for the entities in a space, allowing customisation and extension to different models.
 
-Two schemas (`general` and `strict_ost`) are included. The general schema combines a basic vision/mission/goals hierarchy with a hierarchy loosely based on Opportunity Solution Trees. It is intentionally flexible to support rapid initial adoption. The strict OST schema has a narrower scope, and reflects Teresa Torres' specific recommendations for Opportunity Solution Trees more closely.
+Several schemas (`strict_ost`, `knowledge_wiki` and `general`) are included. The general (strategy) schema combines a basic vision/mission/goals hierarchy with a hierarchy loosely based on Opportunity Solution Trees. It is intentionally flexible to support rapid initial adoption. The strict OST schema has a narrower scope, and reflects Teresa Torres' specific recommendations for Opportunity Solution Trees more closely. The knowledge wiki schema defines a flatter set of types used for knowledge bases.
 
-sctx schemas use a metaschema based on JSON Schema Draft-07 that adds a top-level `$metadata` block:
+structured-context schemas use a metaschema based on JSON Schema Draft-07 that adds a top-level `$metadata` block:
 
 ```json5
 "$metadata": {
@@ -91,8 +132,6 @@ sctx schemas use a metaschema based on JSON Schema Draft-07 that adds a top-leve
 }
 ```
 
-Rules are a flat array (`rules[]`) with per-rule `category`.
-
 Schema hierarchy levels support DAG (multi-parent) relationships via configurable edge fields. Each entry in `$metadata.hierarchy.levels` can be a plain type name string (defaults to `parent` field on child nodes) or an object:
 
 ```json5
@@ -154,7 +193,7 @@ If no provider defines `hierarchy`, hierarchy-specific checks are skipped. Readi
 - **Transitive resolution**: `$ref` chains are resolved recursively across files/schemas (including nested `allOf` usage in partials).
 - **Unique IDs**: To encourage clean namespacing, local partial schemas **must** have unique `$id`s that do not collide with the default schemas. If a collision is detected, validation will fail with an error.
 
-Schema resolution order: space config `schema` > global config `schema` > bundled `schemas/general.json`
+Schema resolution order: space config `schema` > global config `schema`. Schema resolution fails if none is configured.
 
 **⚠️ Security Notice: Only use schemas and configuration files from trusted sources.**
 
@@ -283,7 +322,7 @@ Generates a Mermaid Entity Relationship Diagram from a schema:
 
 Example:
 ```bash
-sctx schemas show general --mermaid-erd
+sctx schemas show strategy_general --mermaid-erd
 ```
 
 ### Sync space to Miro

package/dist/commands/spaces.js

@@ -1,5 +1,5 @@
 import { basename, resolve } from 'node:path';
-import { configPath, loadConfig, resolveSchema } from '../config';
+import { configPath, loadConfig } from '../config';
 function renderConfigValue(v) {
     if (typeof v === 'object' && v !== null)
         return JSON.stringify(v);
@@ -12,7 +12,8 @@ export function listSpaces() {
     for (const space of config.spaces) {
         console.log(`${space.name}`);
         console.log(`  path:    ${space.path}`);
-        console.log(`  schema:  ${basename(resolveSchema(config, space))}`);
+        const schema = space.schema ?? config.schema;
+        console.log(`  schema:  ${schema ? basename(schema) : '(none)'}`);
         if (space.miroBoardId)
             console.log(`  miro:    configured`);
         const plugins = space.plugins ?? {};

package/dist/commands/validate.js

@@ -97,7 +97,7 @@ export async function validate(context, options = {}) {
     const { schema, schemaRefRegistry, schemaValidator } = context;
     const metadata = schema.metadata;
     const readResult = await readSpace(context);
-    const { nodes, parseIgnored } = readResult;
+    const { nodes, parseIssues } = readResult;
     const result = {
         validCount: 0,
         nodeErrorCount: 0,
@@ -106,8 +106,8 @@ export async function validate(context, options = {}) {
         duplicateErrors: [],
         ruleViolations: [],
         hierarchyViolations: [],
-        orphanCount: 0,
-        parseIgnored: parseIgnored || [],
+        orphans: [],
+        parseIssues,
     };
     for (const node of nodes) {
         const valid = schemaValidator(node.schemaData);
@@ -143,7 +143,7 @@ export async function validate(context, options = {}) {
     result.hierarchyViolations = [...hierarchyValidation.violations];
     // Calculate orphan count (informational, not a validation error)
     if (metadata.hierarchy) {
-        result.orphanCount = buildSpaceGraph(nodes, metadata.hierarchy.levels).orphans.length;
+        result.orphans = [...buildSpaceGraph(nodes, metadata.hierarchy.levels).orphans];
     }
     // Load and execute rules validation if schema defines rules
     if (metadata.rules) {
@@ -180,15 +180,16 @@ export async function validate(context, options = {}) {
         for (const v of result.hierarchyViolations) {
             addError(v.file, `hierarchy:${v.description}`, 'hierarchy', v.description);
         }
-        const errorCount = Object.values(errorsByFile).reduce((sum, errs) => sum + Object.keys(errs).length, 0);
+        const parseErrorCount = result.parseIssues.filter((i) => i.severity === 'error').length;
+        const errorCount = Object.values(errorsByFile).reduce((sum, errs) => sum + Object.keys(errs).length, 0) + parseErrorCount;
         console.log(JSON.stringify({
             space: context.space.name,
             valid: errorCount === 0,
             validCount: result.validCount,
             errorCount,
             errors: errorsByFile,
-            orphanCount: result.orphanCount,
-            parseIgnored: result.parseIgnored,
+            orphanCount: result.orphans.length,
+            parseIssues: result.parseIssues,
         }, null, 2));
         return errorCount > 0 ? 1 : 0;
     }
@@ -223,12 +224,20 @@ export async function validate(context, options = {}) {
     console.log(fmt('  Duplicate keys', result.duplicateErrors.length, true));
     console.log(fmt('  Rule violations', result.ruleViolations.length, true));
     console.log(fmt('  Hierarchy violations', result.hierarchyViolations.length, true));
-    console.log(fmt('  Orphans (hierarchy nodes - no parent)', result.orphanCount, true, true));
-    console.log(fmt('  Ignored during parsing', result.parseIgnored.length, true, true));
-    if (result.parseIgnored.length > 0) {
-        console.log(`\nIgnored during parsing:`);
-        for (const f of result.parseIgnored)
-            console.log(`   ${f}`);
+    console.log(fmt('  Orphans (hierarchy nodes - no parent)', result.orphans.length, true, true));
+    const parseIssueErrorCount = result.parseIssues.filter((i) => i.severity === 'error').length;
+    console.log(fmt('  Excluded during parsing', result.parseIssues.length, true, parseIssueErrorCount === 0));
+    if (result.orphans.length > 0) {
+        console.log(`\nOrphans (hierarchy nodes - no parent):`);
+        for (const node of result.orphans)
+            console.log(`   ${node.label}`);
+    }
+    if (result.parseIssues.length > 0) {
+        console.log(`\nExcluded during parsing:`);
+        for (const issue of result.parseIssues) {
+            const detail = issue.message ? ` - ${issue.message}` : '';
+            console.log(`   ${issue.file}: ${issue.severity} - ${issue.type}${detail}`);
+        }
     }
     if (result.nodeErrors.length > 0) {
         console.log(`\nSchema validation errors:`);
@@ -285,7 +294,8 @@ export async function validate(context, options = {}) {
         result.refErrors.length > 0 ||
         result.duplicateErrors.length > 0 ||
         result.ruleViolations.length > 0 ||
-        result.hierarchyViolations.length > 0) {
+        result.hierarchyViolations.length > 0 ||
+        parseIssueErrorCount > 0) {
         return 1;
     }
     return 0;

package/dist/config.d.ts

@@ -28,7 +28,7 @@ export declare function configPath(): string;
 export declare function loadConfig(): Config;
 /** Get the full space config entry by name. Throws if not found. */
 export declare function getSpaceConfig(name: string, config: Config): SpaceConfig;
-/** Resolve schema path: CLI arg > space-level config > global config > hardcoded default. */
+/** Resolve schema path: CLI arg > space-level config > global config. Throws if none configured. */
 export declare function resolveSchema(config: Config, space?: SpaceConfig): string;
 type StringFields<T> = {
     [K in keyof T]: T[K] extends string | undefined ? K : never;

package/dist/config.js

@@ -98,13 +98,24 @@ function resolveRelativePaths(config, configDir) {
             return p;
         return resolve(configDir, p);
     };
+    const relSchema = (p) => {
+        if (!p || isAbsolute(p) || isUrl(p))
+            return p;
+        if (!p.includes('/') && !p.includes('\\')) {
+            const localPath = resolve(configDir, p);
+            if (existsSync(localPath))
+                return localPath;
+            return join(bundledSchemasDir, p);
+        }
+        return resolve(configDir, p);
+    };
     return {
         ...config,
-        schema: rel(config.schema),
+        schema: relSchema(config.schema),
         spaces: config.spaces.map((s) => ({
             ...s,
             path: rel(s.path),
-            schema: rel(s.schema),
+            schema: relSchema(s.schema),
             plugins: normalizePlugins(s.plugins),
         })),
     };
@@ -159,9 +170,13 @@ export function getSpaceConfig(name, config) {
     }
     return space;
 }
-/** Resolve schema path: CLI arg > space-level config > global config > hardcoded default. */
+/** Resolve schema path: CLI arg > space-level config > global config. Throws if none configured. */
 export function resolveSchema(config, space) {
-    return space?.schema ?? config.schema ?? join(bundledSchemasDir, 'general.json');
+    const schema = space?.schema ?? config.schema;
+    if (!schema) {
+        throw new Error('No schema configured. Set "schema" in the space config or at the top level of the config file.');
+    }
+    return schema;
 }
 /** Update a string field on a space entry and persist config. */
 export function updateSpaceField(spaceName, field, value) {

package/dist/plugin-api.d.ts

@@ -9,4 +9,4 @@ export type { AnySchemaObject, SchemaObject, ValidateFunction } from 'ajv';
 export type { ParseHook, ParseResult, PluginContext, RenderFormat, RenderHook, RenderOptions, StructuredContextPlugin, TemplateSyncHook, TemplateSyncOptions, } from './plugins/util';
 export type { SharedEmbeddingFields } from './schema/metadata-contract';
 export type { SpaceGraph } from './space-graph';
-export type { BaseNode, EdgeDefinition, HierarchyLevel, Relationship, SchemaMetadata, SchemaWithMetadata, SpaceContext, SpaceNode, UnresolvedRef, } from './types';
+export type { BaseNode, EdgeDefinition, HierarchyLevel, ParseIssue, Relationship, SchemaMetadata, SchemaWithMetadata, SpaceContext, SpaceNode, UnresolvedRef, } from './types';

package/dist/plugins/markdown/read-space.js

@@ -25,7 +25,13 @@ export function readSpaceOnAPage(context) {
         pageType: 'space_on_a_page',
         metadata,
     });
-    return { nodes, parseIgnored: terminatedHeadings, diagnostics: { kind: 'page', preambleNodeCount } };
+    const parseIssues = terminatedHeadings.map((heading) => ({
+        file: heading,
+        severity: 'warning',
+        type: 'terminated',
+        message: 'Ignored headings detected beyond end of hierarchy.',
+    }));
+    return { nodes, parseIssues, diagnostics: { kind: 'page', preambleNodeCount } };
 }
 export async function readSpaceDirectory(context, options) {
     const { space, schema: { metadata }, } = context;
@@ -38,17 +44,33 @@ export async function readSpaceDirectory(context, options) {
     const knownTypes = typeInferenceCfg?.mode !== 'off' ? extractSchemaTypeNames(context.schema, context.schemaRefRegistry) : undefined;
     const files = await Array.fromAsync(new Glob('**/*.md').scan({ cwd: directory, followSymlinks: true }));
     const nodes = [];
-    const skipped = [];
-    const nonSpace = [];
+    const parseIssues = [];
     for (const file of files) {
         const absoluteFilePath = resolve(directory, file);
         if (absoluteTemplateDir && absoluteFilePath.startsWith(absoluteTemplateDir)) {
             continue;
         }
         const content = readFileSync(join(directory, file), 'utf-8');
-        const parsed = matter(content);
+        let parsed;
+        try {
+            parsed = matter(content);
+        }
+        catch (err) {
+            // gray-matter caches parsed YAML and has a known bug where a caught exception
+            // corrupts its internal cache, causing subsequent parses to silently return {}.
+            // Clear the cache after any parse error to avoid stale state.
+            // See: https://github.com/jonschlinkert/gray-matter/issues/166
+            matter.clearCache();
+            parseIssues.push({
+                file,
+                severity: 'error',
+                type: 'parse',
+                message: err instanceof Error ? err.message : String(err),
+            });
+            continue;
+        }
         if (!parsed.data || Object.keys(parsed.data).length === 0) {
-            skipped.push(file);
+            parseIssues.push({ file, severity: 'warning', type: 'empty' });
             continue;
         }
         const data = coerceDates(applyFieldMap(parsed.data, fieldMap));
@@ -56,7 +78,7 @@ export async function readSpaceDirectory(context, options) {
             data.type = inferTypeFromPath(file, typeInferenceCfg, knownTypes, context.schema.metadata.typeAliases);
         }
         if (!data.type) {
-            nonSpace.push(file);
+            parseIssues.push({ file, severity: 'warning', type: 'no-type' });
             continue;
         }
         if (ON_A_PAGE_TYPES.includes(data.type) && !options?.includeOnAPageFiles) {
@@ -81,9 +103,14 @@ export async function readSpaceDirectory(context, options) {
             });
             nodes.push(...embedded);
             for (const heading of terminatedHeadings) {
-                nonSpace.push(`${file} > ${heading}`);
+                parseIssues.push({
+                    file: `${file} > ${heading}`,
+                    severity: 'warning',
+                    type: 'terminated',
+                    message: 'Ignored headings detected beyond end of hierarchy.',
+                });
             }
         }
     }
-    return { nodes, parseIgnored: [...skipped, ...nonSpace], diagnostics: { kind: 'directory' } };
+    return { nodes, parseIssues, diagnostics: { kind: 'directory' } };
 }

package/dist/plugins/util.d.ts

@@ -1,6 +1,6 @@
 import type { AnySchemaObject } from 'ajv';
 import type { SpaceGraph } from '../space-graph';
-import type { BaseNode, SpaceContext } from '../types';
+import type { BaseNode, ParseIssue, SpaceContext } from '../types';
 export declare const PLUGIN_PREFIX = "sctx-";
 export declare const CONFIG_PLUGINS_DIR = "plugins";
 /** Normalize a plugin name to its canonical prefixed form. */
@@ -11,8 +11,8 @@ export type PluginContext = SpaceContext & {
 };
 export type ParseResult = {
     nodes: BaseNode[];
-    /** Paths/items the plugin skipped during parsing, for any reason. */
-    parseIgnored: string[];
+    /** Issues encountered while parsing files — excluded files with reason and severity. */
+    parseIssues: ParseIssue[];
     /** Plugin diagnostics: keyed scalar or list values. */
     diagnostics: Record<string, number | string | string[]>;
 };

package/dist/read/read-space.js

@@ -12,7 +12,7 @@ export async function readSpace(context) {
             return {
                 nodes,
                 source: plugin.name,
-                parseIgnored: result.parseIgnored,
+                parseIssues: result.parseIssues,
                 diagnostics: result.diagnostics,
                 unresolvedRefs,
             };

package/dist/schemas/knowledge_wiki.json

@@ -9,7 +9,9 @@
       "study": "source",
       "article": "source",
       "paper": "source",
-      "research": "source"
+      "research": "source",
+      "comparison": "synthesis",
+      "query": "synthesis"
     },
     "relationships": [
       {
@@ -26,6 +28,13 @@
         "fieldOn": "child",
         "multiple": true
       },
+      {
+        "parent": "source",
+        "type": "entity",
+        "field": "sources",
+        "fieldOn": "child",
+        "multiple": true
+      },
       {
         "parent": "concept",
         "type": "synthesis",
@@ -134,6 +143,36 @@
         }
       ]
     },
+    {
+      "type": "object",
+      "description": "A concrete entity — a person, organisation, product, model, or other named thing. The building blocks of the wiki's knowledge graph alongside concepts. Entities are distinct from concepts: a concept frames an idea or mechanism; an entity is a specific, identifiable thing in the world.",
+      "allOf": [{ "$ref": "sctx://_sctx_base#/$defs/baseNodeProps" }],
+      "properties": {
+        "type": { "const": "entity" },
+        "summary": {
+          "$ref": "sctx://_sctx_base#/$defs/summary"
+        },
+        "sources": {
+          "type": "array",
+          "items": { "$ref": "sctx://_sctx_base#/$defs/wikilink" },
+          "description": "Wikilinks to source pages that contributed to this entity page"
+        },
+        "related": {
+          "type": "array",
+          "items": { "$ref": "sctx://_sctx_base#/$defs/wikilink" },
+          "description": "Wikilinks to related entity, concept, or synthesis pages"
+        }
+      },
+      "required": ["type"],
+      "additionalProperties": true,
+      "examples": [
+        {
+          "type": "entity",
+          "summary": "AI safety research lab founded by Dario Amodei and Daniela Amodei",
+          "tags": ["company", "ai", "safety"]
+        }
+      ]
+    },
     {
       "type": "object",
       "description": "A synthesis page — connects multiple concepts and sources into a coherent model, framework, or thesis. The highest-value pages in a knowledge wiki. Must reference contributing sources.",

package/dist/schemas/{general.json → strategy_general.json}

@@ -1,6 +1,6 @@
 {
   "$schema": "https://raw.githubusercontent.com/mindsocket/structured-context/main/schemas/generated/_structured_context_schema_meta.json",
-  "$id": "sctx://general",
+  "$id": "sctx://strategy_general",
   "title": "Strategy and opportunity ladder",
   "description": "Validates frontmatter for space node files",
   "$metadata": {

package/dist/types.d.ts

@@ -86,6 +86,18 @@ export type SpaceNode = BaseNode & {
      */
     resolvedParents: ResolvedParentRef[];
 };
+export type ParseIssue = {
+    /** Source identifier of the file or item (filename or heading title). */
+    file: string;
+    /** error: prevented the file from producing nodes; warning: file was silently excluded. */
+    severity: 'error' | 'warning';
+    /** empty: no content; no-type: no type field;
+     *  parse: parse failure (syntax issue or unexpected content);
+     *  plugins may choose to provide additional types. */
+    type: 'empty' | 'no-type' | 'parse' | string;
+    /** Human-readable detail. */
+    message?: string;
+};
 /** Rule categories for organizing executable validation rules */
 export type RuleCategory = 'validation' | 'coherence' | 'workflow' | 'best-practice';
 export type { Rule } from './schema/metadata-contract';
@@ -118,8 +130,8 @@ export type SchemaWithMetadata = SchemaObject & {
 export type ReadSpaceResult = {
     /** Fully resolved nodes produced by the plugin and enriched by core. */
     nodes: SpaceNode[];
-    /** Paths/items the plugin skipped during parsing, for any reason. */
-    parseIgnored: string[];
+    /** Issues encountered while parsing files — excluded files with reason and severity. */
+    parseIssues: ParseIssue[];
     /** Plugin diagnostics: keyed scalar or list values. */
     diagnostics: Record<string, number | string | string[]>;
     /** Name of the plugin that produced the nodes. */

package/docs/config.md

@@ -20,7 +20,7 @@ A space is a named directory or single file registered in the config. Example:
     {
       "name": "ProductX",
       "path": "/path/to/space",
-      "schema": "general.json"
+      "schema": "strategy_general.json"
     }
   ]
 }

package/docs/schemas.md

@@ -20,11 +20,11 @@ Set `schema` in the space config entry:
 }
 ```
 
-Resolution order: space `schema` > global `schema` > bundled `schemas/general.json`.
+Resolution order: space `schema` > global `schema`. Schema resolution fails if none is configured.
 
 ## Bundled schemas
 
-### `general.json` (default)
+### `strategy_general.json`
 
 Flexible planning schema spanning strategy + OST-like flow.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "structured-context",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "Tools for working with Opportunity Solution Tree structures and other product management and strategy frameworks",
   "module": "./dist/index.js",
   "type": "module",

package/schemas/knowledge_wiki.json

@@ -9,7 +9,9 @@
       "study": "source",
       "article": "source",
       "paper": "source",
-      "research": "source"
+      "research": "source",
+      "comparison": "synthesis",
+      "query": "synthesis"
     },
     "relationships": [
       {
@@ -26,6 +28,13 @@
         "fieldOn": "child",
         "multiple": true
       },
+      {
+        "parent": "source",
+        "type": "entity",
+        "field": "sources",
+        "fieldOn": "child",
+        "multiple": true
+      },
       {
         "parent": "concept",
         "type": "synthesis",
@@ -134,6 +143,36 @@
         }
       ]
     },
+    {
+      "type": "object",
+      "description": "A concrete entity — a person, organisation, product, model, or other named thing. The building blocks of the wiki's knowledge graph alongside concepts. Entities are distinct from concepts: a concept frames an idea or mechanism; an entity is a specific, identifiable thing in the world.",
+      "allOf": [{ "$ref": "sctx://_sctx_base#/$defs/baseNodeProps" }],
+      "properties": {
+        "type": { "const": "entity" },
+        "summary": {
+          "$ref": "sctx://_sctx_base#/$defs/summary"
+        },
+        "sources": {
+          "type": "array",
+          "items": { "$ref": "sctx://_sctx_base#/$defs/wikilink" },
+          "description": "Wikilinks to source pages that contributed to this entity page"
+        },
+        "related": {
+          "type": "array",
+          "items": { "$ref": "sctx://_sctx_base#/$defs/wikilink" },
+          "description": "Wikilinks to related entity, concept, or synthesis pages"
+        }
+      },
+      "required": ["type"],
+      "additionalProperties": true,
+      "examples": [
+        {
+          "type": "entity",
+          "summary": "AI safety research lab founded by Dario Amodei and Daniela Amodei",
+          "tags": ["company", "ai", "safety"]
+        }
+      ]
+    },
     {
       "type": "object",
       "description": "A synthesis page — connects multiple concepts and sources into a coherent model, framework, or thesis. The highest-value pages in a knowledge wiki. Must reference contributing sources.",

package/schemas/{general.json → strategy_general.json}

@@ -1,6 +1,6 @@
 {
   "$schema": "https://raw.githubusercontent.com/mindsocket/structured-context/main/schemas/generated/_structured_context_schema_meta.json",
-  "$id": "sctx://general",
+  "$id": "sctx://strategy_general",
   "title": "Strategy and opportunity ladder",
   "description": "Validates frontmatter for space node files",
   "$metadata": {