@forwardimpact/pathway 0.25.22 → 0.25.25

package/src/commands/build-packs.js

@@ -1,15 +1,19 @@
 /**
  * Pack generation for Pathway distribution.
  *
- * Emits one pre-built agent/skill pack per valid discipline/track combination
- * and two discovery manifests (`.well-known/agent-skills/index.json` for
- * `npx skills` and `apm.yml` for Microsoft APM). See
- * specs/320-pathway-ecosystem-distribution for context.
+ * Emits one pre-built agent/skill pack per valid discipline/track combination.
+ * Each pack becomes its own `npx skills`-compatible repository at
+ * `packs/{name}/.well-known/skills/`, with an aggregate repository at
+ * `packs/.well-known/skills/` listing every skill from every pack.
+ * An `apm.yml` for Microsoft APM is also written at the site root.
+ *
+ * See specs/320-pathway-ecosystem-distribution for context.
  *
  * Invoked from build.js after the distribution bundle has been generated.
  */
 
-import { mkdir, rm, readFile, writeFile } from "fs/promises";
+import { mkdir, rm, readFile, writeFile, readdir, cp } from "fs/promises";
+import { utimesSync } from "fs";
 import { join } from "path";
 import { execFileSync } from "child_process";
 import { createHash } from "crypto";
@@ -209,50 +213,205 @@ function derivePackContent({
   return { profiles, skillFiles, teamInstructions };
 }
 
+/**
+ * Recursively collect all paths (files and directories) under `dir`,
+ * relative to `dir`, in sorted order.
+ */
+async function collectPaths(dir, prefix = ".") {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const result = [];
+  for (const entry of entries) {
+    const rel = prefix + "/" + entry.name;
+    const abs = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      result.push(rel);
+      result.push(...(await collectPaths(abs, rel)));
+    } else {
+      result.push(rel);
+    }
+  }
+  return result;
+}
+
+/**
+ * Set mtime and atime to the Unix epoch for every entry under `dir`.
+ */
+async function resetTimestamps(dir) {
+  const epoch = new Date(0);
+  const paths = await collectPaths(dir);
+  for (const rel of paths) {
+    utimesSync(join(dir, rel), epoch, epoch);
+  }
+  utimesSync(dir, epoch, epoch);
+}
+
 /**
  * Archive a staged pack directory as a deterministic tar.gz and return its
  * sha256 digest.
+ *
+ * Determinism strategy (works on GNU tar and BSD tar):
+ *  1. Reset all file timestamps to epoch via Node's utimesSync.
+ *  2. Collect and sort the file list in JS — no reliance on --sort=name.
+ *  3. Create an uncompressed tar to stdout with the sorted list.
+ *  4. Pipe through `gzip -n` to suppress the gzip header timestamp.
+ *
  * @param {string} packDir - Staging directory containing the pack files
  * @param {string} archivePath - Destination path for the tar.gz
  * @returns {Promise<string>} sha256 digest string (e.g. "sha256:abc...")
  */
 async function archivePack(packDir, archivePath) {
-  execFileSync("tar", [
-    "-czf",
-    archivePath,
-    "--sort=name",
-    "--mtime=1970-01-01",
-    "--owner=0",
-    "--group=0",
-    "--numeric-owner",
-    "-C",
-    packDir,
-    ".",
-  ]);
+  await resetTimestamps(packDir);
+
+  const files = await collectPaths(packDir);
+  files.sort();
+
+  const tarBuf = execFileSync("tar", ["-cf", "-", "-C", packDir, ...files]);
+  const gzBuf = execFileSync("gzip", ["-n"], { input: tarBuf });
+  await writeFile(archivePath, gzBuf);
 
   const bytes = await readFile(archivePath);
   return "sha256:" + createHash("sha256").update(bytes).digest("hex");
 }
 
 /**
- * Write the `npx skills` discovery manifest.
- * @param {string} outputDir
- * @param {Array<{name: string, description: string, url: string, digest: string}>} packs
- * @param {string} version
+ * Collect all file paths under `dir`, relative to `dir`, for the manifest
+ * `files` array. Returns sorted paths with forward slashes.
+ * @param {string} dir
+ * @param {string} [prefix]
+ * @returns {Promise<string[]>}
+ */
+async function collectFileList(dir, prefix = "") {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const result = [];
+  for (const entry of entries) {
+    const rel = prefix ? prefix + "/" + entry.name : entry.name;
+    if (entry.isDirectory()) {
+      result.push(...(await collectFileList(join(dir, entry.name), rel)));
+    } else {
+      result.push(rel);
+    }
+  }
+  return result.sort();
+}
+
+/**
+ * Parse YAML frontmatter from a SKILL.md file. Returns an object with
+ * the key/value pairs found between the `---` fences.
+ * @param {string} content
+ * @returns {Record<string, string>}
+ */
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const result = {};
+  for (const line of match[1].split("\n")) {
+    const idx = line.indexOf(":");
+    if (idx > 0) result[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
+  }
+  return result;
+}
+
+/**
+ * Build a single skill index entry from a staged skill directory.
+ * @param {string} skillDir - Path containing SKILL.md and optional extras
+ * @param {string} name - Skill name for the manifest
+ * @returns {Promise<{name: string, description: string, files: string[]}>}
+ */
+async function buildSkillEntry(skillDir, name) {
+  const skillMd = await readFile(join(skillDir, "SKILL.md"), "utf-8");
+  const fm = parseFrontmatter(skillMd);
+  const files = await collectFileList(skillDir);
+  return { description: fm.description || "", files, name };
+}
+
+/**
+ * Write a `npx skills`-compatible repository for a single pack.
+ *
+ * Each pack becomes its own skill repository at
+ * `packs/{name}/.well-known/skills/` so that individual skills
+ * within the pack can be discovered and installed independently:
+ *
+ *   npx skills add domain.org/packs/se-platform --all
+ *   npx skills add domain.org/packs/se-platform -s architecture-design
+ *
+ * @param {string} packsOutputDir - The `packs/` output directory
+ * @param {string} packStagingDir - Staging directory for this pack
+ * @param {string} packName - Pack name (e.g. "se-platform")
+ * @returns {Promise<Array<{name: string, description: string, files: string[]}>>}
+ *   The skill entries written, for use in the aggregate manifest.
  */
