fix: address PR review — workflow category, active-parent rule, config validation

- Add `workflow` rule category for process discipline checks; move
  active-outcome/opportunity-count rules from coherence to workflow
- Add `active-node-parent-active` workflow rule: an active node's parent
  must also be active
- Update `solution-quantity` best-practice to only apply when opportunity
  status is exploring or active
- Check `allowSelfRef ⊆ hierarchy` in validate command, reporting
  mismatches as config errors with a new configErrors result field
- Rename schemaErrors/schemaValidCount → nodeErrors/validCount for clarity
- Update docs/rules.md: add workflow category, clarify scope is
  orthogonal to category, update examples

Author: mindsocket

docs/rules.md

@@ -6,12 +6,13 @@ For how rules fit into the broader schema metadata, see [docs/schemas.md](schema
 
 ## Rule Categories
 
-Rules are grouped into three categories under `_metadata.rules`.
+Rules are grouped into categories under `_metadata.rules`. Categories are informational — they determine how violations are labelled and grouped in output, but do not affect how the rule is evaluated. Use `scope` to control evaluation mode.
 
 | Category | Purpose |
 |---|---|
 | `validation` | Structural correctness — a violation means the node is incorrect and should be fixed |
-| `coherence` | Cross-node checks — for flagging conflicts or contradictions (often combined with `scope: 'global'` for multi-node/aggregate checks) |
+| `coherence` | Cross-node checks — for flagging conflicts or contradictions between nodes |
+| `workflow` | Process discipline checks — for keeping the tree in an operational working state (active counts, status consistency) |
 | `bestPractice` | Advisory guidance — signals the space may benefit from additional work |
 
 ## Rule Object Structure
@@ -64,29 +65,28 @@ $exists(parent) = false   // true for root nodes
 
 ```json
 {
-  "coherence": [
+  "workflow": [
     {
       "id": "active-outcome-count",
       "description": "Only one outcome should be active at a time",
       "scope": "global",
       "check": "$count(nodes[resolvedType='outcome' and status='active']) <= 1"
     },
     {
-      "id": "active-opportunity-count",
-      "description": "Only one target opportunity should be active at a time",
-      "scope": "global",
-      "check": "$count(nodes[resolvedType='opportunity' and status='active']) <= 1"
+      "id": "active-node-parent-active",
+      "description": "An active node's parent should also be active",
+      "check": "current.status != 'active' or $exists(parent) = false or parent.status = 'active'"
     }
   ],
   "bestPractice": [
     {
       "id": "solution-quantity",
       "description": "Explore multiple candidate solutions (aim for at least three) for the target opportunity",
       "type": "opportunity",
-      "check": "$count(nodes[resolvedParentTitle=$$.current.title and resolvedType='solution']) >= 3"
+      "check": "(current.status != 'exploring' and current.status != 'active') or $count(nodes[resolvedParentTitle=$$.current.title and resolvedType='solution']) >= 3"
     }
   ]
 }
 ```
 
-The coherence rules run against every node (no `type` filter) — each node in a space with two active outcomes will report a violation. The best-practice rule only runs against `opportunity` nodes, using `resolvedParentTitle` to count child solutions.
+The first workflow rule uses `scope: 'global'` — evaluated once against the whole space, producing at most one violation. The second runs per-node with no `type` filter, checking every node. The best-practice rule only runs against `opportunity` nodes where status is `exploring` or `active`, using `resolvedParentTitle` to count child solutions.

schemas/_strict.json

@@ -9,7 +9,7 @@
       "hierarchy": ["outcome", "opportunity", "solution", "assumption_test"],
       "allowSelfRef": ["opportunity"],
       "rules": {
-        "coherence": [
+        "workflow": [
           {
             "id": "active-outcome-count",
             "description": "Only one outcome should be active at a time",
@@ -21,14 +21,19 @@
             "description": "Only one target opportunity should be active at a time",
             "scope": "global",
             "check": "$count(nodes[resolvedType='opportunity' and status='active']) <= 1"
+          },
+          {
+            "id": "active-node-parent-active",
+            "description": "An active node's parent should also be active",
+            "check": "current.status != 'active' or $exists(parent) = false or parent.status = 'active'"
           }
         ],
         "bestPractice": [
           {
             "id": "solution-quantity",
             "description": "Explore multiple candidate solutions (aim for at least three) for the target opportunity",
             "type": "opportunity",
-            "check": "$count(nodes[resolvedParentTitle=$$.current.title and resolvedType='solution']) >= 3"
+            "check": "(current.status != 'exploring' and current.status != 'active') or $count(nodes[resolvedParentTitle=$$.current.title and resolvedType='solution']) >= 3"
           }
         ]
       }

src/commands/validate.ts

@@ -9,10 +9,11 @@ import { validateHierarchy } from '../validate-hierarchy';
 import { validateRules } from '../validate-rules';
 
 interface ValidationResult {
-  schemaValidCount: number;
-  schemaErrorCount: number;
-  schemaErrors: Array<{ file: string; errors: ErrorObject[] }>;
+  validCount: number;
+  nodeErrorCount: number;
+  nodeErrors: Array<{ file: string; errors: ErrorObject[] }>;
   refErrors: Array<{ file: string; parent: string; error: string }>;
+  configErrors: string[];
   ruleViolations: RuleViolation[];
   hierarchyViolations: HierarchyViolation[];
   skipped: string[];
@@ -33,10 +34,11 @@ export async function validate(path: string, options: { schema: string }): Promi
   }
 
   const result: ValidationResult = {
-    schemaValidCount: 0,
-    schemaErrorCount: 0,
-    schemaErrors: [],
+    validCount: 0,
+    nodeErrorCount: 0,
+    nodeErrors: [],
     refErrors: [],
+    configErrors: [],
     ruleViolations: [],
     hierarchyViolations: [],
     skipped,
@@ -47,10 +49,10 @@ export async function validate(path: string, options: { schema: string }): Promi
     const valid = validateFunc(node.schemaData);
 
     if (valid) {
-      result.schemaValidCount++;
+      result.validCount++;
     } else {
-      result.schemaErrorCount++;
-      result.schemaErrors.push({
+      result.nodeErrorCount++;
+      result.nodeErrors.push({
         file: node.label,
         errors: validateFunc.errors || [],
       });
@@ -88,6 +90,13 @@ export async function validate(path: string, options: { schema: string }): Promi
 
   // Load and execute hierarchy validation if schema defines hierarchy
   const metadata = loadMetadata(options.schema);
+
+  // Validate schema metadata configuration
+  const badSelfRefTypes = (metadata.allowSelfRef ?? []).filter((t) => !metadata.hierarchy.includes(t));
+  for (const t of badSelfRefTypes) {
+    result.configErrors.push(`allowSelfRef contains "${t}" which is not in the hierarchy`);
+  }
+
   result.hierarchyViolations = validateHierarchy(nodes, metadata);
 
   // Load and execute rules validation if schema defines rules
@@ -98,11 +107,12 @@ export async function validate(path: string, options: { schema: string }): Promi
   // Report
   console.log(`\n🔍 Space Validation Results`);
   console.log(`━`.repeat(50));
-  console.log(`✅ Valid: ${result.schemaValidCount}`);
-  console.log(`❌ Schema Errors: ${result.schemaErrorCount}`);
+  console.log(`✅ Valid: ${result.validCount}`);
+  console.log(`❌ Node Errors: ${result.nodeErrorCount}`);
   console.log(`🔗 Reference Errors: ${result.refErrors.length}`);
+  console.log(`⚙️ Config Errors: ${result.configErrors.length}`);
   console.log(`📋 Rule Violations: ${result.ruleViolations.length}`);
-  console.log(`🏗️  Hierarchy Violations: ${result.hierarchyViolations.length}`);
+  console.log(`🏗️ Hierarchy Violations: ${result.hierarchyViolations.length}`);
   console.log(`⏭ Skipped (no frontmatter): ${result.skipped.length}`);
   console.log(`📄 Non-space (no type field): ${result.nonSpace.length}`);
 
@@ -116,9 +126,9 @@ export async function validate(path: string, options: { schema: string }): Promi
     for (const f of result.nonSpace) console.log(`   ${f}`);
   }
 
-  if (result.schemaErrors.length > 0) {
-    console.log(`\n❌ Schema validation errors:`);
-    result.schemaErrors.forEach(({ file, errors }) => {
+  if (result.nodeErrors.length > 0) {
+    console.log(`\n❌ Node errors:`);
+    result.nodeErrors.forEach(({ file, errors }) => {
       console.log(`\n   ${file}:`);
       errors.forEach((err: ErrorObject) => {
         console.log(`      ${err.instancePath || 'root'}: ${err.message}`);
@@ -133,6 +143,13 @@ export async function validate(path: string, options: { schema: string }): Promi
     });
   }
 
+  if (result.configErrors.length > 0) {
+    console.log(`\n⚙️  Config errors:`);
+    for (const e of result.configErrors) {
+      console.log(`   ${e}`);
+    }
+  }
+
   if (result.ruleViolations.length > 0) {
     console.log(`\n📋 Rule violations:`);
 
@@ -164,8 +181,9 @@ export async function validate(path: string, options: { schema: string }): Promi
   console.log(`\n`);
 
   if (
-    result.schemaErrorCount > 0 ||
+    result.nodeErrorCount > 0 ||
     result.refErrors.length > 0 ||
+    result.configErrors.length > 0 ||
     result.ruleViolations.length > 0 ||
     result.hierarchyViolations.length > 0
   ) {

src/types.ts

@@ -30,7 +30,7 @@ export interface SpaceDirectoryReadResult {
 }
 
 /** Rule categories for organizing executable validation rules */
-export type RuleCategory = 'validation' | 'coherence' | 'best-practice';
+export type RuleCategory = 'validation' | 'coherence' | 'workflow' | 'best-practice';
 
 /** A single executable rule with JSONata check expression */
 export interface Rule {
@@ -47,6 +47,7 @@ export interface Rule {
 export interface RulesMetadata {
   validation?: Rule[];
   coherence?: Rule[];
+  workflow?: Rule[];
   bestPractice?: Rule[];
 }
 

src/validate-rules.ts

@@ -25,6 +25,7 @@ export async function validateRules(nodes: SpaceNode[], rules: RulesMetadata): P
   const allCategories: Array<{ category: RuleCategory; rules: Rule[] }> = [
     { category: 'validation', rules: rules.validation ?? [] },
     { category: 'coherence', rules: rules.coherence ?? [] },
+    { category: 'workflow', rules: rules.workflow ?? [] },
     { category: 'best-practice', rules: rules.bestPractice ?? [] },
   ];