@forwardimpact/schema 0.6.0 → 0.8.0

package/schema/rdf/stages.ttl

@@ -28,14 +28,14 @@ fit:handoffs a rdf:Property ;
     rdfs:domain fit:Stage ;
     rdfs:range fit:Handoff .
 
-fit:entryCriteria a rdf:Property ;
-    rdfs:label "entryCriteria"@en ;
-    rdfs:comment "Conditions that must be met before entering this stage"@en ;
+fit:readChecklist a rdf:Property ;
+    rdfs:label "readChecklist"@en ;
+    rdfs:comment "Read-Then-Do Checklist: steps to follow in order during this stage"@en ;
     rdfs:range xsd:string .
 
-fit:exitCriteria a rdf:Property ;
-    rdfs:label "exitCriteria"@en ;
-    rdfs:comment "Conditions that must be met before leaving this stage"@en ;
+fit:confirmChecklist a rdf:Property ;
+    rdfs:label "confirmChecklist"@en ;
+    rdfs:comment "Do-Then-Confirm Checklist: items to verify before handing off to next stage"@en ;
     rdfs:range xsd:string .
 
 fit:summary a rdf:Property ;
@@ -74,7 +74,7 @@ fit:StageShape a sh:NodeShape ;
     sh:targetClass fit:Stage ;
     sh:property [
         sh:path fit:id ;
-        sh:in ( "specify" "plan" "code" "review" "deploy" ) ;
+        sh:in ( "specify" "plan" "onboard" "code" "review" "deploy" ) ;
         sh:minCount 1 ;
         sh:maxCount 1 ;
         sh:name "id" ;
@@ -122,16 +122,16 @@ fit:StageShape a sh:NodeShape ;
         sh:description "Restrictions on behaviour in this stage" ;
     ] ;
     sh:property [
-        sh:path fit:entryCriteria ;
+        sh:path fit:readChecklist ;
         sh:datatype xsd:string ;
-        sh:name "entryCriteria" ;
-        sh:description "Conditions that must be met before entering this stage" ;
+        sh:name "readChecklist" ;
+        sh:description "Read-Then-Do Checklist: steps to follow in order during this stage" ;
     ] ;
     sh:property [
-        sh:path fit:exitCriteria ;
+        sh:path fit:confirmChecklist ;
         sh:datatype xsd:string ;
-        sh:name "exitCriteria" ;
-        sh:description "Conditions that must be met before leaving this stage" ;
+        sh:name "confirmChecklist" ;
+        sh:description "Do-Then-Confirm Checklist: items to verify before handing off to next stage" ;
     ] .
 
 # -----------------------------------------------------------------------------
