@forwardimpact/pathway 0.25.21 → 0.25.24

package/src/formatters/skill/shared.js

@@ -95,11 +95,18 @@ export function prepareSkillDetail(
   if (!skill) return null;
 
   const relatedDisciplines = disciplines
-    .filter((d) => getSkillTypeForDiscipline(d, skill.id) !== null)
+    .filter(
+      (d) =>
+        getSkillTypeForDiscipline({ discipline: d, skillId: skill.id }) !==
+        null,
+    )
     .map((d) => ({
       id: d.id,
       name: d.specialization || d.name,
-      skillType: getSkillTypeForDiscipline(d, skill.id),
+      skillType: getSkillTypeForDiscipline({
+        discipline: d,
+        skillId: skill.id,
+      }),
     }));
 
   const relatedTracks = tracks

package/src/formatters/track/shared.js

@@ -88,7 +88,10 @@ export function prepareTrackDetail(track, { skills, behaviours }) {
   const skillModifiers = track.skillModifiers
     ? Object.entries(track.skillModifiers).map(([key, modifier]) => {
         if (isCapability(key)) {
-          const capabilitySkills = getSkillsByCapability(skills, key);
+          const capabilitySkills = getSkillsByCapability({
+            skills,
+            capability: key,
+          });
           return {
             id: key,
             name: key.charAt(0).toUpperCase() + key.slice(1),

package/src/index.html

@@ -83,7 +83,7 @@
         <div class="top-bar__command">
           <span class="top-bar__prompt">$</span>
           <span class="top-bar__command-text" id="cli-command"
-            >bunx fit-pathway</span
+            >npx fit-pathway</span
           >
           <button class="top-bar__copy" id="cli-copy" aria-label="Copy command">
             <svg viewBox="0 0 24 24">

package/src/lib/cli-command.js

@@ -1,7 +1,7 @@
 /**
  * CLI Command Mapping
  *
- * Maps hash routes to their equivalent `bunx fit-pathway` CLI commands.
+ * Maps hash routes to their equivalent `npx fit-pathway` CLI commands.
  */
 
 /**
@@ -11,122 +11,122 @@
  */
 const ROUTE_COMMANDS = [
   // Landing
-  { pattern: /^\/$/, toCommand: () => "bunx fit-pathway" },
+  { pattern: /^\/$/, toCommand: () => "npx fit-pathway" },
 
   // Entity lists
-  { pattern: /^\/skill$/, toCommand: () => "bunx fit-pathway skill" },
-  { pattern: /^\/behaviour$/, toCommand: () => "bunx fit-pathway behaviour" },
+  { pattern: /^\/skill$/, toCommand: () => "npx fit-pathway skill" },
+  { pattern: /^\/behaviour$/, toCommand: () => "npx fit-pathway behaviour" },
   {
     pattern: /^\/discipline$/,
-    toCommand: () => "bunx fit-pathway discipline",
+    toCommand: () => "npx fit-pathway discipline",
   },
-  { pattern: /^\/track$/, toCommand: () => "bunx fit-pathway track" },
-  { pattern: /^\/level$/, toCommand: () => "bunx fit-pathway level" },
-  { pattern: /^\/driver$/, toCommand: () => "bunx fit-pathway driver" },
-  { pattern: /^\/stage$/, toCommand: () => "bunx fit-pathway stage" },
-  { pattern: /^\/tool$/, toCommand: () => "bunx fit-pathway tool" },
+  { pattern: /^\/track$/, toCommand: () => "npx fit-pathway track" },
+  { pattern: /^\/level$/, toCommand: () => "npx fit-pathway level" },
+  { pattern: /^\/driver$/, toCommand: () => "npx fit-pathway driver" },
+  { pattern: /^\/stage$/, toCommand: () => "npx fit-pathway stage" },
+  { pattern: /^\/tool$/, toCommand: () => "npx fit-pathway tool" },
 
   // Entity details
   {
     pattern: /^\/skill\/(.+)$/,
-    toCommand: (m) => `bunx fit-pathway skill ${m[1]}`,
+    toCommand: (m) => `npx fit-pathway skill ${m[1]}`,
   },
   {
     pattern: /^\/behaviour\/(.+)$/,
-    toCommand: (m) => `bunx fit-pathway behaviour ${m[1]}`,
+    toCommand: (m) => `npx fit-pathway behaviour ${m[1]}`,
   },
   {
     pattern: /^\/discipline\/(.+)$/,
-    toCommand: (m) => `bunx fit-pathway discipline ${m[1]}`,
+    toCommand: (m) => `npx fit-pathway discipline ${m[1]}`,
   },
   {
     pattern: /^\/track\/(.+)$/,
-    toCommand: (m) => `bunx fit-pathway track ${m[1]}`,
+    toCommand: (m) => `npx fit-pathway track ${m[1]}`,
   },
   {
     pattern: /^\/level\/(.+)$/,
-    toCommand: (m) => `bunx fit-pathway level ${m[1]}`,
+    toCommand: (m) => `npx fit-pathway level ${m[1]}`,
   },
   {
     pattern: /^\/driver\/(.+)$/,
-    toCommand: (m) => `bunx fit-pathway driver ${m[1]}`,
+    toCommand: (m) => `npx fit-pathway driver ${m[1]}`,
   },
   {
     pattern: /^\/stage\/(.+)$/,
-    toCommand: (m) => `bunx fit-pathway stage ${m[1]}`,
+    toCommand: (m) => `npx fit-pathway stage ${m[1]}`,
   },
 
   // Job builder + detail
   {
     pattern: /^\/job-builder$/,
-    toCommand: () => "bunx fit-pathway job --list",
+    toCommand: () => "npx fit-pathway job --list",
   },
   {
     pattern: /^\/job\/([^/]+)\/([^/]+)\/([^/]+)$/,
-    toCommand: (m) => `bunx fit-pathway job ${m[1]} ${m[2]} --track=${m[3]}`,
+    toCommand: (m) => `npx fit-pathway job ${m[1]} ${m[2]} --track=${m[3]}`,
   },
   {
     pattern: /^\/job\/([^/]+)\/([^/]+)$/,
-    toCommand: (m) => `bunx fit-pathway job ${m[1]} ${m[2]}`,
+    toCommand: (m) => `npx fit-pathway job ${m[1]} ${m[2]}`,
   },
 
   // Interview builder + detail
   {
     pattern: /^\/interview-prep$/,
-    toCommand: () => "bunx fit-pathway interview --list",
+    toCommand: () => "npx fit-pathway interview --list",
   },
   {
     pattern: /^\/interview\/([^/]+)\/([^/]+)\/([^/]+)$/,
     toCommand: (m) =>
-      `bunx fit-pathway interview ${m[1]} ${m[2]} --track=${m[3]}`,
+      `npx fit-pathway interview ${m[1]} ${m[2]} --track=${m[3]}`,
   },
   {
     pattern: /^\/interview\/([^/]+)\/([^/]+)$/,
-    toCommand: (m) => `bunx fit-pathway interview ${m[1]} ${m[2]}`,
+    toCommand: (m) => `npx fit-pathway interview ${m[1]} ${m[2]}`,
   },
 
   // Career progress builder + detail
   {
     pattern: /^\/career-progress$/,
-    toCommand: () => "bunx fit-pathway progress --list",
+    toCommand: () => "npx fit-pathway progress --list",
   },
   {
     pattern: /^\/progress\/([^/]+)\/([^/]+)\/([^/]+)$/,
     toCommand: (m) =>
-      `bunx fit-pathway progress ${m[1]} ${m[2]} --track=${m[3]}`,
+      `npx fit-pathway progress ${m[1]} ${m[2]} --track=${m[3]}`,
   },
   {
     pattern: /^\/progress\/([^/]+)\/([^/]+)$/,
-    toCommand: (m) => `bunx fit-pathway progress ${m[1]} ${m[2]}`,
+    toCommand: (m) => `npx fit-pathway progress ${m[1]} ${m[2]}`,
   },
 
   // Self-assessment
   {
     pattern: /^\/self-assessment$/,
-    toCommand: () => "bunx fit-pathway self-assessment",
+    toCommand: () => "npx fit-pathway self-assessment",
   },
   {
     pattern: /^\/self-assessment\/results$/,
-    toCommand: () => "bunx fit-pathway self-assessment",
+    toCommand: () => "npx fit-pathway self-assessment",
   },
 
   // Agent builder + detail
   {
     pattern: /^\/agent-builder$/,
-    toCommand: () => "bunx fit-pathway agent --list",
+    toCommand: () => "npx fit-pathway agent --list",
   },
   {
     pattern: /^\/agent\/([^/]+)\/([^/]+)\/([^/]+)$/,
     toCommand: (m) =>
-      `bunx fit-pathway agent ${m[1]} --track=${m[2]} --stage=${m[3]}`,
+      `npx fit-pathway agent ${m[1]} --track=${m[2]} --stage=${m[3]}`,
   },
   {
     pattern: /^\/agent\/([^/]+)\/([^/]+)$/,
-    toCommand: (m) => `bunx fit-pathway agent ${m[1]} --track=${m[2]}`,
+    toCommand: (m) => `npx fit-pathway agent ${m[1]} --track=${m[2]}`,
   },
   {
     pattern: /^\/agent\/([^/]+)$/,
-    toCommand: (m) => `bunx fit-pathway agent ${m[1]}`,
+    toCommand: (m) => `npx fit-pathway agent ${m[1]}`,
   },
 ];
 
@@ -141,5 +141,5 @@ export function getCliCommand(hashPath) {
     const match = path.match(pattern);
     if (match) return toCommand(match);
   }
-  return "bunx fit-pathway";
+  return "npx fit-pathway";
 }

package/src/lib/cli-output.js

@@ -1,129 +1,12 @@
 /**
- * CLI Output Formatting Utilities
+ * Domain-specific CLI Output Formatters
  *
- * Provides consistent formatting for terminal output including colors,
- * tables, headers, and level formatting.
+ * Pathway-specific formatting for skill proficiencies, behaviour maturities,
+ * modifiers, percentages, and change indicators. Generic formatters (colors,
+ * tables, headers, etc.) live in @forwardimpact/libcli.
  */
 
-// ANSI color codes
-export const colors = {
-  reset: "\x1b[0m",
-  bold: "\x1b[1m",
-  dim: "\x1b[2m",
-  italic: "\x1b[3m",
-  underline: "\x1b[4m",
-  red: "\x1b[31m",
-  green: "\x1b[32m",
-  yellow: "\x1b[33m",
-  blue: "\x1b[34m",
-  magenta: "\x1b[35m",
-  cyan: "\x1b[36m",
-  white: "\x1b[37m",
-  gray: "\x1b[90m",
-};
-
-/**
- * Check if stdout supports colors
- * @returns {boolean}
- */
-export function supportsColor() {
-  if (process.env.NO_COLOR) return false;
-  if (process.env.FORCE_COLOR) return true;
-  return process.stdout.isTTY;
-}
-
-/**
- * Wrap text with color if supported
- * @param {string} text
- * @param {string} color
- * @returns {string}
- */
-function colorize(text, color) {
-  if (!supportsColor()) return text;
-  return `${color}${text}${colors.reset}`;
-}
-
-/**
- * Format a header
- * @param {string} text
- * @returns {string}
- */
-export function formatHeader(text) {
-  return colorize(text, colors.bold + colors.cyan);
-}
-
-/**
- * Format a subheader
- * @param {string} text
- * @returns {string}
- */
-export function formatSubheader(text) {
-  return colorize(text, colors.bold);
-}
-
-/**
- * Format a list item
- * @param {string} label
- * @param {string} value
- * @param {number} [indent=0]
- * @returns {string}
- */
-export function formatListItem(label, value, indent = 0) {
-  const padding = "  ".repeat(indent);
-  const bullet = colorize("•", colors.dim);
-  return `${padding}${bullet} ${label}: ${value}`;
-}
-
-/**
- * Format a bullet item (no label)
- * @param {string} text
- * @param {number} [indent=0]
- * @returns {string}
- */
-export function formatBullet(text, indent = 0) {
-  const padding = "  ".repeat(indent);
-  const bullet = colorize("•", colors.dim);
-  return `${padding}${bullet} ${text}`;
-}
-
-/**
- * Format a table
- * @param {string[]} headers
- * @param {Array<Array<string|number>>} rows
- * @param {Object} [options]
- * @param {boolean} [options.compact=false]
- * @returns {string}
- */
-export function formatTable(headers, rows, options = {}) {
-  const { compact = false } = options;
-
-  // Calculate column widths
-  const widths = headers.map((h, i) =>
-    Math.max(String(h).length, ...rows.map((r) => String(r[i] || "").length)),
-  );
-
-  const lines = [];
-
-  // Header
-  const headerLine = headers
-    .map((h, i) => String(h).padEnd(widths[i]))
-    .join("  ");
-  lines.push(colorize(headerLine, colors.bold));
-
-  // Separator
-  if (!compact) {
-    lines.push(widths.map((w) => "─".repeat(w)).join("──"));
-  }
-
-  // Rows
-  for (const row of rows) {
-    lines.push(
-      row.map((cell, i) => String(cell || "").padEnd(widths[i])).join("  "),
-    );
-  }
-
-  return lines.join("\n");
-}
+import { colorize, colors } from "@forwardimpact/libcli";
 
 /**
  * Format skill proficiency with color
@@ -193,78 +76,15 @@ export function formatPercent(value) {
 }
 
 /**
- * Format a change indicator (↑, ↓, →)
+ * Format a change indicator
  * @param {number} change
  * @returns {string}
  */
 export function formatChange(change) {
   if (change > 0) {
-    return colorize(`↑${change}`, colors.green);
+    return colorize(`\u2191${change}`, colors.green);
   } else if (change < 0) {
-    return colorize(`↓${Math.abs(change)}`, colors.red);
+    return colorize(`\u2193${Math.abs(change)}`, colors.red);
   }
-  return colorize("→", colors.dim);
-}
-
-/**
- * Format an error message
- * @param {string} message
- * @returns {string}
- */
-export function formatError(message) {
-  return colorize(`Error: ${message}`, colors.red);
-}
-
-/**
- * Format a success message
- * @param {string} message
- * @returns {string}
- */
-export function formatSuccess(message) {
-  return colorize(message, colors.green);
-}
-
-/**
- * Format a warning message
- * @param {string} message
-/**
- * Format a warning message
- * @param {string} message
- * @returns {string}
- */
-export function formatWarning(message) {
-  return colorize(`Warning: ${message}`, colors.yellow);
-}
-
-/**
- * Create a horizontal rule
- * @param {number} [width=60]
- * @returns {string}
- */
-export function horizontalRule(width = 60) {
-  return colorize("─".repeat(width), colors.dim);
-}
-
-/**
- * Format a section with title and content
- * @param {string} title
- * @param {string} content
- * @returns {string}
- */
-export function formatSection(title, content) {
-  return `${formatHeader(title)}\n\n${content}`;
-}
-
-/**
- * Indent all lines of text
- * @param {string} text
- * @param {number} [spaces=2]
- * @returns {string}
- */
-export function indent(text, spaces = 2) {
-  const padding = " ".repeat(spaces);
-  return text
-    .split("\n")
-    .map((line) => padding + line)
-    .join("\n");
+  return colorize("\u2192", colors.dim);
 }

package/src/pages/agent-builder-install.js

@@ -0,0 +1,118 @@
+/**
+ * Agent builder install section
+ *
+ * Surfaces the ecosystem-tool install commands (Microsoft APM and
+ * `npx skills`) for the currently selected discipline/track pack. The packs
+ * themselves are emitted by `fit-pathway build` when
+ * `framework.distribution.siteUrl` is configured — see spec 320 and
+ * `products/pathway/src/commands/build-packs.js`. The pack name derivation
+ * here must stay in sync with that generator so the command points at an
+ * archive that actually exists on the deployed site.
+ */
+
+import { code, div, h2, p, section } from "../lib/render.js";
+import {
+  getDisciplineAbbreviation,
+  toKebabCase,
+} from "@forwardimpact/libskill/agent";
+import { createCommandPrompt } from "../components/command-prompt.js";
+
+/** Stable id for the install section heading (for aria-labelledby). */
+const INSTALL_HEADING_ID = "agent-builder-install-heading";
+
+/**
+ * Derive the pack archive name for a discipline/track combination.
+ * Must match `build-packs.js` → `${abbrev}-${toKebabCase(track.id)}`.
+ * @param {{id: string}} discipline
+ * @param {{id: string}} track
+ * @returns {string}
+ */
+export function getPackName(discipline, track) {
+  return `${getDisciplineAbbreviation(discipline.id)}-${toKebabCase(track.id)}`;
+}
+
+/**
+ * Normalize a site URL by stripping a trailing slash. Matches the
+ * normalization applied by `generatePacks` so the displayed URL lines up
+ * with the manifest entries.
+ * @param {string} siteUrl
+ * @returns {string}
+ */
+function normalizeSiteUrl(siteUrl) {
+  return siteUrl.replace(/\/$/, "");
+}
+
+/**
+ * Build the `apm install` command for a specific pack archive. Targets the
+ * direct archive URL (rather than a registry-style shorthand) because it is
+ * the most durable path through APM's evolving resolution logic and matches
+ * the URL listed in the generated `apm.yml` manifest.
+ * @param {string} siteUrl
+ * @param {string} packName
+ * @returns {string}
+ */
+export function getApmInstallCommand(siteUrl, packName) {
+  return `apm install ${normalizeSiteUrl(siteUrl)}/packs/${packName}.tar.gz`;
+}
+
+/**
+ * Build the `npx skills add` command that discovers the per-pack skill
+ * repository at `<siteUrl>/packs/<packName>/.well-known/skills/index.json`.
+ * @param {string} siteUrl
+ * @param {string} packName
+ * @returns {string}
+ */
+export function getSkillsAddCommand(siteUrl, packName) {
+  return `npx skills add ${normalizeSiteUrl(siteUrl)}/packs/${packName}`;
+}
+
+/**
+ * Render the install section for the selected agent combination. Returns
+ * `null` when no site URL is configured (no packs have been published, so
+ * there is nothing meaningful to install) so the caller can skip rendering.
+ * @param {Object} params
+ * @param {{id: string}} params.discipline - Selected human discipline
+ * @param {{id: string}} params.track - Selected human track
+ * @param {string|undefined} params.siteUrl - Framework distribution site URL
+ * @returns {HTMLElement|null}
+ */
+export function createInstallSection({ discipline, track, siteUrl }) {
+  if (!siteUrl) return null;
+
+  const packName = getPackName(discipline, track);
+  const apmCommand = getApmInstallCommand(siteUrl, packName);
+  const skillsCommand = getSkillsAddCommand(siteUrl, packName);
+
+  return section(
+    {
+      className: "agent-install-section",
+      "aria-labelledby": INSTALL_HEADING_ID,
+    },
+    div(
+      { className: "agent-install-header" },
+      h2({ id: INSTALL_HEADING_ID }, "📦 Install This Agent Team"),
+      p(
+        { className: "text-muted agent-install-description" },
+        "Install the pre-built pack for this discipline × track combination " +
+          "directly through an ecosystem package manager. The pack contains " +
+          "the same stage agents, skills, team instructions, and Claude Code " +
+          "settings shown below — installed into your project's ",
+        code({}, ".claude/"),
+        " directory.",
+      ),
+    ),
+    div(
+      { className: "agent-install-commands" },
+      div(
+        { className: "agent-install-command" },
+        p({ className: "agent-install-command-label" }, "Microsoft APM"),
+        createCommandPrompt(apmCommand),
+      ),
+      div(
+        { className: "agent-install-command" },
+        p({ className: "agent-install-command-label" }, "npx skills"),
+        createCommandPrompt(skillsCommand),
+      ),
+    ),
+  );
+}

package/src/pages/agent-builder-preview.js

@@ -10,8 +10,8 @@ import {
   deriveStageAgent,
   generateSkillMarkdown,
   deriveAgentSkills,
-  deriveToolkit,
-} from "@forwardimpact/libskill";
+} from "@forwardimpact/libskill/agent";
+import { deriveToolkit } from "@forwardimpact/libskill/toolkit";
 import { getStageEmoji } from "../formatters/stage/shared.js";
 import { formatAgentProfile } from "../formatters/agent/profile.js";
 import {
@@ -115,7 +115,7 @@ function deriveSkillData(context) {
   const skillFiles = derivedSkills
     .map((d) => skills.find((s) => s.id === d.skillId))
     .filter((skill) => skill?.agent)
-    .map((skill) => generateSkillMarkdown(skill, stages));
+    .map((skill) => generateSkillMarkdown({ skillData: skill, stages }));
 
   const toolkit = deriveToolkit({
     skillMatrix: derivedSkills,

package/src/pages/agent-builder.js

@@ -18,7 +18,7 @@ import {
 } from "../lib/render.js";
 import { getState } from "../lib/state.js";
 import { loadAgentDataBrowser } from "../lib/yaml-loader.js";
-import { deriveReferenceLevel } from "@forwardimpact/libskill";
+import { deriveReferenceLevel } from "@forwardimpact/libskill/agent";
 import {
   createSelectWithValue,
   createDisciplineSelect,
@@ -30,6 +30,7 @@ import {
   createSingleStagePreview,
   createHelpSection,
 } from "./agent-builder-preview.js";
+import { createInstallSection } from "./agent-builder-install.js";
 
 /** All stages option value */
 const ALL_STAGES_VALUE = "all";
@@ -79,6 +80,7 @@ async function getTemplates() {
  */
 export async function renderAgentBuilder() {
   const { data } = getState();
+  const siteUrl = data.framework?.distribution?.siteUrl;
 
   // Show loading state
   render(
@@ -260,8 +262,27 @@ export async function renderAgentBuilder() {
       templates,
     };
 
+    // Install section (ecosystem-tool install commands) — appears above the
+    // preview cards so the install action is visible before users scroll
+    // through the generated files. Only rendered when the framework has a
+    // published distribution site URL, since the packs only exist at that
+    // URL after a `fit-pathway build`. Must come after the stage-validity
+    // guard below so an invalid stage id (e.g. from a stale bookmark) does
+    // not pair the install card with a "Stage not found" error.
+    function appendInstallSection() {
+      const installSection = createInstallSection({
+        discipline: humanDiscipline,
+        track: humanTrack,
+        siteUrl,
+      });
+      if (installSection) {
+        previewContainer.appendChild(installSection);
+      }
+    }
+
     // Generate preview based on stage selection
     if (stage === ALL_STAGES_VALUE) {
+      appendInstallSection();
       previewContainer.appendChild(createAllStagesPreview(context));
     } else {
       const stageObj = stages.find((s) => s.id === stage);
@@ -274,6 +295,7 @@ export async function renderAgentBuilder() {
         );
         return;
       }
+      appendInstallSection();
       previewContainer.appendChild(createSingleStagePreview(context, stageObj));
     }
   }

package/src/pages/progress.js

@@ -16,8 +16,8 @@ import {
   prepareCurrentJob,
   prepareCustomProgression,
   getDefaultTargetLevel,
-  isValidCombination,
 } from "../formatters/progress/shared.js";
+import { isValidJobCombination } from "@forwardimpact/libskill/derivation";
 import { buildComparisonResult } from "./progress-comparison.js";
 
 /**
@@ -188,7 +188,7 @@ function createComparisonSelectorsSection({
     for (const level of data.levels) {
       // Check trackless combination
       if (
-        isValidCombination({ discipline: selectedDisc, level, track: null })
+        isValidJobCombination({ discipline: selectedDisc, level, track: null })
       ) {
         if (!validLevels.find((g) => g.id === level.id)) {
           validLevels.push(level);
@@ -197,7 +197,7 @@ function createComparisonSelectorsSection({
       }
       // Check each track combination
       for (const track of data.tracks) {
-        if (isValidCombination({ discipline: selectedDisc, level, track })) {
+        if (isValidJobCombination({ discipline: selectedDisc, level, track })) {
           if (!validLevels.find((g) => g.id === level.id)) {
             validLevels.push(level);
           }

package/src/pages/skill.js

@@ -11,7 +11,7 @@ import { prepareSkillsList } from "../formatters/skill/shared.js";
 import { skillToDOM } from "../formatters/skill/dom.js";
 import { skillToCardConfig } from "../lib/card-mappers.js";
 import { getCapabilityEmoji, getConceptEmoji } from "@forwardimpact/map/levels";
-import { generateSkillMarkdown } from "@forwardimpact/libskill";
+import { generateSkillMarkdown } from "@forwardimpact/libskill/agent";
 import { formatAgentSkill } from "../formatters/agent/skill.js";
 
 /** @type {string|null} Cached skill template */
@@ -101,7 +101,10 @@ export async function renderSkillDetail(params) {
   let agentSkillContent;
   if (skill.agent) {
     const template = await getSkillTemplate();
-    const skillData = generateSkillMarkdown(skill, data.stages);
+    const skillData = generateSkillMarkdown({
+      skillData: skill,
+      stages: data.stages,
+    });
     agentSkillContent = formatAgentSkill(skillData, template);
   }