@forwardimpact/pathway 0.12.0 → 0.13.0

package/bin/fit-pathway.js

@@ -18,7 +18,7 @@
  *   stage [<id>]                Show stages
  *   tool [<name>]               Show tools
  *   job [<discipline> <grade>] [--track=TRACK]  Generate job definition
- *   interview <discipline> <grade> [--track=TRACK] [--type=TYPE]  Generate interview
+ *   interview <discipline> <grade> [--track=TRACK] [--type=mission|decomposition|stakeholder]  Generate interview
  *   progress <discipline> <grade> [--track=TRACK] [--compare=GRADE]  Career progression
  *   questions [options]         Browse interview questions
  *   agent [<discipline> <track>] [--output=PATH]  Generate AI agent
@@ -167,13 +167,14 @@ INTERVIEW COMMAND
 Generate interview question sets based on job requirements.
 
 Usage:
-  npx fit-pathway interview <discipline> <grade>
-  npx fit-pathway interview <d> <g> --track=<track>
-  npx fit-pathway interview <d> <g> --type=<type>
+  npx fit-pathway interview <discipline> <grade>                     All types
+  npx fit-pathway interview <d> <g> --track=<track>                  With track
+  npx fit-pathway interview <d> <g> --track=<t> --type=<type>        Single type
 
 Options:
   --track=TRACK       Track specialization
