@forwardimpact/pathway 0.1.0 → 0.2.0

package/app/model/loader.js

@@ -121,6 +121,11 @@ async function loadDisciplinesFromDir(disciplinesDir) {
       const {
         specialization,
         roleTitle,
+        // Track constraints
+        isProfessional,
+        isManagement,
+        validTracks,
+        minGrade,
         // Shared content - now at root level
         description,
         // Structural properties (derivation inputs) - at top level
@@ -136,6 +141,11 @@ async function loadDisciplinesFromDir(disciplinesDir) {
         id,
         specialization,
         roleTitle,
+        // Track constraints
+        isProfessional,
+        isManagement,
+        validTracks,
+        minGrade,
         // Shared content at top level
         description,
         // Structural properties at top level
@@ -175,12 +185,10 @@ async function loadTracksFromDir(tracksDir) {
         description,
         roleContext,
         // Structural properties (derivation inputs) - at top level
-        isProfessional,
-        isManagement,
         skillModifiers,
         behaviourModifiers,
         assessmentWeights,
-        validDisciplines,
+        minGrade,
         // Agent section (no human section anymore for tracks)
         agent,
       } = content;
@@ -191,12 +199,10 @@ async function loadTracksFromDir(tracksDir) {
         description,
         roleContext,
         // Structural properties at top level
-        isProfessional,
-        isManagement,
         skillModifiers,
         behaviourModifiers,
         assessmentWeights,
-        validDisciplines,
+        minGrade,
         // Preserve agent section for agent generation
         ...(agent && { agent }),
       };
@@ -486,7 +492,7 @@ export function loadAndValidate(data, options = {}) {
  * Load agent-specific data for agent profile generation
  * Uses co-located files: each entity file contains both human and agent sections
  * @param {string} dataDir - Path to the data directory
- * @returns {Promise<Object>} Agent data including disciplines, tracks, behaviours, vscodeSettings
+ * @returns {Promise<Object>} Agent data including disciplines, tracks, behaviours, vscodeSettings, devcontainer, copilotSetupSteps
  */
 export async function loadAgentData(dataDir) {
   const disciplinesDir = join(dataDir, "disciplines");
@@ -494,15 +500,27 @@ export async function loadAgentData(dataDir) {
   const behavioursDir = join(dataDir, "behaviours");
 
   // Load from co-located files
-  const [disciplineFiles, trackFiles, behaviourFiles, vscodeSettings] =
-    await Promise.all([
-      loadDisciplinesFromDir(disciplinesDir),
-      loadTracksFromDir(tracksDir),
-      loadBehavioursFromDir(behavioursDir),
-      fileExists(join(dataDir, "vscode-settings.yaml"))
-        ? loadYamlFile(join(dataDir, "vscode-settings.yaml"))
-        : {},
-    ]);
+  const [
+    disciplineFiles,
+    trackFiles,
+    behaviourFiles,
+    vscodeSettings,
+    devcontainer,
+    copilotSetupSteps,
+  ] = await Promise.all([
+    loadDisciplinesFromDir(disciplinesDir),
+    loadTracksFromDir(tracksDir),
+    loadBehavioursFromDir(behavioursDir),
+    fileExists(join(dataDir, "vscode-settings.yaml"))
+      ? loadYamlFile(join(dataDir, "vscode-settings.yaml"))
+      : {},
+    fileExists(join(dataDir, "devcontainer.yaml"))
+      ? loadYamlFile(join(dataDir, "devcontainer.yaml"))
+      : {},
+    fileExists(join(dataDir, "copilot-setup-steps.yaml"))
+      ? loadYamlFile(join(dataDir, "copilot-setup-steps.yaml"))
+      : null,
+  ]);
 
   // Extract agent sections from co-located files
   const disciplines = disciplineFiles
@@ -531,6 +549,8 @@ export async function loadAgentData(dataDir) {
     tracks,
     behaviours,
     vscodeSettings,
+    devcontainer,
+    copilotSetupSteps,
   };
 }
 
@@ -551,11 +571,15 @@ export async function loadSkillsWithAgentData(dataDir) {
   const allSkills = [];
 
   for (const file of yamlFiles) {
+    const capabilityId = basename(file, ".yaml"); // Derive ID from filename
     const capability = await loadYamlFile(join(capabilitiesDir, file));
 
     if (capability.skills && Array.isArray(capability.skills)) {
       for (const skill of capability.skills) {
-        allSkills.push(skill);
+        allSkills.push({
+          ...skill,
+          capability: capabilityId, // Add capability from parent filename
+        });
       }
     }
   }

package/app/model/matching.js

@@ -275,9 +275,9 @@ function calculateExpectationsScore(selfExpectations, jobExpectations) {
  * @returns {import('./levels.js').MatchAnalysis}
  */
 export function calculateJobMatch(selfAssessment, job) {
-  // Get weights from track or use defaults
-  const skillWeight = job.track.assessmentWeights?.skillWeight ?? 0.5;
-  const behaviourWeight = job.track.assessmentWeights?.behaviourWeight ?? 0.5;
+  // Get weights from track or use defaults (track may be null for trackless jobs)
+  const skillWeight = job.track?.assessmentWeights?.skillWeight ?? 0.5;
+  const behaviourWeight = job.track?.assessmentWeights?.behaviourWeight ?? 0.5;
 
   // Calculate skill score
   const skillResult = calculateSkillScore(
@@ -362,6 +362,36 @@ export function findMatchingJobs({
 
   // Generate all valid job combinations
   for (const discipline of disciplines) {
+    // First generate trackless jobs for each discipline × grade
+    for (const grade of grades) {
+      if (
+        !isValidJobCombination({
+          discipline,
+          grade,
+          track: null,
+          validationRules,
+          grades,
+        })
+      ) {
+        continue;
+      }
+
+      const job = deriveJob({
+        discipline,
+        grade,
+        track: null,
+        skills,
+        behaviours,
+        validationRules,
+      });
+
+      if (job) {
+        const analysis = calculateJobMatch(selfAssessment, job);
+        matches.push({ job, analysis });
+      }
+    }
+
+    // Then generate jobs with valid tracks
     for (const track of tracks) {
       for (const grade of grades) {
         // Skip invalid combinations

package/app/model/profile.js

@@ -10,6 +10,10 @@
  *
  * The core derivation (deriveSkillMatrix, deriveBehaviourProfile) remains in
  * derivation.js. This module adds post-processing for specific use cases.
+ *
+ * Agent filtering keeps only skills at the highest derived level. This ensures
+ * track modifiers are respected—a broad skill boosted by a +1 track modifier
+ * may reach the same level as primary skills and thus be included.
  */
 
 import { SKILL_LEVEL_ORDER, BEHAVIOUR_MATURITY_ORDER } from "./levels.js";
@@ -47,44 +51,40 @@ export function filterHumanOnlySkills(skillMatrix) {
 }
 
 /**
- * Filter broad skills without positive track modifier
- * Keeps broad skills only if their capability has a positive track modifier
- * @param {Array} skillMatrix - Skill matrix entries
- * @param {Set<string>} positiveCapabilities - Capabilities with positive modifiers
- * @returns {Array} Filtered skill matrix
+ * Filter skills to keep only those at the highest derived level
+ * After track modifiers are applied, some skills will be at higher levels
+ * than others. This filter keeps only the skills at the maximum level.
+ * @param {Array} skillMatrix - Skill matrix entries with derived levels
+ * @returns {Array} Filtered skill matrix containing only highest-level skills
  */
-export function filterBroadWithoutPositiveModifier(
-  skillMatrix,
-  positiveCapabilities,
-) {
+export function filterByHighestLevel(skillMatrix) {
+  if (skillMatrix.length === 0) return [];
+
+  // Find the highest level index in the matrix
+  const maxLevelIndex = Math.max(
+    ...skillMatrix.map((entry) => SKILL_LEVEL_ORDER.indexOf(entry.level)),
+  );
+
+  // Keep only skills at that level
   return skillMatrix.filter(
-    (entry) =>
-      entry.type !== "broad" || positiveCapabilities.has(entry.capability),
+    (entry) => SKILL_LEVEL_ORDER.indexOf(entry.level) === maxLevelIndex,
   );
 }
 
 /**
  * Apply agent-specific skill filters
- * Combines humanOnly and broad skill filtering for agent profiles
- * @param {Array} skillMatrix - Skill matrix entries
- * @param {Object} track - Track definition (for modifier lookup)
+ * Filters to human-only skills and keeps only skills at the highest derived level.
+ * This approach respects track modifiers—a broad skill boosted to the same level
+ * as primary skills will be included.
+ * @param {Array} skillMatrix - Skill matrix entries with derived levels
  * @returns {Array} Filtered skill matrix
  */
-export function filterSkillsForAgent(skillMatrix, track) {
-  const positiveCapabilities = getPositiveTrackCapabilities(track);
+export function filterSkillsForAgent(skillMatrix) {
+  // First exclude human-only skills
+  const withoutHumanOnly = filterHumanOnlySkills(skillMatrix);
 
-  return skillMatrix.filter((entry) => {
-    // Exclude human-only skills
-    if (entry.isHumanOnly) {
-      return false;
-    }
-    // For broad skills, only include if capability has positive modifier
-    if (entry.type === "broad") {
-      return positiveCapabilities.has(entry.capability);
-    }
-    // Include primary, secondary, and track-added skills
-    return true;
-  });
+  // Then keep only skills at the highest level
+  return filterByHighestLevel(withoutHumanOnly);
 }
 
 // =============================================================================
@@ -126,7 +126,7 @@ export function sortByMaturityDescending(behaviourProfile) {
 /**
  * @typedef {Object} ProfileOptions
  * @property {boolean} [excludeHumanOnly=false] - Filter out human-only skills
- * @property {boolean} [excludeBroadWithoutPositiveModifier=false] - Filter broad skills
+ * @property {boolean} [keepHighestLevelOnly=false] - Keep only skills at the highest derived level
  * @property {boolean} [sortByLevel=false] - Sort skills by level descending
  * @property {boolean} [sortByMaturity=false] - Sort behaviours by maturity descending
  */
@@ -148,7 +148,7 @@ export function sortByMaturityDescending(behaviourProfile) {
  * and AI agents use this function, with different options:
  *
  * - Human jobs: No filtering, default sorting by type
- * - AI agents: Filter humanOnly, filter broad without positive modifier, sort by level
+ * - AI agents: Filter humanOnly, keep only highest-level skills, sort by level
  *
  * @param {Object} params
  * @param {Object} params.discipline - The discipline
@@ -171,7 +171,7 @@ export function prepareBaseProfile({
 }) {
   const {
     excludeHumanOnly = false,
-    excludeBroadWithoutPositiveModifier = false,
+    keepHighestLevelOnly = false,
     sortByLevel = false,
     sortByMaturity = false,
   } = options;
@@ -186,18 +186,11 @@ export function prepareBaseProfile({
   });
 
   // Apply skill filters
-  if (excludeHumanOnly || excludeBroadWithoutPositiveModifier) {
-    const positiveCapabilities = getPositiveTrackCapabilities(track);
-
-    if (excludeHumanOnly) {
-      skillMatrix = filterHumanOnlySkills(skillMatrix);
-    }
-    if (excludeBroadWithoutPositiveModifier) {
-      skillMatrix = filterBroadWithoutPositiveModifier(
-        skillMatrix,
-        positiveCapabilities,
-      );
-    }
+  if (excludeHumanOnly) {
+    skillMatrix = filterHumanOnlySkills(skillMatrix);
+  }
+  if (keepHighestLevelOnly) {
+    skillMatrix = filterByHighestLevel(skillMatrix);
   }
 
   // Apply sorting
@@ -230,12 +223,12 @@ export function prepareBaseProfile({
 
 /**
  * Preset options for agent profile derivation
- * Excludes human-only skills, excludes broad skills without positive modifiers,
+ * Excludes human-only skills, keeps only skills at the highest derived level,
  * and sorts by level/maturity descending
  */
 export const AGENT_PROFILE_OPTIONS = {
   excludeHumanOnly: true,
-  excludeBroadWithoutPositiveModifier: true,
+  keepHighestLevelOnly: true,
   sortByLevel: true,
   sortByMaturity: true,
 };