@@ -142,7 +142,7 @@ fit:HandoffShape a sh:NodeShape ;
     sh:targetClass fit:Handoff ;
     sh:property [
         sh:path fit:targetStage ;
-        sh:in ( "specify" "plan" "code" "review" "deploy" ) ;
+        sh:in ( "specify" "plan" "onboard" "code" "review" "deploy" ) ;
         sh:minCount 1 ;
         sh:maxCount 1 ;
         sh:name "targetStage" ;

package/src/levels.js

@@ -54,30 +54,25 @@ export const BEHAVIOUR_MATURITY_ORDER = [
   BehaviourMaturity.EXEMPLIFYING,
 ];
 
-/**
- * Lifecycle stages for development workflow
- * @readonly
- * @enum {string}
- */
-export const Stage = {
-  SPECIFY: "specify",
-  PLAN: "plan",
-  CODE: "code",
-  REVIEW: "review",
-  DEPLOY: "deploy",
-};
+// ============================================================================
+// Data-driven Stage Functions
+// ============================================================================
+// Stage ordering is derived from loaded stage data, not hardcoded.
+// Use getStageOrder(stages) to get stage IDs in lifecycle order.
 
 /**
- * Ordered array of stages for lifecycle progression
- * @type {string[]}
+ * Get ordered stage IDs from loaded stage data
+ *
+ * Stages are defined in stages.yaml and their array order IS the
+ * canonical lifecycle order. This function extracts IDs preserving
+ * that order, similar to getCapabilityOrder for capabilities.
+ *
+ * @param {Object[]} stages - Loaded stages array from stages.yaml
+ * @returns {string[]} Stage IDs in lifecycle order
  */
-export const STAGE_ORDER = [
-  Stage.SPECIFY,
-  Stage.PLAN,
-  Stage.CODE,
-  Stage.REVIEW,
-  Stage.DEPLOY,
-];
+export function getStageOrder(stages) {
+  return stages.map((s) => s.id);
+}
 
 /**
  * Skill capabilities (what capability area)

package/src/validation.js

@@ -6,7 +6,6 @@
 
 import {
   Capability,
-  Stage,
   getSkillLevelIndex,
   getBehaviourMaturityIndex,
 } from "./levels.js";
@@ -150,14 +149,16 @@ function validateSkill(skill, index, requiredStageIds = []) {
         ),
       );
     } else {
-      // Validate each stage
-      const validStageIds = Object.values(Stage);
+      // Validate each stage against loaded stage data
       for (const [stageId, stageData] of Object.entries(skill.agent.stages)) {
-        if (!validStageIds.includes(stageId)) {
+        if (
+          requiredStageIds.length > 0 &&
+          !requiredStageIds.includes(stageId)
+        ) {
           errors.push(
             createError(
               "INVALID_VALUE",
-              `Invalid stage ID: ${stageId}. Must be one of: ${validStageIds.join(", ")}`,
+              `Invalid stage ID: ${stageId}. Must be one of: ${requiredStageIds.join(", ")}`,
               `${agentPath}.stages.${stageId}`,
               stageId,
             ),
@@ -184,41 +185,41 @@ function validateSkill(skill, index, requiredStageIds = []) {
             ),
           );
         }
-        // activities is required and must be an array
-        if (!stageData.activities) {
+        // readChecklist is required and must be an array
+        if (!stageData.readChecklist) {
           errors.push(
             createError(
               "MISSING_REQUIRED",
-              `Stage ${stageId} missing activities`,
-              `${stagePath}.activities`,
+              `Stage ${stageId} missing readChecklist`,
+              `${stagePath}.readChecklist`,
             ),
           );
-        } else if (!Array.isArray(stageData.activities)) {
+        } else if (!Array.isArray(stageData.readChecklist)) {
           errors.push(
             createError(
               "INVALID_VALUE",
-              `Stage ${stageId} activities must be an array`,
-              `${stagePath}.activities`,
-              stageData.activities,
+              `Stage ${stageId} readChecklist must be an array`,
+              `${stagePath}.readChecklist`,
+              stageData.readChecklist,
             ),
           );
         }
-        // ready is required and must be an array (these become checklist items)
-        if (!stageData.ready) {
+        // confirmChecklist is required and must be an array (these become checklist items)
+        if (!stageData.confirmChecklist) {
           errors.push(
             createError(
               "MISSING_REQUIRED",
-              `Stage ${stageId} missing ready criteria`,
-              `${stagePath}.ready`,
+              `Stage ${stageId} missing confirmChecklist`,
+              `${stagePath}.confirmChecklist`,
             ),
           );
-        } else if (!Array.isArray(stageData.ready)) {
+        } else if (!Array.isArray(stageData.confirmChecklist)) {
           errors.push(
             createError(
               "INVALID_VALUE",
-              `Stage ${stageId} ready must be an array`,
-              `${stagePath}.ready`,
-              stageData.ready,
+              `Stage ${stageId} confirmChecklist must be an array`,
+              `${stagePath}.confirmChecklist`,
+              stageData.confirmChecklist,
             ),
           );
         }
@@ -284,7 +285,7 @@ function validateSkill(skill, index, requiredStageIds = []) {
       errors.push(
         createError(
           "INVALID_FIELD",
-          "Skill agent 'verificationCriteria' field is not supported. Use stages.{stage}.ready instead.",
+          "Skill agent 'verificationCriteria' field is not supported. Use stages.{stage}.confirmChecklist instead.",
           `${agentPath}.verificationCriteria`,
         ),
       );
@@ -1249,15 +1250,6 @@ function validateStage(stage, index) {
 
   if (!stage.id) {
     errors.push(createError("MISSING_REQUIRED", "Stage missing id", path));
-  } else if (!Object.values(Stage).includes(stage.id)) {
-    errors.push(
-      createError(
-        "INVALID_VALUE",
-        `Invalid stage id: ${stage.id}`,
-        `${path}.id`,
-        stage.id,
-      ),
-    );
   }
 
   if (!stage.name) {
@@ -1997,7 +1989,7 @@ export function validateAgentData({ humanData, agentData }) {
 
   // Validate skills with agent sections have complete stage coverage
   const skillsWithAgent = (humanData.skills || []).filter((s) => s.agent);
-  const requiredStages = ["plan", "code", "review"];
+  const requiredStages = ["plan", "onboard", "code", "review"];
 
   for (const skill of skillsWithAgent) {
     const stages = skill.agent.stages || {};
@@ -2025,28 +2017,28 @@ export function validateAgentData({ humanData, agentData }) {
         );
       }
       if (
-        !stageData.activities ||
-        !Array.isArray(stageData.activities) ||
-        stageData.activities.length === 0
+        !stageData.readChecklist ||
+        !Array.isArray(stageData.readChecklist) ||
+        stageData.readChecklist.length === 0
       ) {
         errors.push(
           createError(
             "MISSING_REQUIRED",
-            `Skill '${skill.id}' agent stage '${stageId}' missing or empty activities`,
-            `skills.${skill.id}.agent.stages.${stageId}.activities`,
+            `Skill '${skill.id}' agent stage '${stageId}' missing or empty readChecklist`,
+            `skills.${skill.id}.agent.stages.${stageId}.readChecklist`,
           ),
         );
       }
       if (
-        !stageData.ready ||
-        !Array.isArray(stageData.ready) ||
-        stageData.ready.length === 0
+        !stageData.confirmChecklist ||
+        !Array.isArray(stageData.confirmChecklist) ||
+        stageData.confirmChecklist.length === 0
       ) {
         errors.push(
           createError(
             "MISSING_REQUIRED",
-            `Skill '${skill.id}' agent stage '${stageId}' missing or empty ready criteria`,
-            `skills.${skill.id}.agent.stages.${stageId}.ready`,
+            `Skill '${skill.id}' agent stage '${stageId}' missing or empty confirmChecklist`,
+            `skills.${skill.id}.agent.stages.${stageId}.confirmChecklist`,
           ),
         );
       }