-  --type=TYPE         Interview type: full (default), short
+  --type=TYPE         Interview type: mission, decomposition, stakeholder
+                      (omit for all types)
 
 ────────────────────────────────────────────────────────────────────────────────
 PROGRESS COMMAND

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forwardimpact/pathway",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Career progression web app and CLI for exploring roles and generating agents",
   "license": "Apache-2.0",
   "repository": {
@@ -40,8 +40,8 @@
     "./commands": "./src/commands/index.js"
   },
   "dependencies": {
-    "@forwardimpact/schema": "^0.5.0",
-    "@forwardimpact/model": "^0.6.0",
+    "@forwardimpact/schema": "^0.6.0",
+    "@forwardimpact/model": "^0.7.0",
     "mustache": "^4.2.0",
     "simple-icons": "^16.7.0",
     "yaml": "^2.3.4"

package/src/commands/interview.js

@@ -4,9 +4,9 @@
  * Generates and displays interview questions in the terminal.
  *
  * Usage:
- *   npx pathway interview <discipline> <grade>                    # Interview for trackless job
- *   npx pathway interview <discipline> <grade> --track=<track>    # Interview with track
- *   npx pathway interview <discipline> <grade> --track=<track> --type=short
+ *   npx fit-pathway interview <discipline> <grade>                                  # All interview types
+ *   npx fit-pathway interview <discipline> <grade> --track=<track>                  # With track
+ *   npx fit-pathway interview <discipline> <grade> --track=<track> --type=mission   # Single type
  */
 
 import { createCompositeCommand } from "./command-factory.js";
@@ -16,8 +16,10 @@ import {
 } from "../formatters/interview/shared.js";
 import { interviewToMarkdown } from "../formatters/interview/markdown.js";
 
+const VALID_TYPES = Object.keys(INTERVIEW_TYPES);
+
 /**
- * Format interview output
+ * Format a single interview type as markdown
  * @param {Object} view - Presenter view
  * @param {Object} options - Options including framework
  */
@@ -25,15 +27,31 @@ function formatInterview(view, options) {
   console.log(interviewToMarkdown(view, { framework: options.framework }));
 }
 
+/**
+ * Format all interview types as markdown with separators
+ * @param {Array<Object>} views - Array of presenter views
+ * @param {Object} options - Options including framework
+ */
+function formatAllInterviews(views, options) {
+  for (let i = 0; i < views.length; i++) {
+    if (i > 0) {
+      console.log("\n" + "─".repeat(80) + "\n");
+    }
+    console.log(
+      interviewToMarkdown(views[i], { framework: options.framework }),
+    );
+  }
+}
+
 export const runInterviewCommand = createCompositeCommand({
   commandName: "interview",
   requiredArgs: ["discipline_id", "grade_id"],
   findEntities: (data, args, options) => {
-    const interviewType = options.type || "full";
+    const interviewType = options.type === "full" ? null : options.type;
 
-    if (!INTERVIEW_TYPES[interviewType]) {
+    if (interviewType && !INTERVIEW_TYPES[interviewType]) {
       console.error(`Unknown interview type: ${interviewType}`);
-      console.error("Available types: full, short, behaviour");
+      console.error(`Available types: ${VALID_TYPES.join(", ")}`);
       process.exit(1);
     }
 
@@ -58,18 +76,38 @@ export const runInterviewCommand = createCompositeCommand({
     }
     return null;
   },
-  presenter: (entities, data, _options) =>
-    prepareInterviewDetail({
+  presenter: (entities, data, _options) => {
+    const params = {
       discipline: entities.discipline,
       grade: entities.grade,
       track: entities.track,
       skills: data.skills,
       behaviours: data.behaviours,
       questions: data.questions,
-      interviewType: entities.interviewType,
-    }),
-  formatter: (view, options, data) =>
-    formatInterview(view, { ...options, framework: data.framework }),
+    };
+
+    // Single type: return one view
+    if (entities.interviewType) {
+      return prepareInterviewDetail({
+        ...params,
+        interviewType: entities.interviewType,
+      });
+    }
+
+    // All types: return array of views
+    return VALID_TYPES.map((type) =>
+      prepareInterviewDetail({ ...params, interviewType: type }),
+    ).filter(Boolean);
+  },
+  formatter: (view, options, data) => {
+    const opts = { ...options, framework: data.framework };
+
+    if (Array.isArray(view)) {
+      formatAllInterviews(view, opts);
+    } else {
+      formatInterview(view, opts);
+    }
+  },
   usageExample:
-    "npx pathway interview software_engineering L4 --track=platform --type=short",
+    "npx fit-pathway interview software_engineering J090 --track=platform --type=mission",
 });

package/src/commands/questions.js

@@ -56,12 +56,15 @@ function showQuestionsSummary(data) {
     "practitioner",
     "expert",
   ];
+  const roleTypes = ["professionalQuestions", "managementQuestions"];
   const skillRows = skillLevels.map((level) => {
     let count = 0;
     for (const skill of skills) {
-      const sq = questions.skills?.[skill.id];
-      if (sq?.[level]) {
-        count += sq[level].length;
+      const sq = questions.skillLevels?.[skill.id];
+      if (sq) {
+        for (const roleType of roleTypes) {
+          count += (sq[roleType]?.[level] || []).length;
+        }
       }
     }
     return [level, count];
@@ -81,9 +84,11 @@ function showQuestionsSummary(data) {
   const behaviourRows = maturities.map((maturity) => {
     let count = 0;
     for (const behaviour of behaviours) {
-      const bq = questions.behaviours?.[behaviour.id];
-      if (bq?.[maturity]) {
-        count += bq[maturity].length;
+      const bq = questions.behaviourMaturities?.[behaviour.id];
+      if (bq) {
+        for (const roleType of roleTypes) {
+          count += (bq[roleType]?.[maturity] || []).length;
+        }
       }
     }
     return [maturity.replace(/_/g, " "), count];
@@ -138,10 +143,8 @@ export async function runQuestionsCommand({
       behaviours: data.behaviours,
       filter,
     });
-    for (const section of view.sections) {
-      for (const q of section.questions) {
-        console.log(q.id);
-      }
+    for (const q of view.questions) {
+      console.log(q.id);
     }
     return;
   }

package/src/css/components/badges.css

@@ -94,24 +94,34 @@
   }
 
   /* Capability badges - each capability ID maps to its own distinct color */
+  .badge-ai {
+    background: var(--color-cap-ai-light);
+    color: var(--color-cap-ai);
+  }
+
+  .badge-business {
+    background: var(--color-cap-business-light);
+    color: var(--color-cap-business);
+  }
+
+  .badge-data {
+    background: var(--color-cap-data-light);
+    color: var(--color-cap-data);
+  }
+
   .badge-delivery {
     background: var(--color-cap-delivery-light);
     color: var(--color-cap-delivery);
   }
 
-  .badge-scale {
-    background: var(--color-cap-scale-light);
-    color: var(--color-cap-scale);
-  }
-
-  .badge-reliability {
-    background: var(--color-cap-reliability-light);
-    color: var(--color-cap-reliability);
+  .badge-documentation {
+    background: var(--color-cap-documentation-light);
+    color: var(--color-cap-documentation);
   }
 
-  .badge-business {
-    background: var(--color-cap-business-light);
-    color: var(--color-cap-business);
+  .badge-ml {
+    background: var(--color-cap-ml-light);
+    color: var(--color-cap-ml);
   }
 
   .badge-people {
@@ -119,6 +129,26 @@
     color: var(--color-cap-people);
   }
 
+  .badge-process {
+    background: var(--color-cap-process-light);
+    color: var(--color-cap-process);
+  }
+
+  .badge-product {
+    background: var(--color-cap-product-light);
+    color: var(--color-cap-product);
+  }
+
+  .badge-reliability {
+    background: var(--color-cap-reliability-light);
+    color: var(--color-cap-reliability);
+  }
+
+  .badge-scale {
+    background: var(--color-cap-scale-light);
+    color: var(--color-cap-scale);
+  }
+
   /* Tool badge */
   .badge-tool {
     background: var(--color-bg);

package/src/css/tokens.css

@@ -43,22 +43,34 @@
     --color-maturity-5: #c4b5fd;
 
     /* --------------------------------------------------------------------------
-     Colors - Capabilities (text)
+     Colors - Capabilities (text) - matches data/capabilities/*.yaml IDs
      -------------------------------------------------------------------------- */
-    --color-cap-delivery: #dc2626; /* red - speed and efficiency */
-    --color-cap-scale: #1d4ed8; /* blue - infrastructure and systems */
-    --color-cap-reliability: #0891b2; /* cyan - stability and operations */
-    --color-cap-business: #b45309; /* amber - strategy and outcomes */
-    --color-cap-people: #be185d; /* pink - collaboration and leadership */
+    --color-cap-ai: #7c3aed; /* violet */
+    --color-cap-business: #b45309; /* amber */
+    --color-cap-data: #0f766e; /* teal */
+    --color-cap-delivery: #dc2626; /* red */
+    --color-cap-documentation: #15803d; /* green */
+    --color-cap-ml: #9333ea; /* purple */
+    --color-cap-people: #be185d; /* pink */
+    --color-cap-process: #c2410c; /* orange */
+    --color-cap-product: #4f46e5; /* indigo */
+    --color-cap-reliability: #0891b2; /* cyan */
+    --color-cap-scale: #1d4ed8; /* blue */
 
     /* --------------------------------------------------------------------------
      Colors - Capabilities (backgrounds)
      -------------------------------------------------------------------------- */
-    --color-cap-delivery-light: #fecaca; /* red */
-    --color-cap-scale-light: #dbeafe; /* blue */
-    --color-cap-reliability-light: #cffafe; /* cyan */
+    --color-cap-ai-light: #ede9fe; /* violet */
     --color-cap-business-light: #fef3c7; /* amber */
+    --color-cap-data-light: #ccfbf1; /* teal */
+    --color-cap-delivery-light: #fecaca; /* red */
+    --color-cap-documentation-light: #dcfce7; /* green */
+    --color-cap-ml-light: #f3e8ff; /* purple */
     --color-cap-people-light: #fce7f3; /* pink */
+    --color-cap-process-light: #ffedd5; /* orange */
+    --color-cap-product-light: #e0e7ff; /* indigo */
+    --color-cap-reliability-light: #cffafe; /* cyan */
+    --color-cap-scale-light: #dbeafe; /* blue */
 
     /* --------------------------------------------------------------------------
      Colors - Neutrals

package/src/formatters/interview/markdown.js

@@ -27,6 +27,9 @@ export function interviewToMarkdown(view, { framework } = {}) {
   // Group sections by type
   const skillSections = view.sections.filter((s) => s.type === "skill");
   const behaviourSections = view.sections.filter((s) => s.type === "behaviour");
+  const capabilitySections = view.sections.filter(
+    (s) => s.type === "capability",
+  );
 
   // Skill questions
   if (skillSections.length > 0) {
@@ -36,27 +39,83 @@ export function interviewToMarkdown(view, { framework } = {}) {
       for (const q of section.questions) {
         lines.push(`**Q**: ${q.question}`);
         if (q.followUps.length > 0) {
+          lines.push("", "**Follow-ups:**");
           for (const followUp of q.followUps) {
             lines.push(`  → ${followUp}`);
           }
         }
+        if (q.lookingFor && q.lookingFor.length > 0) {
+          lines.push("", "**What to look for:**");
+          for (const item of q.lookingFor) {
+            lines.push(`- ${item}`);
+          }
+        }
         lines.push("");
       }
     }
   }
 
-  // Behaviour questions
+  // Capability decomposition questions
+  if (capabilitySections.length > 0) {
+    lines.push(`## 🧩 Decomposition Questions`, "");
+    for (const section of capabilitySections) {
+      lines.push(`### ${section.name} (${formatLevel(section.level)})`, "");
+      for (const q of section.questions) {
+        lines.push(`**Scenario**: ${q.question}`);
+        if (q.context) {
+          lines.push(`> ${q.context}`);
+        }
+        if (q.decompositionPrompts && q.decompositionPrompts.length > 0) {
+          lines.push("", "**Guide the candidate through:**");
+          for (const prompt of q.decompositionPrompts) {
+            lines.push(`- ${prompt}`);
+          }
+        }
+        if (q.followUps.length > 0) {
+          lines.push("", "**Follow-ups:**");
+          for (const followUp of q.followUps) {
+            lines.push(`  → ${followUp}`);
+          }
+        }
+        if (q.lookingFor && q.lookingFor.length > 0) {
+          lines.push("", "**What to look for:**");
+          for (const item of q.lookingFor) {
+            lines.push(`- ${item}`);
+          }
+        }
+        lines.push("");
+      }
+    }
+  }
+
+  // Behaviour stakeholder simulation questions
   if (behaviourSections.length > 0) {
-    lines.push(`## ${behaviourEmoji} Behaviour Questions`, "");
+    lines.push(`## ${behaviourEmoji} Stakeholder Simulation`, "");
     for (const section of behaviourSections) {
       lines.push(`### ${section.name} (${formatLevel(section.level)})`, "");
       for (const q of section.questions) {
-        lines.push(`**Q**: ${q.question}`);
+        lines.push(`**Scenario**: ${q.question}`);
+        if (q.context) {
+          lines.push(`> ${q.context}`);
+        }
+        if (q.simulationPrompts && q.simulationPrompts.length > 0) {
+          lines.push("", "**Steer the simulation:**");
+          for (const prompt of q.simulationPrompts) {
+            lines.push(`- ${prompt}`);
+          }
+        }
         if (q.followUps.length > 0) {
+          lines.push("", "**Follow-ups:**");
           for (const followUp of q.followUps) {
             lines.push(`  → ${followUp}`);
           }
         }
+        if (q.lookingFor && q.lookingFor.length > 0) {
+          lines.push("", "**What to look for:**");
+          for (const item of q.lookingFor) {
+            lines.push(`- ${item}`);
+          }
+        }
         lines.push("");
       }
     }

package/src/formatters/interview/shared.js

@@ -10,9 +10,9 @@ import {
   getDisciplineSkillIds,
 } from "@forwardimpact/model/derivation";
 import {
-  deriveInterviewQuestions,
-  deriveShortInterview,
-  deriveBehaviourQuestions,
+  deriveMissionFitInterview,
+  deriveDecompositionInterview,
+  deriveStakeholderInterview,
 } from "@forwardimpact/model/interview";
 import { getOrCreateJob } from "@forwardimpact/model/job-cache";
 
@@ -20,26 +20,35 @@ import { getOrCreateJob } from "@forwardimpact/model/job-cache";
  * Interview type configurations
  */
 export const INTERVIEW_TYPES = {
-  short: {
-    id: "short",
-    name: "Screening",
-    description: "20-minute screening interview",
-    icon: "⏱️",
-    expectedDurationMinutes: 20,
-  },
-  behaviour: {
-    id: "behaviour",
-    name: "Behavioural",
-    description: "Focus on behaviours and mindsets",
-    icon: "🧠",
+  mission: {
+    id: "mission",
+    name: "Mission Fit",
+    description:
+      "Assess technical skills and alignment with role expectations. Focus on depth of knowledge, problem-solving approach, and ability to articulate technical decisions.",
+    icon: "🎯",
     expectedDurationMinutes: 45,
+    panel: "Recruiting Manager + 1 Senior Engineer",
+    questionTypes: ["skill"],
+  },
+  decomposition: {
+    id: "decomposition",
+    name: "Decomposition",
+    description:
+      "Evaluate how candidates break down ambiguous problems into actionable components. Inspired by Palantir's technique—focus on structured thinking, trade-off analysis, and communication under uncertainty.",
+    icon: "🧩",
+    expectedDurationMinutes: 60,
+    panel: "2 Senior Engineers",
+    questionTypes: ["capability"],
   },
-  full: {
-    id: "full",
-    name: "Full Interview",
-    description: "Comprehensive interview covering all skills and behaviours",
-    icon: "📋",
-    expectedDurationMinutes: 90,
+  stakeholder: {
+    id: "stakeholder",
+    name: "Stakeholder Simulation",
+    description:
+      "Simulate real-world stakeholder interactions through behaviour-focused assessment. Focus on communication style, influence, and ability to navigate competing priorities.",
+    icon: "👥",
+    expectedDurationMinutes: 60,
+    panel: "3-4 Stakeholders",
+    questionTypes: ["behaviour"],
   },
 };
 
@@ -67,14 +76,27 @@ function groupQuestionsIntoSections(questions) {
       };
     }
 
-    sections[id].questions.push({
+    const questionEntry = {
       skillOrBehaviourId: id,
       skillOrBehaviourName: name,
       type,
       level,
       question: q.question.text,
       followUps: q.question.followUps || [],
-    });
+      lookingFor: q.question.lookingFor || [],
+    };
+
+    if (q.question.decompositionPrompts) {
+      questionEntry.decompositionPrompts = q.question.decompositionPrompts;
+    }
+    if (q.question.simulationPrompts) {
+      questionEntry.simulationPrompts = q.question.simulationPrompts;
+    }
+    if (q.question.context) {
+      questionEntry.context = q.question.context;
+    }
+
+    sections[id].questions.push(questionEntry);
   }
 
   return Object.values(sections);
@@ -83,7 +105,7 @@ function groupQuestionsIntoSections(questions) {
 /**
  * @typedef {Object} InterviewDetailView
  * @property {string} title
- * @property {string} interviewType - 'full', 'short', or 'behaviour'
+ * @property {string} interviewType - 'mission', 'decomposition', or 'stakeholder'
  * @property {string} disciplineId
  * @property {string} disciplineName
  * @property {string} gradeId
@@ -104,7 +126,7 @@ function groupQuestionsIntoSections(questions) {
  * @param {Array} params.skills
  * @param {Array} params.behaviours
  * @param {Array} params.questions
- * @param {string} [params.interviewType='full']
+ * @param {string} [params.interviewType='mission']
  * @returns {InterviewDetailView|null}
  */
 export function prepareInterviewDetail({
@@ -114,7 +136,7 @@ export function prepareInterviewDetail({
   skills,
   behaviours,
   questions,
-  interviewType = "full",
+  interviewType = "mission",
 }) {
   if (!discipline || !grade) return null;
 
@@ -130,18 +152,26 @@ export function prepareInterviewDetail({
 
   let interviewGuide;
   switch (interviewType) {
-    case "short":
-      interviewGuide = deriveShortInterview({ job, questionBank: questions });
+    case "mission":
+      interviewGuide = deriveMissionFitInterview({
+        job,
+        questionBank: questions,
+      });
       break;
-    case "behaviour":
-      interviewGuide = deriveBehaviourQuestions({
+    case "decomposition":
+      interviewGuide = deriveDecompositionInterview({
+        job,
+        questionBank: questions,
+      });
+      break;
+    case "stakeholder":
+      interviewGuide = deriveStakeholderInterview({
         job,
         questionBank: questions,
       });
       break;
-    case "full":
     default:
-      interviewGuide = deriveInterviewQuestions({
+      interviewGuide = deriveMissionFitInterview({
         job,
         questionBank: questions,
       });
@@ -151,19 +181,27 @@ export function prepareInterviewDetail({
   // Extract the questions array from the interview guide
   const rawQuestions = interviewGuide.questions || [];
 
-  // Separate skill and behaviour questions based on targetType
+  // Separate questions by type
   const skillQuestions = rawQuestions.filter((q) => q.targetType === "skill");
   const behaviourQuestions = rawQuestions.filter(
     (q) => q.targetType === "behaviour",
   );
+  const capabilityQuestions = rawQuestions.filter(
+    (q) => q.targetType === "capability",
+  );
 
   const skillSections = groupQuestionsIntoSections(skillQuestions);
   const behaviourSections = groupQuestionsIntoSections(behaviourQuestions);
+  const capabilitySections = groupQuestionsIntoSections(capabilityQuestions);
 
-  const allSections = [...skillSections, ...behaviourSections];
+  const allSections = [
+    ...skillSections,
+    ...behaviourSections,
+    ...capabilitySections,
+  ];
   const totalQuestions = rawQuestions.length;
 
-  const typeConfig = INTERVIEW_TYPES[interviewType] || INTERVIEW_TYPES.full;
+  const typeConfig = INTERVIEW_TYPES[interviewType] || INTERVIEW_TYPES.mission;
 
   return {
     title: job.title,
@@ -293,24 +331,19 @@ export function prepareAllInterviews({
   if (!job) return null;
 
   // Generate all interview types
-  const shortInterview = deriveShortInterview({
+  const missionInterview = deriveMissionFitInterview({
     job,
     questionBank: questions,
-    targetMinutes: 20,
   });
 
-  const behaviourInterview = deriveBehaviourQuestions({
+  const decompositionInterview = deriveDecompositionInterview({
     job,
     questionBank: questions,
   });
 
-  const fullInterview = deriveInterviewQuestions({
+  const stakeholderInterview = deriveStakeholderInterview({
     job,
     questionBank: questions,
-    options: {
-      targetMinutes: 60,
-      skillBehaviourRatio: 0.6,
-    },
   });
 
   return {
@@ -321,17 +354,21 @@ export function prepareAllInterviews({
     trackId: track?.id || null,
     trackName: track?.name || null,
     interviews: {
-      short: {
-        ...shortInterview,
-        type: "short",
-        typeInfo: INTERVIEW_TYPES.short,
+      mission: {
+        ...missionInterview,
+        type: "mission",
+        typeInfo: INTERVIEW_TYPES.mission,
+      },
+      decomposition: {
+        ...decompositionInterview,
+        type: "decomposition",
+        typeInfo: INTERVIEW_TYPES.decomposition,
       },
-      behaviour: {
-        ...behaviourInterview,
-        type: "behaviour",
-        typeInfo: INTERVIEW_TYPES.behaviour,
+      stakeholder: {
+        ...stakeholderInterview,
+        type: "stakeholder",
+        typeInfo: INTERVIEW_TYPES.stakeholder,
       },
-      full: { ...fullInterview, type: "full", typeInfo: INTERVIEW_TYPES.full },
     },
   };
 }

package/src/formatters/questions/markdown.js

@@ -259,6 +259,21 @@ function formatSingleSource(view) {
     for (const q of byLevel[level]) {
       lines.push(`  • [${q.id}] ${q.text}`);
       lines.push(`    Duration: ${q.expectedDurationMinutes} min`);
+      if (q.context) {
+        lines.push(`    Context: ${q.context}`);
+      }
+      if (q.simulationPrompts && q.simulationPrompts.length > 0) {
+        lines.push("    Steer the simulation:");
+        for (const prompt of q.simulationPrompts) {
+          lines.push(`      - ${prompt}`);
+        }
+      }
+      if (q.decompositionPrompts && q.decompositionPrompts.length > 0) {
+        lines.push("    Guide candidate thinking:");
+        for (const prompt of q.decompositionPrompts) {
+          lines.push(`      - ${prompt}`);
+        }
+      }
       if (q.lookingFor.length > 0) {
         lines.push("    Looking for:");
         for (const item of q.lookingFor) {

package/src/formatters/questions/shared.js

@@ -46,6 +46,9 @@ export const BEHAVIOUR_MATURITIES = [
  * @property {string[]} lookingFor - Expected answer indicators
  * @property {number} expectedDurationMinutes - Time estimate
  * @property {string[]} [followUps] - Follow-up questions
+ * @property {string} [context] - Scenario context
+ * @property {string[]} [simulationPrompts] - Simulation steering prompts
+ * @property {string[]} [decompositionPrompts] - Decomposition guidance prompts
  */
 
 /**
@@ -103,6 +106,11 @@ function getSkillCapability(skillId, skills) {
   return skill ? skill.capability : null;
 }
 
+/**
+ * Role type keys in question YAML files
+ */
+const ROLE_TYPES = ["professionalQuestions", "managementQuestions"];
+
 /**
  * Flatten all questions from question bank
  * @param {Object} questionBank
@@ -115,78 +123,76 @@ export function flattenQuestions(questionBank, skills, behaviours, filter) {
   const questions = [];
 
   // Process skill questions
-  for (const [skillId, levels] of Object.entries(
+  for (const [skillId, roleTypes] of Object.entries(
     questionBank.skillLevels || {},
   )) {
     const skillName = getSkillName(skillId, skills);
     const capability = getSkillCapability(skillId, skills);
 
-    // Filter by skill IDs
     if (filter.skills && !filter.skills.includes(skillId)) continue;
-
-    // Skip skills if filtering by specific behaviours
     if (filter.behaviours) continue;
-
-    // Filter by capability
     if (filter.capability && capability !== filter.capability) continue;
-
-    for (const [level, levelQuestions] of Object.entries(levels)) {
-      // Filter by level
-      if (filter.level && level !== filter.level) continue;
-
-      // Skip if filtering by maturity (behaviour-only filter)
-      if (filter.maturity) continue;
-
-      for (const q of levelQuestions) {
-        questions.push({
-          source: skillId,
-          sourceName: skillName,
-          sourceType: "skill",
-          level,
-          id: q.id,
-          text: q.text,
-          lookingFor: q.lookingFor || [],
-          expectedDurationMinutes: q.expectedDurationMinutes || 5,
-          followUps: q.followUps || [],
-        });
+    if (filter.maturity) continue;
+
+    for (const roleType of ROLE_TYPES) {
+      const levels = roleTypes[roleType];
+      if (!levels) continue;
+
+      for (const [level, levelQuestions] of Object.entries(levels)) {
+        if (filter.level && level !== filter.level) continue;
+
+        for (const q of levelQuestions) {
+          questions.push({
+            source: skillId,
+            sourceName: skillName,
+            sourceType: "skill",
+            level,
+            id: q.id,
+            text: q.text,
+            lookingFor: q.lookingFor || [],
+            expectedDurationMinutes: q.expectedDurationMinutes || 5,
+            followUps: q.followUps || [],
+            context: q.context || null,
+            decompositionPrompts: q.decompositionPrompts || [],
+          });
+        }
       }
     }
   }
 
   // Process behaviour questions
-  for (const [behaviourId, maturities] of Object.entries(
+  for (const [behaviourId, roleTypes] of Object.entries(
     questionBank.behaviourMaturities || {},
   )) {
     const behaviourName = getBehaviourName(behaviourId, behaviours);
 
-    // Filter by behaviour IDs
     if (filter.behaviours && !filter.behaviours.includes(behaviourId)) continue;
-
-    // Skip behaviours if filtering by capability (skill-only filter)
     if (filter.capability) continue;
-
-    // Skip behaviours if filtering by specific skills
     if (filter.skills) continue;
-
-    for (const [maturity, maturityQuestions] of Object.entries(maturities)) {
-      // Filter by maturity
-      if (filter.maturity && maturity !== filter.maturity) continue;
-
-      // Skip if filtering by level (skill-only filter)
-      if (filter.level) continue;
-
-      for (const q of maturityQuestions) {
-        questions.push({
-          source: behaviourId,
-          sourceName: behaviourName,
-          sourceType: "behaviour",
-          level: maturity,
-          id: q.id,
-          text: q.text,
-          lookingFor: q.lookingFor || [],
-          expectedDurationMinutes: q.expectedDurationMinutes || 5,
-          followUps: q.followUps || [],
-        });
+    if (filter.level) continue;
+
+    for (const roleType of ROLE_TYPES) {
+      const maturities = roleTypes[roleType];
+      if (!maturities) continue;
+
+      for (const [maturity, maturityQuestions] of Object.entries(maturities)) {
+        if (filter.maturity && maturity !== filter.maturity) continue;
+
+        for (const q of maturityQuestions) {
+          questions.push({
+            source: behaviourId,
+            sourceName: behaviourName,
+            sourceType: "behaviour",
+            level: maturity,
+            id: q.id,
+            text: q.text,
+            lookingFor: q.lookingFor || [],
+            expectedDurationMinutes: q.expectedDurationMinutes || 5,
+            followUps: q.followUps || [],
+            context: q.context || null,
+            simulationPrompts: q.simulationPrompts || [],
+          });
+        }
       }
     }
   }
@@ -211,12 +217,16 @@ export function calculateStats(questions, questionBank) {
 
   // Calculate full stats for skills and behaviours
   const skillStats = {};
-  for (const [skillId, levels] of Object.entries(
+  for (const [skillId, roleTypes] of Object.entries(
     questionBank.skillLevels || {},
   )) {
     skillStats[skillId] = {};
     for (const level of SKILL_LEVELS) {
-      skillStats[skillId][level] = (levels[level] || []).length;
+      let count = 0;
+      for (const roleType of ROLE_TYPES) {
+        count += (roleTypes[roleType]?.[level] || []).length;
+      }
+      skillStats[skillId][level] = count;
     }
     skillStats[skillId].total = Object.values(skillStats[skillId]).reduce(
       (a, b) => a + b,
@@ -225,14 +235,16 @@ export function calculateStats(questions, questionBank) {
   }
 
   const behaviourStats = {};
-  for (const [behaviourId, maturities] of Object.entries(
+  for (const [behaviourId, roleTypes] of Object.entries(
     questionBank.behaviourMaturities || {},
   )) {
     behaviourStats[behaviourId] = {};
     for (const maturity of BEHAVIOUR_MATURITIES) {
-      behaviourStats[behaviourId][maturity] = (
-        maturities[maturity] || []
-      ).length;
+      let count = 0;
+      for (const roleType of ROLE_TYPES) {
+        count += (roleTypes[roleType]?.[maturity] || []).length;
+      }
+      behaviourStats[behaviourId][maturity] = count;
     }
     behaviourStats[behaviourId].total = Object.values(
       behaviourStats[behaviourId],

package/src/lib/yaml-loader.js

@@ -237,35 +237,52 @@ async function loadCapabilitiesFromDir(capabilitiesDir) {
 }
 
 /**
- * Load questions from folder structure using skill/behaviour IDs
+ * Load questions from folder structure using skill/behaviour/capability IDs
  * @param {string} questionsDir - Path to questions directory
  * @param {Array} skills - Skills array (with id property)
  * @param {Array} behaviours - Behaviours array (with id property)
+ * @param {Array} capabilities - Capabilities array (with id property)
  * @returns {Promise<Object>}
  */
-async function loadQuestionFolder(questionsDir, skills, behaviours) {
-  const [skillEntries, behaviourEntries] = await Promise.all([
-    Promise.all(
-      skills.map(async (skill) => {
-        const content = await tryLoadYamlFile(
-          `${questionsDir}/skills/${skill.id}.yaml`,
-        );
-        return [skill.id, content || {}];
-      }),
-    ),
-    Promise.all(
-      behaviours.map(async (behaviour) => {
-        const content = await tryLoadYamlFile(
-          `${questionsDir}/behaviours/${behaviour.id}.yaml`,
-        );
-        return [behaviour.id, content || {}];
-      }),
-    ),
-  ]);
+async function loadQuestionFolder(
+  questionsDir,
+  skills,
+  behaviours,
+  capabilities,
+) {
+  const [skillEntries, behaviourEntries, capabilityEntries] = await Promise.all(
+    [
+      Promise.all(
+        skills.map(async (skill) => {
+          const content = await tryLoadYamlFile(
+            `${questionsDir}/skills/${skill.id}.yaml`,
+          );
+          return [skill.id, content || {}];
+        }),
+      ),
+      Promise.all(
+        behaviours.map(async (behaviour) => {
+          const content = await tryLoadYamlFile(
+            `${questionsDir}/behaviours/${behaviour.id}.yaml`,
+          );
+          return [behaviour.id, content || {}];
+        }),
+      ),
+      Promise.all(
+        capabilities.map(async (capability) => {
+          const content = await tryLoadYamlFile(
+            `${questionsDir}/capabilities/${capability.id}.yaml`,
+          );
+          return [capability.id, content || {}];
+        }),
+      ),
+    ],
+  );
 
   return {
     skillLevels: Object.fromEntries(skillEntries),
     behaviourMaturities: Object.fromEntries(behaviourEntries),
+    capabilityLevels: Object.fromEntries(capabilityEntries),
   };
 }
 
@@ -293,11 +310,12 @@ export async function loadAllData(dataDir = "./data") {
       loadYamlFile(`${dataDir}/framework.yaml`),
     ]);
 
-  // Load questions using skill/behaviour IDs
+  // Load questions using skill/behaviour/capability IDs
   const questions = await loadQuestionFolder(
     `${dataDir}/questions`,
     skills,
     behaviours,
+    capabilities,
   );
 
   return {

package/src/pages/interview.js

@@ -81,8 +81,8 @@ export function renderInterviewDetail(params) {
     return;
   }
 
-  // State for current interview type (default to first: Screening)
-  let currentType = "short";
+  // State for current interview type (default to first: Mission Fit)
+  let currentType = "mission";
 
   const page = div(
     { className: "interview-detail-page" },
@@ -194,23 +194,32 @@ function createInterviewSummary(interview) {
       { className: "interview-summary-header" },
       h2({}, `${typeInfo.icon} ${typeInfo.name}`),
       p({ className: "text-muted" }, typeInfo.description),
+      typeInfo.panel
+        ? p({ className: "text-muted" }, `Panel: ${typeInfo.panel}`)
+        : null,
     ),
     div(
       { className: "interview-summary-stats" },
       createBadge(`${interview.questions.length} questions`, "default"),
       createBadge(`~${interview.expectedDurationMinutes} minutes`, "secondary"),
-      interview.coverage.skills.length > 0
+      interview.coverage.skills?.length > 0
         ? createBadge(
             `${interview.coverage.skills.length} skills covered`,
             "primary",
           )
         : null,
-      interview.coverage.behaviours.length > 0
+      interview.coverage.behaviours?.length > 0
         ? createBadge(
             `${interview.coverage.behaviours.length} behaviours covered`,
             "primary",
           )
         : null,
+      interview.coverage.capabilities?.length > 0
+        ? createBadge(
+            `${interview.coverage.capabilities.length} capabilities covered`,
+            "primary",
+          )
+        : null,
     ),
   );
 }
@@ -226,6 +235,9 @@ function createQuestionsDisplay(interview, framework) {
   const behaviourQuestions = interview.questions.filter(
     (q) => q.targetType === "behaviour",
   );
+  const capabilityQuestions = interview.questions.filter(
+    (q) => q.targetType === "capability",
+  );
 
   const sections = [];
 
@@ -241,12 +253,21 @@ function createQuestionsDisplay(interview, framework) {
   if (behaviourQuestions.length > 0) {
     sections.push(
       createDetailSection({
-        title: `${getConceptEmoji(framework, "behaviour")} Behaviour Questions (${behaviourQuestions.length})`,
+        title: `${getConceptEmoji(framework, "behaviour")} Stakeholder Simulation (${behaviourQuestions.length})`,
         content: createQuestionsList(behaviourQuestions),
       }),
     );
   }
 
+  if (capabilityQuestions.length > 0) {
+    sections.push(
+      createDetailSection({
+        title: `${getConceptEmoji(framework, "capability") || "🧩"} Decomposition Questions (${capabilityQuestions.length})`,
+        content: createQuestionsList(capabilityQuestions),
+      }),
+    );
+  }
+
   if (sections.length === 0) {
     return div(
       { className: "card" },
@@ -262,6 +283,7 @@ function createQuestionsDisplay(interview, framework) {
 
 /**
  * Create questions list
+ * @param {Array} questions - Questions to display
  */
 function createQuestionsList(questions) {
   return div(
@@ -272,10 +294,41 @@ function createQuestionsList(questions) {
 
 /**
  * Create question card
+ * @param {Object} questionEntry - Question entry
+ * @param {number} number - Question number
  */
 function createQuestionCard(questionEntry, number) {
   const { question, targetName, targetLevel } = questionEntry;
 
+  const contextSection = question.context
+    ? div(
+        { className: "question-context" },
+        h4({}, "Context:"),
+        p({}, question.context),
+      )
+    : null;
+
+  const decompositionPromptsList =
+    question.decompositionPrompts && question.decompositionPrompts.length > 0
+      ? div(
+          { className: "question-prompts" },
+          h4({}, "Guide candidate thinking:"),
+          ul(
+            {},
+            ...question.decompositionPrompts.map((prompt) => li({}, prompt)),
+          ),
+        )
+      : null;
+
+  const simulationPromptsList =
+    question.simulationPrompts && question.simulationPrompts.length > 0
+      ? div(
+          { className: "question-prompts" },
+          h4({}, "Steer the simulation:"),
+          ul({}, ...question.simulationPrompts.map((prompt) => li({}, prompt))),
+        )
+      : null;
+
   const followUpsList =
     question.followUps && question.followUps.length > 0
       ? div(
@@ -309,6 +362,9 @@ function createQuestionCard(questionEntry, number) {
       ),
     ),
     div({ className: "question-text" }, question.text),
+    contextSection,
+    decompositionPromptsList,
+    simulationPromptsList,
     followUpsList,
     lookingForList,
   );