structured-context 0.11.0 → 0.13.0

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

@@ -3,6 +3,7 @@ export interface GraphValidationResult {
     violations: GraphViolation[];
     refErrors: Array<{
         file: string;
+        line?: number;
         parent: string;
         error: string;
     }>;
@@ -15,7 +16,7 @@ export declare function validateGraph(nodes: SpaceNode[], metadata: SchemaMetada
 /**
  * Validate that resolved parents follow hierarchy level rules and relationship type constraints.
  *
- * For hierarchy edges (fieldOn:'child', source:'hierarchy'): validates level ordering.
+ * For hierarchy edges (fieldOn:'child', source:'hierarchy'): validates level ordering within the edge's hierarchy.
  * For relationship edges (fieldOn:'child', source:'relationship'): validates parent type.
  * For fieldOn:'parent' edges: validates child type, violation attributed to the field-owner node.
  *

package/dist/schema/validate-graph.js

@@ -4,14 +4,19 @@ import { resolveNodeType } from '../schema/schema';
  * Assumes resolveGraphEdges has already been called to populate node.resolvedParents.
  */
 export function validateGraph(nodes, metadata, unresolvedRefs = []) {
-    const refErrors = unresolvedRefs.map((u) => ({ file: u.label, parent: u.ref, error: u.message }));
+    const refErrors = unresolvedRefs.map((u) => ({
+        file: u.source?.file ?? u.label,
+        ...(u.source?.line !== undefined ? { line: u.source.line } : {}),
+        parent: u.ref,
+        error: u.message,
+    }));
     const violations = validateHierarchyStructure(nodes, metadata);
     return { violations, refErrors };
 }
 /**
  * Validate that resolved parents follow hierarchy level rules and relationship type constraints.
  *
- * For hierarchy edges (fieldOn:'child', source:'hierarchy'): validates level ordering.
+ * For hierarchy edges (fieldOn:'child', source:'hierarchy'): validates level ordering within the edge's hierarchy.
  * For relationship edges (fieldOn:'child', source:'relationship'): validates parent type.
  * For fieldOn:'parent' edges: validates child type, violation attributed to the field-owner node.
  *
@@ -19,11 +24,12 @@ export function validateGraph(nodes, metadata, unresolvedRefs = []) {
  */
 export function validateHierarchyStructure(nodes, metadata) {
     const violations = [];
-    const levels = metadata.hierarchy?.levels ?? [];
+    const hierarchies = metadata.hierarchies ?? [];
     const relationships = metadata.relationships ?? [];
-    const allowSkipLevels = metadata.hierarchy?.allowSkipLevels ?? false;
     const typeAliases = metadata.typeAliases;
-    const hierarchy = levels.map((level) => resolveNodeType(level.type, typeAliases));
+    const hierarchiesByName = new Map(hierarchies.map((h) => [h.name, h]));
+    const levelTypesByName = new Map(hierarchies.map((h) => [h.name, h.levels.map((level) => resolveNodeType(level.type, typeAliases))]));
+    const allHierarchyTypes = new Set([...levelTypesByName.values()].flat());
     // Build type rules: (ownerType, field) → set of valid target types.
     // For fieldOn:'child': owner=childType, target=parentType.
     // For fieldOn:'parent': owner=parentType (field owner), target=childType.
@@ -38,18 +44,20 @@ export function validateHierarchyStructure(nodes, metadata) {
             fieldMap.set(field, new Set());
         fieldMap.get(field).add(target);
     }
-    for (let i = 1; i < levels.length; i++) {
-        const level = levels[i];
-        const parentLevel = levels[i - 1];
-        if (level.fieldOn === 'parent') {
-            addTypeRule(parentLevel.type, level.field, level.type);
-            if (level.selfRef)
-                addTypeRule(level.type, level.field, level.type);
-        }
-        else {
-            addTypeRule(level.type, level.field, parentLevel.type);
-            if (level.selfRef)
-                addTypeRule(level.type, level.field, level.type);
+    for (const { levels } of hierarchies) {
+        for (let i = 1; i < levels.length; i++) {
+            const level = levels[i];
+            const parentLevel = levels[i - 1];
+            if (level.fieldOn === 'parent') {
+                addTypeRule(parentLevel.type, level.field, level.type);
+                if (level.selfRef)
+                    addTypeRule(level.type, level.field, level.type);
+            }
+            else {
+                addTypeRule(level.type, level.field, parentLevel.type);
+                if (level.selfRef)
+                    addTypeRule(level.type, level.field, level.type);
+            }
         }
     }
     for (const rel of relationships) {
@@ -107,15 +115,24 @@ export function validateHierarchyStructure(nodes, metadata) {
                 }
             }
             else {
-                // Hierarchy edge (fieldOn:'child', source:'hierarchy'): validate level ordering.
-                const typeIndex = hierarchy.indexOf(nodeType);
-                const parentIndex = hierarchy.indexOf(parentType);
-                if (typeIndex === -1 || parentIndex === -1)
+                // Hierarchy edge (fieldOn:'child', source:'hierarchy'): validate level ordering within its hierarchy.
+                const edgeHierarchy = parentRef.hierarchy !== undefined ? hierarchiesByName.get(parentRef.hierarchy) : undefined;
+                if (!edgeHierarchy)
+                    continue;
+                const levelTypes = levelTypesByName.get(edgeHierarchy.name);
+                const typeIndex = levelTypes.indexOf(nodeType);
+                const parentIndex = levelTypes.indexOf(parentType);
+                // A parent from another hierarchy is invalid; a parent of a type outside every hierarchy is not checked here.
+                if (typeIndex === -1 || (parentIndex === -1 && !allHierarchyTypes.has(parentType)))
                     continue;
-                const level = levels[typeIndex];
+                const level = edgeHierarchy.levels[typeIndex];
                 const canSelfRef = level.selfRef || level.selfRefField !== undefined;
+                const allowSkipLevels = edgeHierarchy.allowSkipLevels ?? false;
                 let isValidHierarchy = false;
-                if (parentIndex === typeIndex - 1) {
+                if (parentIndex === -1) {
+                    isValidHierarchy = false;
+                }
+                else if (parentIndex === typeIndex - 1) {
                     isValidHierarchy = true;
                 }
                 else if (canSelfRef && parentIndex === typeIndex) {

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

@@ -1,10 +1,23 @@
+import type { TrimReport } from '../judge/trim';
+import type { SemanticJudgeProvider } from '../judge/types';
 import type { 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. */
+    judgeTarget?: string;
+    /** Set of node labels that have already failed upstream structural checks. */
+    gatedNodeLabels?: Set<string>;
+    trimReport?: TrimReport;
+}
 /**
  * Validate nodes against rules metadata.
- * Returns a list of rule violations found.
+ * Evaluates expressions and (when opt-in) semantic parts.
  *
  * @param nodes - All nodes in the space
  * @param rules - Rules metadata list
- * @returns Array of rule violations
+ * @param options - Validation options, including the judge for semantic rules
+ * @returns Rule violations
  */
-export declare function validateRules(nodes: SpaceNode[], rules: Rule[]): Promise<RuleViolation[]>;
+export declare function validateRules(nodes: SpaceNode[], rules: Rule[], options?: ValidateRulesOptions): Promise<RuleViolation[]>;

package/dist/schema/validate-rules.js

@@ -1,14 +1,20 @@
-import { buildEvalContext, evaluateExpression } from './evaluate-rule';
+import { judgeNodes } from '../judge/judge-node';
+import { buildSpaceGraph } from '../space-graph';
+import { buildEvalContext, evaluateRuleExpression, expressionErrorViolation, tryEvaluateExpression, } from './evaluate-rule';
+import { ruleSeverities, ruleSeverity } from './rule-severity';
+export { DEFAULT_SEVERITY_BY_CATEGORY, ruleSeverity } from './rule-severity';
 /**
  * Validate nodes against rules metadata.
- * Returns a list of rule violations found.
+ * Evaluates expressions and (when opt-in) semantic parts.
  *
  * @param nodes - All nodes in the space
  * @param rules - Rules metadata list
- * @returns Array of rule violations
+ * @param options - Validation options, including the judge for semantic rules
+ * @returns Rule violations
  */
-export async function validateRules(nodes, rules) {
+export async function validateRules(nodes, rules, options = {}) {
     const violations = [];
+    const judge = options.judge;
     // Build node index for efficient lookups
     const nodeIndex = new Map();
     for (const node of nodes) {
@@ -17,35 +23,91 @@ export async function validateRules(nodes, rules) {
             nodeIndex.set(title, node);
         }
     }
-    // Evaluate each rule against applicable nodes
-    for (const rule of rules) {
-        if (rule.scope === 'global') {
-            // Global rules are evaluated once against the full node set.
-            // A sentinel node provides the evaluation context (nodes array is what matters).
-            const sentinel = nodes[0];
-            if (sentinel) {
-                const context = buildEvalContext(sentinel, nodes, nodeIndex);
-                const result = await evaluateExpression(rule.check, context);
-                if (result !== true) {
-                    violations.push({ file: '', ruleId: rule.id, category: rule.category, description: rule.description });
+    const sentinel = nodes[0];
+    const runnable = rules.filter((r) => r.expression !== undefined || (r.semantic !== undefined && judge));
+    // The nodes each per-node rule applies to: matching `type` and passing the applicability condition (`when`).
+    const applicable = new Map();
+    for (const rule of runnable) {
+        if (rule.global)
+            continue;
+        const matching = [];
+        for (const node of nodes) {
+            if (rule.type && rule.type !== node.resolvedType)
+                continue;
+            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));
+                    continue;
                 }
+                if (when.value !== true)
+                    continue;
             }
+            matching.push(node);
         }
-        else {
-            const targetNodes = rule.type ? nodes.filter((n) => n.resolvedType === rule.type) : nodes;
-            for (const node of targetNodes) {
-                const context = buildEvalContext(node, nodes, nodeIndex);
-                const result = await evaluateExpression(rule.check, context);
-                if (result !== true) {
-                    violations.push({
-                        file: node.label,
-                        ruleId: rule.id,
-                        category: rule.category,
-                        description: rule.description,
-                    });
-                }
-            }
+        applicable.set(rule, matching);
+    }
+    // 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
+    for (const rule of runnable) {
+        if (rule.expression === undefined)
+            continue;
+        if (rule.global) {
+            if (!sentinel)
+                continue;
+            const result = await evaluateRuleExpression(rule, sentinel, nodes, nodeIndex, '');
+            if (!result.passed)
+                violations.push(result.violation);
+            continue;
+        }
+        for (const node of applicable.get(rule) ?? []) {
+            const result = await evaluateRuleExpression(rule, node, nodes, nodeIndex);
+            if (result.passed)
+                continue;
+            violations.push(result.violation);
+            notEvaluable.add(`${rule.id}\0${node.label}`);
+            if (result.failed)
+                failedNodeLabels.add(node.label);
         }
     }
+    // 2. Semantic parts, for nodes that passed their own expression. A node that failed an expression or
+    // upstream is left out (safe cascading default).
+    if (judge) {
+        const perNode = []; // kept in node order
+        const pending = [];
+        for (const node of nodes) {
+            if (options.judgeTarget !== undefined && node.label !== options.judgeTarget)
+                continue;
+            const found = [];
+            perNode.push(found);
+            if (failedNodeLabels.has(node.label))
+                continue;
+            const semantic = runnable.filter((r) => r.semantic !== undefined && applicable.get(r)?.includes(node) && !notEvaluable.has(`${r.id}\0${node.label}`));
+            if (semantic.length > 0)
+                pending.push({ node, rules: semantic, found });
+        }
+        // One provider call for every node, so a provider with `evaluateNodes` can share model calls.
+        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)
+                    continue;
+                found.push({
+                    file: node.label,
+                    ruleId: j.rule.id,
+                    category: j.rule.category,
+                    severity: j.severity ?? ruleSeverities(j.rule)[0] ?? ruleSeverity(j.rule),
+                    description: j.error ? `${j.rule.description} (Semantic evaluation error: ${j.error})` : j.rule.description,
+                    evidence: j.evidence,
+                    ...(j.verdict !== undefined && { verdict: j.verdict }),
+                    ...(j.guidance !== undefined && { guidance: j.guidance }),
+                });
+            }
+        });
+        for (const found of perNode)
+            violations.push(...found);
+    }
     return violations;
 }

package/dist/schemas/_knowledge_wiki.json

@@ -1,6 +1,6 @@
 {
-  "$schema": "https://raw.githubusercontent.com/mindsocket/structured-context/main/schemas/generated/_structured_context_schema_meta.json",
-  "$id": "sctx://_knowledge_wiki",
+  "$schema": "https://raw.githubusercontent.com/mindsocket/structured-context/main/schemas/generated/latest/_structured_context_schema_meta.json",
+  "$id": "sctx://core/_knowledge_wiki",
   // Shared entity definitions for knowledge wiki schemas.
   // Provides aliases, relationships, rules, and entity type $defs.
   // This partial has no hierarchy — wiki entities are flat with no required parent links.
@@ -50,14 +50,14 @@
         "category": "coherence",
         "description": "Syntheses should reference at least one contributing source in their sources array",
         "type": "synthesis",
-        "check": "$exists(current.sources) and $count(current.sources) >= 1"
+        "expression": "$exists(current.sources) and $count(current.sources) >= 1"
       },
       {
         "id": "concept-has-summary",
         "category": "best-practice",
         "description": "Concept pages should have a short summary for index discoverability",
         "type": "concept",
-        "check": "$exists(current.summary) and $length(current.summary) > 0"
+        "expression": "$exists(current.summary) and $length(current.summary) > 0"
       }
     ]
   },
@@ -65,18 +65,18 @@
     "source": {
       "type": "object",
       "description": "A processed summary of a raw source (article, paper, book, video, thread, podcast, etc.). Captures key information from the source in structured form with provenance.",
-      "allOf": [{ "$ref": "sctx://_sctx_base#/$defs/baseNodeProps" }],
+      "allOf": [{ "$ref": "sctx://core/_sctx_base#/$defs/baseNodeProps" }],
       "properties": {
         "type": { "const": "source" },
         "summary": {
-          "$ref": "sctx://_sctx_base#/$defs/summary"
+          "$ref": "sctx://core/_sctx_base#/$defs/summary"
         },
         "url": {
           "type": "string",
           "description": "URL of the original source"
         },
         "local_copy": {
-          "$ref": "sctx://_sctx_base#/$defs/wikilink",
+          "$ref": "sctx://core/_sctx_base#/$defs/wikilink",
           "description": "Wikilink to a local copy of the source (e.g. a saved PDF or clipped note)"
         },
         "author": {
@@ -89,7 +89,7 @@
         },
         "published_date": {
           "type": "string",
-          "format": "date",
+          "format": "date-or-date-time",
           "description": "Original publication date"
         },
         "source_type": {
@@ -98,7 +98,7 @@
         },
         "sources": {
           "type": "array",
-          "items": { "$ref": "sctx://_sctx_base#/$defs/wikilink" },
+          "items": { "$ref": "sctx://core/_sctx_base#/$defs/wikilink" },
           "description": "Wikilinks to other source pages that this one references or extends"
         }
       },
@@ -117,20 +117,20 @@
     "concept": {
       "type": "object",
       "description": "A concept page — defines and frames a specific idea, mechanism, or domain term. May draw from multiple sources. The building blocks of the wiki's knowledge graph.",
-      "allOf": [{ "$ref": "sctx://_sctx_base#/$defs/baseNodeProps" }],
+      "allOf": [{ "$ref": "sctx://core/_sctx_base#/$defs/baseNodeProps" }],
       "properties": {
         "type": { "const": "concept" },
         "summary": {
-          "$ref": "sctx://_sctx_base#/$defs/summary"
+          "$ref": "sctx://core/_sctx_base#/$defs/summary"
         },
         "sources": {
           "type": "array",
-          "items": { "$ref": "sctx://_sctx_base#/$defs/wikilink" },
+          "items": { "$ref": "sctx://core/_sctx_base#/$defs/wikilink" },
           "description": "Wikilinks to source pages that contributed to this concept"
         },
         "related": {
           "type": "array",
-          "items": { "$ref": "sctx://_sctx_base#/$defs/wikilink" },
+          "items": { "$ref": "sctx://core/_sctx_base#/$defs/wikilink" },
           "description": "Wikilinks to related concept or synthesis pages"
         }
       },
@@ -147,20 +147,20 @@
     "entity": {
       "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" }],
+      "allOf": [{ "$ref": "sctx://core/_sctx_base#/$defs/baseNodeProps" }],
       "properties": {
         "type": { "const": "entity" },
         "summary": {
-          "$ref": "sctx://_sctx_base#/$defs/summary"
+          "$ref": "sctx://core/_sctx_base#/$defs/summary"
         },
         "sources": {
           "type": "array",
-          "items": { "$ref": "sctx://_sctx_base#/$defs/wikilink" },
+          "items": { "$ref": "sctx://core/_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" },
+          "items": { "$ref": "sctx://core/_sctx_base#/$defs/wikilink" },
           "description": "Wikilinks to related entity, concept, or synthesis pages"
         }
       },
@@ -177,20 +177,20 @@
     "synthesis": {
       "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.",
-      "allOf": [{ "$ref": "sctx://_sctx_base#/$defs/baseNodeProps" }],
+      "allOf": [{ "$ref": "sctx://core/_sctx_base#/$defs/baseNodeProps" }],
       "properties": {
         "type": { "const": "synthesis" },
         "summary": {
-          "$ref": "sctx://_sctx_base#/$defs/summary"
+          "$ref": "sctx://core/_sctx_base#/$defs/summary"
         },
         "sources": {
           "type": "array",
-          "items": { "$ref": "sctx://_sctx_base#/$defs/wikilink" },
+          "items": { "$ref": "sctx://core/_sctx_base#/$defs/wikilink" },
           "description": "Wikilinks to source pages this synthesis draws from"
         },
         "concepts": {
           "type": "array",
-          "items": { "$ref": "sctx://_sctx_base#/$defs/wikilink" },
+          "items": { "$ref": "sctx://core/_sctx_base#/$defs/wikilink" },
           "description": "Wikilinks to concept pages this synthesis connects"
         }
       },
@@ -208,12 +208,12 @@
     "note": {
       "type": "object",
       "description": "Personal notes, journal entries, talk notes, or rough thoughts not drawn from an external URL.",
-      "allOf": [{ "$ref": "sctx://_sctx_base#/$defs/baseNodeProps" }],
+      "allOf": [{ "$ref": "sctx://core/_sctx_base#/$defs/baseNodeProps" }],
       "properties": {
         "type": { "const": "note" },
         "date": {
           "type": "string",
-          "format": "date",
+          "format": "date-or-date-time",
           "description": "Date this entry was created or relates to"
         }
       },
@@ -230,7 +230,7 @@
     "index": {
       "type": "object",
       "description": "The wiki index — a catalog of all pages with links, summaries, and metadata. Updated by the agent on ingest. Used as the primary navigation entry point.",
-      "allOf": [{ "$ref": "sctx://_sctx_base#/$defs/baseNodeProps" }],
+      "allOf": [{ "$ref": "sctx://core/_sctx_base#/$defs/baseNodeProps" }],
       "properties": {
         "type": { "const": "index" }
       },

package/dist/schemas/_okf.json

@@ -0,0 +1,172 @@
+{
+  "$schema": "https://raw.githubusercontent.com/mindsocket/structured-context/main/schemas/generated/latest/_structured_context_schema_meta.json",
+  "$id": "sctx://core/_okf",
+  // Open Knowledge Format v0.2 frontmatter families: core, provenance, trust, lifecycle, attested computation.
+  // OKF §4.1: consumers MUST NOT reject unknown fields, so every object here allows additional properties.
+  // Concept types are not registered centrally (§4.1), so there is deliberately no oneOf over `type` consts:
+  // type checking would reject every type not listed. `Attested Computation` is handled with if/then instead.
+  // index.md and log.md are reserved bundle files without a `type`; they are reported as excluded during parsing.
+  "$metadata": {
+    "rules": [
+      {
+        "id": "okf-description",
+        "category": "best-practice",
+        "severity": "warning",
+        "description": "Concepts should have a one-line description (used by index generators and search snippets)",
+        "expression": "$exists(current.description) and $length(current.description) > 0"
+      },
+      {
+        "id": "okf-stale-after-generated",
+        "category": "validation",
+        "description": "stale_after must be later than generated.at",
+        "expression": "$not($exists(current.stale_after)) or $not($exists(current.generated.at)) or $toMillis(current.stale_after) > $toMillis(current.generated.at)"
+      },
+      {
+        "id": "okf-usage-count-window",
+        "category": "coherence",
+        "severity": "warning",
+        "description": "A source's usage_count is only meaningful within a usage_window (on the source or shared at the top level)",
+        "expression": "$not($exists(current.sources)) or $count(current.sources[$exists(usage_count) and $not($exists(usage_window)) and $not($exists($$.current.usage_window))]) = 0"
+      },
+      {
+        "id": "okf-computation-present",
+        "category": "validation",
+        "type": "Attested Computation",
+        "description": "An Attested Computation needs its computation: a `computation` path or a body `# Computation` section. Known limitation: the section is found by matching a `# Computation` line in the body text, so such a line inside a code fence also counts",
+        "expression": "$exists(current.computation) or $contains(current.content, /^# Computation[ \\t]*$/m)"
+      }
+    ]
+  },
+  "$defs": {
+    "timestamp": {
+      "type": "string",
+      "format": "date-time",
+      "description": "ISO 8601 datetime with an explicit UTC offset, e.g. 2026-06-30T14:00:00Z (§5)"
+    },
+    "actor": {
+      "type": "string",
+      "minLength": 1,
+      "description": "<producer>/<version> for agents, human:<id> for people, process:<id> for automated processes (§7)"
+    },
+    "usageWindow": {
+      "type": "object",
+      "properties": {
+        "from": { "$ref": "#/$defs/timestamp" },
+        "to": { "$ref": "#/$defs/timestamp" }
+      },
+      "required": ["from", "to"]
+    },
+    "source": {
+      "type": "object",
+      "properties": {
+        "resource": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Followable artifact (URL or path) or a scope descriptor"
+        },
+        "id": { "type": "string", "description": "Stable key for footnote attribution" },
+        "title": { "type": "string" },
+        "author": { "$ref": "#/$defs/actor" },
+        "usage_count": { "type": "integer", "minimum": 0 },
+        "last_modified": { "$ref": "#/$defs/timestamp" },
+        "usage_window": { "$ref": "#/$defs/usageWindow" }
+      },
+      "required": ["resource"]
+    },
+    "generated": {
+      "type": "object",
+      "properties": {
+        "by": { "$ref": "#/$defs/actor" },
+        "at": { "$ref": "#/$defs/timestamp" }
+      },
+      "required": ["by"]
+    },
+    "verification": {
+      "type": "object",
+      "properties": {
+        "by": { "$ref": "#/$defs/actor" },
+        "at": { "$ref": "#/$defs/timestamp" }
+      },
+      "required": ["by", "at"]
+    },
+    "okfProps": {
+      "type": "object",
+      "properties": {
+        "type": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Kind of concept; unregistered and open-ended (§4.1)"
+        },
+        "title": { "type": "string" },
+        "description": { "type": "string" },
+        "resource": { "type": "string", "minLength": 1, "description": "URI or path of the underlying asset" },
+        "tags": { "type": "array", "items": { "type": "string" } },
+        "sources": { "type": "array", "items": { "$ref": "#/$defs/source" } },
+        "usage_window": { "$ref": "#/$defs/usageWindow" },
+        "generated": { "$ref": "#/$defs/generated" },
+        "verified": {
+          "description": "One verification event, or a list of them (§5.2: a bare mapping is a one-element list)",
+          "anyOf": [
+            { "$ref": "#/$defs/verification" },
+            { "type": "array", "items": { "$ref": "#/$defs/verification" } }
+          ]
+        },
+        "status": { "type": "string", "enum": ["draft", "stable", "deprecated"], "default": "stable" },
+        "stale_after": { "$ref": "#/$defs/timestamp" }
+      },
+      "required": ["type"]
+    },
+    "concept": {
+      "type": "object",
+      "allOf": [
+        { "$ref": "#/$defs/okfProps" },
+        {
+          "if": { "properties": { "type": { "const": "Attested Computation" } }, "required": ["type"] },
+          "then": { "$ref": "#/$defs/attestedComputation" }
+        }
+      ],
+      "additionalProperties": true
+    },
+    "attestedComputation": {
+      "type": "object",
+      "properties": {
+        "runtime": {
+          "type": "string",
+          "minLength": 1,
+          "description": "How to run the computation; defines what `parameters` mean (§10.2)"
+        },
+        "parameters": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "name": { "type": "string", "minLength": 1 },
+              "type": { "type": "string", "minLength": 1 },
+              "required": { "type": "boolean" }
+            },
+            "required": ["name", "type"]
+          }
+        },
+        "computation": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Path to a file holding the computation, instead of the body fence"
+        },
+        "executor": {
+          "type": "object",
+          "properties": {
+            "resource": { "type": "string", "minLength": 1 },
+            "receipt": { "type": "array", "items": { "type": "string" }, "description": "Fields a run must return" }
+          },
+          "required": ["resource"]
+        },
+        "attester": {
+          "type": "object",
+          "properties": { "resource": { "type": "string", "minLength": 1 } },
+          "required": ["resource"]
+        }
+      },
+      "required": ["runtime"]
+    }
+  }
+}