@forwardimpact/pathway 0.12.0 → 0.14.0

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/formatters/stage/dom.js

@@ -34,33 +34,36 @@ export function stageToDOM(stage, { stages = [], showBackLink = true } = {}) {
       p({ className: "page-description" }, view.description),
     ),
 
-    // Entry/Exit Criteria
-    view.entryCriteria.length > 0 || view.exitCriteria.length > 0
+    // Read/Confirm Checklists
+    view.readChecklist.length > 0 || view.confirmChecklist.length > 0
       ? div(
           { className: "section section-detail" },
           div(
             { className: "content-columns" },
-            // Entry criteria column
-            view.entryCriteria.length > 0
+            // Read checklist column
+            view.readChecklist.length > 0
               ? div(
                   { className: "column" },
-                  h2({ className: "section-title" }, "Entry Criteria"),
+                  h2({ className: "section-title" }, "Read-Then-Do Checklist"),
                   ul(
                     { className: "criteria-list" },
-                    ...view.entryCriteria.map((item) =>
+                    ...view.readChecklist.map((item) =>
                       li({ className: "criteria-item" }, item),
                     ),
                   ),
                 )
               : null,
-            // Exit criteria column
-            view.exitCriteria.length > 0
+            // Confirm checklist column
+            view.confirmChecklist.length > 0
               ? div(
                   { className: "column" },
-                  h2({ className: "section-title" }, "Exit Criteria"),
+                  h2(
+                    { className: "section-title" },
+                    "Do-Then-Confirm Checklist",
+                  ),
                   ul(
                     { className: "criteria-list" },
-                    ...view.exitCriteria.map((item) =>
+                    ...view.confirmChecklist.map((item) =>
                       li({ className: "criteria-item" }, item),
                     ),
                   ),

package/src/formatters/stage/microdata.js

@@ -60,11 +60,11 @@ export function stageToMicrodata(stage) {
 
   const sections = [];
 
-  // Entry criteria
-  if (view.entryCriteria.length > 0) {
-    const criteriaItems = view.entryCriteria.map((c) => escapeHtml(c));
+  // Read checklist
+  if (view.readChecklist.length > 0) {
+    const readItems = view.readChecklist.map((c) => escapeHtml(c));
     sections.push(
-      section("Entry Criteria", ul(criteriaItems, "entryCriteria"), 2),
+      section("Read-Then-Do Checklist", ul(readItems, "readChecklist"), 2),
     );
   }
 
@@ -76,10 +76,16 @@ export function stageToMicrodata(stage) {
     );
   }
 
-  // Exit criteria
-  if (view.exitCriteria.length > 0) {
-    const exitItems = view.exitCriteria.map((c) => escapeHtml(c));
-    sections.push(section("Exit Criteria", ul(exitItems, "exitCriteria"), 2));
+  // Confirm checklist
+  if (view.confirmChecklist.length > 0) {
+    const confirmItems = view.confirmChecklist.map((c) => escapeHtml(c));
+    sections.push(
+      section(
+        "Do-Then-Confirm Checklist",
+        ul(confirmItems, "confirmChecklist"),
+        2,
+      ),
+    );
   }
 
   // Handoffs - using Handoff itemtype

package/src/formatters/stage/shared.js

@@ -46,8 +46,8 @@ export function prepareStagesList(stages, descriptionLimit = 150) {
  * @property {string} name
  * @property {string} description
  * @property {string[]} constraints
- * @property {string[]} entryCriteria
- * @property {string[]} exitCriteria
+ * @property {string[]} readChecklist
+ * @property {string[]} confirmChecklist
  * @property {Array<{target: string, label: string, prompt: string}>} handoffs
  */
 
@@ -62,8 +62,8 @@ export function prepareStageDetail(stage) {
     name: stage.name,
     description: stage.description,
     constraints: stage.constraints || [],
-    entryCriteria: stage.entryCriteria || [],
-    exitCriteria: stage.exitCriteria || [],
+    readChecklist: stage.readChecklist || [],
+    confirmChecklist: stage.confirmChecklist || [],
     handoffs: (stage.handoffs || []).map((h) => ({
       target: h.targetStage,
       label: h.label,