-async function writeSkillsManifest(outputDir, packs, version) {
-  const wellKnownDir = join(outputDir, ".well-known", "agent-skills");
+async function writePackRepository(packsOutputDir, packStagingDir, packName) {
+  const wellKnownDir = join(packsOutputDir, packName, ".well-known", "skills");
   await mkdir(wellKnownDir, { recursive: true });
+
+  // Discover individual skills from the staged pack's .claude/skills/
+  const skillsSrcDir = join(packStagingDir, ".claude", "skills");
+  const skillDirs = (
+    await readdir(skillsSrcDir, { withFileTypes: true })
+  ).filter((e) => e.isDirectory());
+
+  const entries = [];
+  for (const dir of skillDirs) {
+    const src = join(skillsSrcDir, dir.name);
+    const dest = join(wellKnownDir, dir.name);
+    await cp(src, dest, { recursive: true });
+    entries.push(await buildSkillEntry(dest, dir.name));
+  }
+
   const manifest = {
     $schema: "https://schemas.agentskills.io/discovery/0.2.0/schema.json",
-    skills: packs.map((pack) => ({
-      description: pack.description,
-      digest: pack.digest,
-      name: pack.name,
-      type: "archive",
-      url: pack.url,
-      version,
-    })),
+    skills: entries,
+  };
+  await writeFile(
+    join(wellKnownDir, "index.json"),
+    stringifySorted(manifest),
+    "utf-8",
+  );
+
+  return entries;
+}
+
+/**
+ * Write an aggregate `npx skills` repository at `packs/` that lists every
+ * unique skill across all packs. Skills with the same name produce identical
+ * SKILL.md content regardless of discipline/track, so we deduplicate by name
+ * and write one copy.
+ *
+ *   npx skills add domain.org/packs --list
+ *
+ * @param {string} packsOutputDir
+ * @param {Array<{packName: string, entries: Array}>} allPackEntries
+ */
+async function writeAggregateRepository(packsOutputDir, allPackEntries) {
+  const wellKnownDir = join(packsOutputDir, ".well-known", "skills");
+  await mkdir(wellKnownDir, { recursive: true });
+
+  // Deduplicate: first occurrence of each skill name wins (content is identical)
+  const seen = new Map();
+  for (const { packName, entries } of allPackEntries) {
+    for (const entry of entries) {
+      if (seen.has(entry.name)) continue;
+      seen.set(entry.name, { packName, entry });
+    }
+  }
+
+  const skills = [];
+  for (const [, { packName, entry }] of seen) {
+    const dest = join(wellKnownDir, entry.name);
+    const src = join(
+      packsOutputDir,
+      packName,
+      ".well-known",
+      "skills",
+      entry.name,
+    );
+    await cp(src, dest, { recursive: true });
+    skills.push(entry);
+  }
+
+  const manifest = {
+    $schema: "https://schemas.agentskills.io/discovery/0.2.0/schema.json",
+    skills,
   };
   await writeFile(
     join(wellKnownDir, "index.json"),
@@ -382,10 +541,25 @@ export async function generatePacks({
     console.log(`   ✓ packs/${agentName}.tar.gz`);
   }
 
-  await rm(stagingDir, { recursive: true, force: true });
+  // Write per-pack skill repositories (one per discipline/track combination)
+  const allPackEntries = [];
+  for (const pack of packs) {
+    const entries = await writePackRepository(
+      packsDir,
+      join(stagingDir, pack.name),
+      pack.name,
+    );
+    allPackEntries.push({ packName: pack.name, entries });
+    console.log(
+      `   ✓ packs/${pack.name}/.well-known/skills/ (${entries.length} skills)`,
+    );
+  }
 
-  await writeSkillsManifest(outputDir, packs, version);
-  console.log("   ✓ .well-known/agent-skills/index.json");
+  // Write aggregate repository at packs/ level
+  await writeAggregateRepository(packsDir, allPackEntries);
+  console.log("   ✓ packs/.well-known/skills/index.json (aggregate)");
+
+  await rm(stagingDir, { recursive: true, force: true });
 
   await writeApmManifest(outputDir, packs, version, frameworkTitle);
   console.log("   ✓ apm.yml");

package/src/commands/build.js

@@ -222,10 +222,10 @@ ${framework.emojiIcon} Generating ${framework.title} static site...
 ✅ Site generated successfully!
 
 Output: ${outputDir}
-${siteUrl ? `\nDistribution:\n  ${outputDir}/bundle.tar.gz\n  ${outputDir}/install.sh\n  ${outputDir}/packs/ (agent/skill packs)\n  ${outputDir}/.well-known/agent-skills/index.json\n  ${outputDir}/apm.yml\n` : ""}
+${siteUrl ? `\nDistribution:\n  ${outputDir}/bundle.tar.gz\n  ${outputDir}/install.sh\n  ${outputDir}/packs/ (agent/skill packs)\n  ${outputDir}/packs/{name}/.well-known/skills/ (per-pack skill repositories)\n  ${outputDir}/packs/.well-known/skills/ (aggregate skill repository)\n  ${outputDir}/apm.yml\n` : ""}
 To serve locally:
   cd ${relative(process.cwd(), outputDir) || "."}
-  bunx serve .
+  npx serve .
 `);
 }
 

package/src/commands/command-factory.js

@@ -12,6 +12,12 @@
  */
 
 import { capitalize } from "../formatters/shared.js";
+import {
+  formatSuccess,
+  formatWarning,
+  formatError,
+  formatBullet,
+} from "@forwardimpact/libcli";
 
 /**
  * Create an entity command with standard behavior
@@ -88,8 +94,15 @@ export function createEntityCommand({
  */
 function handleValidate({ data, _entityName, pluralName, validate }) {
   if (!validate) {
-    console.log(`No specific validation for ${pluralName}.`);
-    console.log(`Run 'bunx pathway --validate' for full data validation.`);
+    process.stdout.write(
+      formatBullet(`No specific validation for ${pluralName}.`, 0) + "\n",
+    );
+    process.stdout.write(
+      formatBullet(
+        "Run 'npx fit-pathway --validate' for full data validation.",
+        0,
+      ) + "\n",
+    );
     return;
   }
 
@@ -97,21 +110,23 @@ function handleValidate({ data, _entityName, pluralName, validate }) {
   const { errors = [], warnings = [] } = result;
 
   if (errors.length === 0 && warnings.length === 0) {
-    console.log(`✅ ${capitalize(pluralName)} validation passed`);
+    process.stdout.write(
+      formatSuccess(`${capitalize(pluralName)} validation passed`) + "\n",
+    );
     return;
   }
 
   if (warnings.length > 0) {
-    console.log(`⚠️  Warnings:`);
+    process.stdout.write(formatWarning(`${warnings.length} warning(s)`) + "\n");
     for (const w of warnings) {
-      console.log(`  - ${w}`);
+      process.stdout.write(formatBullet(w, 1) + "\n");
     }
   }
 
   if (errors.length > 0) {
-    console.log(`❌ Errors:`);
+    process.stderr.write(formatError(`${errors.length} error(s)`) + "\n");
     for (const e of errors) {
-      console.log(`  - ${e}`);
+      process.stderr.write(formatBullet(e, 1) + "\n");
     }
     process.exit(1);
   }
@@ -134,15 +149,21 @@ function handleDetail({
   const entity = findEntity(data, id);
 
   if (!entity) {
-    console.error(`${capitalize(entityName)} not found: ${id}`);
-    console.error(`Available: ${data[pluralName].map((e) => e.id).join(", ")}`);
+    process.stderr.write(
+      formatError(`${capitalize(entityName)} not found: ${id}`) + "\n",
+    );
+    process.stderr.write(
+      `Available: ${data[pluralName].map((e) => e.id).join(", ")}\n`,
+    );
     process.exit(1);
   }
 
   const view = presentDetail(entity, data, options);
 
   if (!view) {
-    console.error(`Failed to present ${entityName}: ${id}`);
+    process.stderr.write(
+      formatError(`Failed to present ${entityName}: ${id}`) + "\n",
+    );
     process.exit(1);
   }
 
@@ -178,9 +199,11 @@ export function createCompositeCommand({
   return async function runCommand({ data, args, options }) {
     if (args.length < requiredArgs.length) {
       const argsList = requiredArgs.map((arg) => `<${arg}>`).join(" ");
-      console.error(`Usage: bunx pathway ${commandName} ${argsList}`);
+      process.stderr.write(
+        formatError(`Usage: npx fit-pathway ${commandName} ${argsList}`) + "\n",
+      );
       if (usageExample) {
-        console.error(`Example: ${usageExample}`);
+        process.stderr.write(`Example: ${usageExample}\n`);
       }
       process.exit(1);
     }
@@ -189,14 +212,16 @@ export function createCompositeCommand({
     const validationError = validateEntities(entities, data, options);
 
     if (validationError) {
-      console.error(validationError);
+      process.stderr.write(formatError(validationError) + "\n");
       process.exit(1);
     }
 
     const view = presenter(entities, data, options);
 
     if (!view) {
-      console.error(`Failed to generate ${commandName} output.`);
+      process.stderr.write(
+        formatError(`Failed to generate ${commandName} output.`) + "\n",
+      );
       process.exit(1);
     }
 

package/src/commands/discipline.js

@@ -4,15 +4,20 @@
  * Handles discipline summary, listing, and detail display in the terminal.
  *
  * Usage:
- *   bunx pathway discipline              # Summary with stats
- *   bunx pathway discipline --list       # IDs only (for piping)
- *   bunx pathway discipline <id>         # Detail view
- *   bunx pathway discipline --validate   # Validation checks
+ *   npx fit-pathway discipline              # Summary with stats
+ *   npx fit-pathway discipline --list       # IDs only (for piping)
+ *   npx fit-pathway discipline <id>         # Detail view
+ *   npx fit-pathway discipline --validate   # Validation checks
  */
 
 import { createEntityCommand } from "./command-factory.js";
 import { disciplineToMarkdown } from "../formatters/discipline/markdown.js";
-import { formatTable } from "../lib/cli-output.js";
+import {
+  formatTable,
+  formatHeader,
+  formatSubheader,
+  formatBullet,
+} from "@forwardimpact/libcli";
 
 /**
  * Format discipline list item for --list output
@@ -32,7 +37,7 @@ function formatListItem(discipline) {
  * @param {Array} disciplines - Raw discipline entities
  */
 function formatSummary(disciplines) {
-  console.log(`\n📋 Disciplines\n`);
+  process.stdout.write("\n" + formatHeader("\u{1F4CB} Disciplines") + "\n\n");
 
   const rows = disciplines.map((d) => {
     const type = d.isProfessional ? "Professional" : "Management";
@@ -41,10 +46,19 @@ function formatSummary(disciplines) {
     return [d.id, d.specialization || d.id, type, trackStr];
   });
 
-  console.log(formatTable(["ID", "Specialization", "Type", "Tracks"], rows));
-  console.log(`\nTotal: ${disciplines.length} disciplines`);
-  console.log(`\nRun 'bunx pathway discipline --list' for IDs and names`);
-  console.log(`Run 'bunx pathway discipline <id>' for details\n`);
+  process.stdout.write(
+    formatTable(["ID", "Specialization", "Type", "Tracks"], rows) + "\n",
+  );
+  process.stdout.write(
+    "\n" + formatSubheader(`Total: ${disciplines.length} disciplines`) + "\n\n",
+  );
+  process.stdout.write(
+    formatBullet("Run 'npx fit-pathway discipline --list' for IDs and names") +
+      "\n",
+  );
+  process.stdout.write(
+    formatBullet("Run 'npx fit-pathway discipline <id>' for details") + "\n\n",
+  );
 }
 
 /**

package/src/commands/driver.js

@@ -4,20 +4,20 @@
  * Handles driver summary, listing, and detail display in the terminal.
  *
  * Usage:
- *   bunx pathway driver              # Summary with stats
- *   bunx pathway driver --list       # IDs only (for piping)
- *   bunx pathway driver <id>         # Detail view
- *   bunx pathway driver --validate   # Validation checks
+ *   npx fit-pathway driver              # Summary with stats
+ *   npx fit-pathway driver --list       # IDs only (for piping)
+ *   npx fit-pathway driver <id>         # Detail view
+ *   npx fit-pathway driver --validate   # Validation checks
  */
 
 import { createEntityCommand } from "./command-factory.js";
 import { prepareDriverDetail } from "../formatters/driver/shared.js";
-import { formatTable } from "../lib/cli-output.js";
 import {
+  formatTable,
   formatHeader,
   formatSubheader,
   formatBullet,
-} from "../lib/cli-output.js";
+} from "@forwardimpact/libcli";
 import { getConceptEmoji } from "@forwardimpact/map/levels";
 
 /**
@@ -38,7 +38,7 @@ function formatSummary(drivers, data) {
   const { skills, behaviours, framework } = data;
   const emoji = framework ? getConceptEmoji(framework, "driver") : "🎯";
 
-  console.log(`\n${emoji} Drivers\n`);
+  process.stdout.write("\n" + formatHeader(`${emoji} Drivers`) + "\n\n");
 
   const rows = drivers.map((d) => {
     const contributingSkills = skills.filter((s) =>
@@ -50,10 +50,19 @@ function formatSummary(drivers, data) {
     return [d.id, d.name, contributingSkills, contributingBehaviours];
   });
 
-  console.log(formatTable(["ID", "Name", "Skills", "Behaviours"], rows));
-  console.log(`\nTotal: ${drivers.length} drivers`);
-  console.log(`\nRun 'bunx pathway driver --list' for IDs and names`);
-  console.log(`Run 'bunx pathway driver <id>' for details\n`);
+  process.stdout.write(
+    formatTable(["ID", "Name", "Skills", "Behaviours"], rows) + "\n",
+  );
+  process.stdout.write(
+    "\n" + formatSubheader(`Total: ${drivers.length} drivers`) + "\n\n",
+  );
+  process.stdout.write(
+    formatBullet("Run 'npx fit-pathway driver --list' for IDs and names") +
+      "\n",
+  );
+  process.stdout.write(
+    formatBullet("Run 'npx fit-pathway driver <id>' for details") + "\n\n",
+  );
 }
 
 /**
@@ -66,25 +75,25 @@ function formatDetail(viewAndContext, framework) {
   const view = prepareDriverDetail(driver, { skills, behaviours });
   const emoji = framework ? getConceptEmoji(framework, "driver") : "🎯";
 
-  console.log(formatHeader(`\n${emoji} ${view.name}\n`));
-  console.log(`${view.description}\n`);
+  process.stdout.write("\n" + formatHeader(`${emoji} ${view.name}`) + "\n\n");
+  process.stdout.write(view.description + "\n\n");
 
   // Contributing skills
   if (view.contributingSkills.length > 0) {
-    console.log(formatSubheader("Contributing Skills\n"));
+    process.stdout.write(formatSubheader("Contributing Skills") + "\n\n");
     for (const s of view.contributingSkills) {
-      console.log(formatBullet(s.name, 1));
+      process.stdout.write(formatBullet(s.name, 1) + "\n");
     }
-    console.log();
+    process.stdout.write("\n");
   }
 
   // Contributing behaviours
   if (view.contributingBehaviours.length > 0) {
-    console.log(formatSubheader("Contributing Behaviours\n"));
+    process.stdout.write(formatSubheader("Contributing Behaviours") + "\n\n");
     for (const b of view.contributingBehaviours) {
-      console.log(formatBullet(b.name, 1));
+      process.stdout.write(formatBullet(b.name, 1) + "\n");
     }
-    console.log();
+    process.stdout.write("\n");
   }
 }
 

package/src/commands/index.js

@@ -17,6 +17,5 @@ export { runInterviewCommand } from "./interview.js";
 export { runProgressCommand } from "./progress.js";
 export { runQuestionsCommand } from "./questions.js";
 export { runServeCommand } from "./serve.js";
-export { runInitCommand } from "./init.js";
 export { runSiteCommand } from "./site.js";
 export { runUpdateCommand } from "./update.js";

package/src/commands/interview.js

@@ -4,9 +4,9 @@
  * Generates and displays interview questions in the terminal.
  *
  * Usage:
- *   bunx fit-pathway interview <discipline> <level>                                  # All interview types
- *   bunx fit-pathway interview <discipline> <level> --track=<track>                  # With track
- *   bunx fit-pathway interview <discipline> <level> --track=<track> --type=mission   # Single type
+ *   npx fit-pathway interview <discipline> <level>                                  # All interview types
+ *   npx fit-pathway interview <discipline> <level> --track=<track>                  # With track
+ *   npx fit-pathway interview <discipline> <level> --track=<track> --type=mission   # Single type
  */
 
 import { createCompositeCommand } from "./command-factory.js";
@@ -15,6 +15,7 @@ import {
   INTERVIEW_TYPES,
 } from "../formatters/interview/shared.js";
 import { interviewToMarkdown } from "../formatters/interview/markdown.js";
+import { formatError, horizontalRule } from "@forwardimpact/libcli";
 
 const VALID_TYPES = Object.keys(INTERVIEW_TYPES);
 
@@ -24,7 +25,9 @@ const VALID_TYPES = Object.keys(INTERVIEW_TYPES);
  * @param {Object} options - Options including framework
  */
 function formatInterview(view, options) {
-  console.log(interviewToMarkdown(view, { framework: options.framework }));
+  process.stdout.write(
+    interviewToMarkdown(view, { framework: options.framework }) + "\n",
+  );
 }
 
 /**
@@ -35,10 +38,10 @@ function formatInterview(view, options) {
 function formatAllInterviews(views, options) {
   for (let i = 0; i < views.length; i++) {
     if (i > 0) {
-      console.log("\n" + "─".repeat(80) + "\n");
+      process.stdout.write("\n" + horizontalRule(80) + "\n\n");
     }
-    console.log(
-      interviewToMarkdown(views[i], { framework: options.framework }),
+    process.stdout.write(
+      interviewToMarkdown(views[i], { framework: options.framework }) + "\n",
     );
   }
 }
@@ -50,8 +53,10 @@ export const runInterviewCommand = createCompositeCommand({
     const interviewType = options.type === "full" ? null : options.type;
 
     if (interviewType && !INTERVIEW_TYPES[interviewType]) {
-      console.error(`Unknown interview type: ${interviewType}`);
-      console.error(`Available types: ${VALID_TYPES.join(", ")}`);
+      process.stderr.write(
+        formatError(`Unknown interview type: ${interviewType}`) + "\n",
+      );
+      process.stderr.write(`Available types: ${VALID_TYPES.join(", ")}\n`);
       process.exit(1);
     }
 
@@ -109,5 +114,5 @@ export const runInterviewCommand = createCompositeCommand({
     }
   },
   usageExample:
-    "bunx fit-pathway interview software_engineering J090 --track=platform --type=mission",
+    "npx fit-pathway interview software_engineering J090 --track=platform --type=mission",
 });