takomi 2.1.44 → 2.5.1

package/.pi/extensions/takomi-context-manager/policy-tools.ts

@@ -1,42 +1,93 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-import type { ContextManagerState } from "./state";
-import { syncReportLedger } from "./state";
-import { renderPolicies, renderPolicyManifest } from "./policy-registry";
-import { persistReportSnapshot, restoreReportFromSession } from "./session-state";
-
-export function registerPolicyTools(pi: ExtensionAPI, state: ContextManagerState): void {
-  pi.registerTool({
-    name: "policy_manifest",
-    label: "Policy Manifest",
-    description: "Return descriptions for available context policy packs without loading full policy content.",
-    promptSnippet: "Show available context policy pack descriptions",
-    parameters: Type.Object({ policies: Type.Optional(Type.Array(Type.String({ description: "Policy name to inspect" }))) }),
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      restoreReportFromSession(state, ctx);
-      state.report.timestamp = new Date().toISOString();
-      state.report.cwd = ctx.cwd;
-      state.report.toolCalls.policyManifest += 1;
-      persistReportSnapshot(pi, state, "policy_manifest");
-      return { content: [{ type: "text", text: renderPolicyManifest(state.policies, params.policies ?? []) }], details: { requested: params.policies ?? [...state.policies.keys()] } };
-    },
-  });
-
-  pi.registerTool({
-    name: "policy_load",
-    label: "Policy Load",
-    description: "Load one or more context policy packs required before sensitive tools such as takomi_subagent.",
-    promptSnippet: "Load policy packs required before sensitive tool calls",
-    parameters: Type.Object({ policies: Type.Array(Type.String({ description: "Policy pack name to load" })) }),
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      restoreReportFromSession(state, ctx);
-      state.report.timestamp = new Date().toISOString();
-      state.report.cwd = ctx.cwd;
-      state.report.toolCalls.policyLoad += 1;
-      const text = renderPolicies(state.policies, state.loadedPolicies, params.policies);
-      syncReportLedger(state);
-      persistReportSnapshot(pi, state, "policy_load");
-      return { content: [{ type: "text", text }], details: { requested: params.policies, loadedPolicies: [...state.loadedPolicies].sort() } };
-    },
-  });
-}
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import type { ContextManagerState } from "./state";
+import { syncReportLedger } from "./state";
+import { renderPolicies, renderPolicyManifest } from "./policy-registry";
+import { persistReportSnapshot, restoreReportFromSession } from "./session-state";
+import { renderCompactCard, renderExpandedMarkdown, renderToolCall, resultText } from "./tool-renderers";
+import { normalizeName } from "./skill-registry";
+
+function requestedPolicies(state: ContextManagerState, names: string[] | undefined): string[] {
+  return names?.length ? names : [...state.policies.values()].map((policy) => policy.name).sort((a, b) => a.localeCompare(b, "en"));
+}
+
+function missingPolicies(state: ContextManagerState, names: string[]): string[] {
+  return names.filter((name) => !state.policies.has(normalizeName(name)));
+}
+
+export function registerPolicyTools(pi: ExtensionAPI, state: ContextManagerState): void {
+  pi.registerTool({
+    name: "policy_manifest",
+    label: "Policy Manifest",
+    description: "Return descriptions for available context policy packs without loading full policy content.",
+    promptSnippet: "Show available context policy pack descriptions",
+    parameters: Type.Object({ policies: Type.Optional(Type.Array(Type.String({ description: "Policy name to inspect" }))) }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      restoreReportFromSession(state, ctx);
+      state.report.timestamp = new Date().toISOString();
+      state.report.cwd = ctx.cwd;
+      state.report.toolCalls.policyManifest += 1;
+      persistReportSnapshot(pi, state, "policy_manifest");
+      const requested = requestedPolicies(state, params.policies);
+      const missing = missingPolicies(state, requested);
+      return { content: [{ type: "text", text: renderPolicyManifest(state.policies, params.policies ?? []) }], details: { requested, found: requested.length - missing.length, missing } };
+    },
+    renderCall(args, theme) {
+      return renderToolCall("policy_manifest", args.policies?.length ? `${args.policies.length} requested` : "all policies", theme);
+    },
+    renderResult(result, { expanded }, theme) {
+      const details = result.details as { requested?: string[]; found?: number; missing?: string[] } | undefined;
+      const requested = details?.requested ?? [];
+      const found = details?.found ?? 0;
+      const missing = details?.missing ?? [];
+      const status = missing.length ? "warning" : requested.length ? "success" : "pending";
+      const summary = missing.length ? `${found} available · ${missing.length} unavailable` : requested.length ? `${found} policies available` : "no policies discovered";
+      const metadata = missing.length ? `Missing: ${missing.join(", ")}` : `${requested.length} requested`;
+      if (!expanded) return renderCompactCard({ status, title: "Policy manifest", summary, metadata }, theme);
+      return renderExpandedMarkdown({ status, title: "Policy manifest", summary, metadata: [metadata], markdown: resultText(result) }, theme);
+    },
+  });
+
+  pi.registerTool({
+    name: "policy_load",
+    label: "Policy Load",
+    description: "Load one or more context policy packs required before sensitive tools such as takomi_subagent.",
+    promptSnippet: "Load policy packs required before sensitive tool calls",
+    parameters: Type.Object({ policies: Type.Array(Type.String({ description: "Policy pack name to load" })) }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      restoreReportFromSession(state, ctx);
+      state.report.timestamp = new Date().toISOString();
+      state.report.cwd = ctx.cwd;
+      state.report.toolCalls.policyLoad += 1;
+      const text = renderPolicies(state.policies, state.loadedPolicies, params.policies);
+      syncReportLedger(state);
+      persistReportSnapshot(pi, state, "policy_load");
+      const missing = missingPolicies(state, params.policies);
+      return {
+        content: [{ type: "text", text }],
+        details: {
+          requested: params.policies,
+          loadedPolicies: [...state.loadedPolicies].sort(),
+          loadedCount: params.policies.length - missing.length,
+          missing,
+        },
+      };
+    },
+    renderCall(args, theme) {
+      return renderToolCall("policy_load", `${args.policies.length} requested`, theme);
+    },
+    renderResult(result, { expanded }, theme) {
+      const details = result.details as { requested?: string[]; loadedCount?: number; missing?: string[] } | undefined;
+      const requested = details?.requested ?? [];
+      const loadedCount = details?.loadedCount ?? 0;
+      const missing = details?.missing ?? [];
+      const status = missing.length || requested.length === 0 ? "warning" : "success";
+      const summary = requested.length === 0
+        ? "no policies requested"
+        : missing.length ? `${loadedCount} loaded · ${missing.length} unavailable` : `${loadedCount} policies loaded`;
+      const metadata = missing.length ? `Missing: ${missing.join(", ")}` : `${requested.length} requested`;
+      if (!expanded) return renderCompactCard({ status, title: "Policy load", summary, metadata }, theme);
+      return renderExpandedMarkdown({ status, title: "Policy load", summary, metadata: [metadata], markdown: resultText(result) }, theme);
+    },
+  });
+}

package/.pi/extensions/takomi-context-manager/skill-categories.d.ts

@@ -0,0 +1,11 @@
+export type SkillCategory = {
+  id: string;
+  title: string;
+  color: string;
+  description: string;
+  skills: string[];
+};
+
+export const CORE_SKILLS: string[];
+export const SKILL_CATEGORIES: SkillCategory[];
+export function getSkillCategory(skillName: string): string | undefined;

package/.pi/extensions/takomi-context-manager/skill-categories.js

@@ -0,0 +1,212 @@
+export const CORE_SKILLS = [
+  'takomi',
+  'sync-docs',
+  'code-review',
+  'security-audit',
+  'optimize-agent-context',
+  'agent-recovery',
+  'avoid-feature-creep',
+  'ai-sdk',
+  'git-commit-generation',
+];
+
+export const SKILL_CATEGORIES = [
+  {
+    id: 'core',
+    title: 'Core / Recommended',
+    color: 'cyan',
+    description: 'Essential skills for efficient Takomi usage.',
+    skills: CORE_SKILLS,
+  },
+  {
+    id: 'developer',
+    title: 'Developer / Frameworks',
+    color: 'blue',
+    description: 'Framework, repo, and developer workflow helpers.',
+    skills: [
+      'ai-sdk',
+      'nextjs-standards',
+      'context7',
+      'monorepo-management',
+      'upgrading-expo',
+      'github-ops',
+      'git-worktree',
+      'git-commit-generation',
+      'pr-comment-fix',
+      'shared-resend-portfolio',
+      'jules',
+      'gemini',
+      'anti-gravity',
+    ],
+  },
+  {
+    id: 'security',
+    title: 'Security / Review',
+    color: 'red',
+    description: 'Security, audit, and review workflows.',
+    skills: [
+      'security-audit',
+      'audit-website',
+      'code-review',
+      'jstar-reviewer',
+      'convex-security-audit',
+      'convex-security-check',
+    ],
+  },
+  {
+    id: 'convex',
+    title: 'Convex',
+    color: 'green',
+    description: 'Convex framework skills and best practices.',
+    skills: [
+      'convex',
+      'convex-agents',
+      'convex-best-practices',
+      'convex-component-authoring',
+      'convex-cron-jobs',
+      'convex-file-storage',
+      'convex-functions',
+      'convex-http-actions',
+      'convex-migrations',
+      'convex-realtime',
+      'convex-schema-validator',
+      'convex-security-audit',
+      'convex-security-check',
+    ],
+  },
+  {
+    id: 'frontend',
+    title: 'Frontend / UI',
+    color: 'magenta',
+    description: 'Frontend implementation, UI/UX, components, and testing.',
+    skills: [
+      'frontend-design',
+      'web-design-guidelines',
+      'building-native-ui',
+      'ui-ux-pro-max',
+      'component-analysis',
+      '21st-dev-components',
+      'stitch',
+      'webapp-testing',
+      'figma',
+    ],
+  },
+  {
+    id: 'docs-office',
+    title: 'Docs / Office / Extraction',
+    color: 'yellow',
+    description: 'Document formats, extraction, and README support.',
+    skills: [
+      'pdf',
+      'docx',
+      'pptx',
+      'xlsx',
+      'high-fidelity-extraction',
+      'crafting-effective-readmes',
+      'exam-creator-skill',
+    ],
+  },
+  {
+    id: 'marketing',
+    title: 'Marketing / SEO / Copy',
+    color: 'green',
+    description: 'Marketing, SEO, naming, pricing, and social strategy.',
+    skills: [
+      'copywriting',
+      'marketing-ideas',
+      'pricing-strategy',
+      'programmatic-seo',
+      'seo-ready',
+      'social-content',
+      'twitter-automation',
+      'google-trends',
+      'domain-name-brainstormer',
+      'global-brand-namer',
+      'youtube-pipeline',
+    ],
+  },
+  {
+    id: 'ai-media',
+    title: 'AI Media / Content Creation',
+    color: 'magenta',
+    description: 'Optional AI media/content skills. Not installed by default.',
+    skills: [
+      'ai-avatar-video',
+      'ai-marketing-videos',
+      'ai-podcast-creation',
+      'ai-product-photography',
+      'ai-social-media-content',
+      'ai-voice-cloning',
+      'takomi-flow',
+    ],
+  },
+  {
+    id: 'creative-video',
+    title: 'Creative / Video / Art',
+    color: 'blue',
+    description: 'Creative visuals, video, animation, and art workflows.',
+    skills: [
+      'algorithmic-art',
+      'blender-mcp-scene-director',
+      'takomi-flow',
+      'remotion',
+      'remotion-real-ui-video',
+      'youtube-pipeline',
+      'ai-avatar-video',
+      'ai-marketing-videos',
+      'photo-book-builder',
+      'hyperframes',
+      'general-video',
+      'motion-graphics',
+    ],
+  },
+  {
+    id: 'hyperframes',
+    title: 'HyperFrames',
+    color: 'magenta',
+    description: 'HTML-native video creation and animation framework.',
+    skills: [
+      'hyperframes',
+      'hyperframes-core',
+      'hyperframes-keyframes',
+      'hyperframes-animation',
+      'hyperframes-creative',
+      'hyperframes-media',
+      'hyperframes-registry',
+      'hyperframes-cli',
+      'remotion-to-hyperframes',
+      'media-use',
+      'embedded-captions',
+      'faceless-explainer',
+      'general-video',
+      'motion-graphics',
+      'music-to-video',
+      'pr-to-video',
+      'product-launch-video',
+      'slideshow',
+      'talking-head-recut',
+      'website-to-video',
+    ],
+  },
+  {
+    id: 'skill-building',
+    title: 'Skill Building / Prompting / Orchestration',
+    color: 'cyan',
+    description: 'Skill authoring, prompt engineering, and optional orchestration helpers.',
+    skills: [
+      'skill-creator',
+      'prompt-engineering',
+      'subagent-driven-development',
+      'spawn-task',
+    ],
+  },
+];
+
+/**
+ * Resolve a bundled skill to its canonical installer category. Some skills are
+ * intentionally listed in multiple browsing categories; the first catalog
+ * entry is the stable primary taxonomy used by install manifests and reports.
+ */
+export function getSkillCategory(skillName) {
+  return SKILL_CATEGORIES.find((category) => category.skills.includes(skillName))?.id;
+}

package/.pi/extensions/takomi-context-manager/skill-registry.ts

@@ -1,6 +1,7 @@
 import { readdir, readFile, stat } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { getSkillCategory } from "./skill-categories";
 import type { SkillRecord } from "./types";
 
 export function normalizeText(value: string): string {
@@ -35,7 +36,10 @@ export function collectSkillsFromOptions(options: unknown): SkillRecord[] {
     return [{
       name,
       description: getString(item, ["description", "summary"]),
-      location: getString(item, ["location", "path", "file", "skillPath"]),
+      location: getString(item, ["filePath", "location", "path", "file", "skillPath"]),
+      category: getString(item, ["category", "group", "taxonomy"]),
+      sourceCategory: getString(item, ["sourceCategory", "installerCategory"]),
+      packageName: getString(item, ["package", "packageName", "sourceSlug", "source"]),
       source: "systemPromptOptions",
     }];
   });
@@ -57,7 +61,15 @@ export function collectSkillsFromXml(systemPrompt: string): SkillRecord[] {
   for (const match of root[1].matchAll(/<skill>([\s\S]*?)<\/skill>/gi)) {
     const name = extractTag(match[1], "name");
     if (!name) continue;
-    skills.push({ name, description: extractTag(match[1], "description"), location: extractTag(match[1], "location"), source: "xml" });
+    skills.push({
+      name,
+      description: extractTag(match[1], "description"),
+      location: extractTag(match[1], "location"),
+      category: extractTag(match[1], "category") ?? extractTag(match[1], "group"),
+      sourceCategory: extractTag(match[1], "source_category") ?? extractTag(match[1], "installer_category"),
+      packageName: extractTag(match[1], "package") ?? extractTag(match[1], "source"),
+      source: "xml",
+    });
   }
   return skills;
 }
@@ -71,14 +83,95 @@ export function mergeSkills(records: SkillRecord[]): Map<string, SkillRecord> {
       name: existing.name,
       description: existing.description ?? skill.description,
       location: existing.location ?? skill.location,
+      category: existing.category ?? skill.category,
+      sourceCategory: existing.sourceCategory ?? skill.sourceCategory,
+      packageName: existing.packageName ?? skill.packageName,
       source: existing.source === "systemPromptOptions" ? existing.source : skill.source,
     } : skill);
   }
   return merged;
 }
 
+export function compareSkillText(a: string, b: string): number {
+  return normalizeName(a).localeCompare(normalizeName(b), "en") || a.localeCompare(b, "en");
+}
+
 export function sortedSkills(skills: Map<string, SkillRecord>): SkillRecord[] {
-  return [...skills.values()].sort((a, b) => a.name.localeCompare(b.name));
+  return [...skills.values()].sort((a, b) => compareSkillText(a.name, b.name));
+}
+
+export type SkillCategoryGroup = { category: string; skills: SkillRecord[] };
+
+/** Safe, renderer-only skill fields. Keep discovery/source details out of tool results. */
+export type SkillRenderProjection = Pick<SkillRecord, "name" | "description">;
+export type SkillIndexRenderGroup = { category: string; skills: SkillRenderProjection[] };
+
+function categorySlug(value: string | undefined): string | undefined {
+  const normalized = value?.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+  return normalized || undefined;
+}
+
+function pathTaxonomyCategory(location: string | undefined): string | undefined {
+  if (!location) return undefined;
+  const segments = location.replace(/\\/g, "/").split("/").filter(Boolean);
+  const skillsIndex = segments.map((segment) => segment.toLowerCase()).lastIndexOf("skills");
+  if (skillsIndex < 0) return undefined;
+  // A categorized filesystem layout is .../skills/<category>/<skill>/SKILL.md.
+  // A normal flat skill root (.../skills/<skill>/SKILL.md) intentionally falls through.
+  const afterSkills = segments.slice(skillsIndex + 1);
+  return afterSkills.length >= 3 ? categorySlug(afterSkills[0]) : undefined;
+}
+
+function packageSlug(location: string | undefined): string | undefined {
+  if (!location) return undefined;
+  const segments = location.replace(/\\/g, "/").split("/").filter(Boolean);
+  const nodeModulesIndex = segments.map((segment) => segment.toLowerCase()).lastIndexOf("node_modules");
+  if (nodeModulesIndex < 0) return undefined;
+  const first = segments[nodeModulesIndex + 1];
+  if (!first) return undefined;
+  if (first.startsWith("@")) {
+    const second = segments[nodeModulesIndex + 2];
+    return second ? categorySlug(`${first.slice(1)}-${second}`) : categorySlug(first.slice(1));
+  }
+  return categorySlug(first);
+}
+
+/**
+ * Category precedence is deterministic and does not infer from a skill name:
+ * explicit skill metadata → installer/source taxonomy → path/package metadata
+ * → uncategorized.
+ */
+export function skillCategory(skill: SkillRecord): string {
+  return categorySlug(skill.category)
+    ?? categorySlug(skill.sourceCategory)
+    ?? pathTaxonomyCategory(skill.location)
+    ?? categorySlug(skill.packageName)
+    ?? packageSlug(skill.location)
+    ?? "uncategorized";
+}
+
+export function groupedSkills(skills: Iterable<SkillRecord>): SkillCategoryGroup[] {
+  const grouped = new Map<string, SkillRecord[]>();
+  for (const skill of skills) {
+    const category = skillCategory(skill);
+    const entries = grouped.get(category) ?? [];
+    entries.push(skill);
+    grouped.set(category, entries);
+  }
+  return [...grouped.entries()]
+    .sort(([a], [b]) => compareSkillText(a, b))
+    .map(([category, entries]) => ({ category, skills: entries.sort((a, b) => compareSkillText(a.name, b.name)) }));
+}
+
+/**
+ * Project the registry into the only fields the skill-index renderer needs.
+ * Locations and discovery metadata must remain internal to the registry.
+ */
+export function skillIndexRenderGroups(skills: Iterable<SkillRecord>): SkillIndexRenderGroup[] {
+  return groupedSkills(skills).map(({ category, skills: entries }) => ({
+    category,
+    skills: entries.map(({ name, description }) => ({ name, description })),
+  }));
 }
 
 export function findSkill(skills: Map<string, SkillRecord>, name: string): SkillRecord | undefined {
@@ -117,7 +210,14 @@ async function readSkillFile(filePath: string): Promise<SkillRecord | undefined>
     const name = frontmatter.name?.trim() || path.basename(path.dirname(filePath));
     const description = frontmatter.description?.trim();
     if (!name || !description) return undefined;
-    return { name, description, location: filePath, source: "filesystem" };
+    return {
+      name,
+      description,
+      location: filePath,
+      category: frontmatter.category?.trim() || frontmatter.group?.trim(),
+      packageName: frontmatter.package?.trim() || frontmatter.source?.trim(),
+      source: "filesystem",
+    };
   } catch {
     return undefined;
   }
@@ -175,6 +275,77 @@ async function collectPackageSkillRoots(nodeModulesRoot: string): Promise<string
   return roots;
 }
 
+export type InstallerTaxonomyEntry = { category: string; skillFilePath: string };
+
+export type InstallerTaxonomyOptions = {
+  home?: string;
+  takomiHome?: string;
+};
+
+function canonicalPath(filePath: string): string {
+  const resolved = path.normalize(path.resolve(filePath));
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+
+/**
+ * Read Takomi's installer ownership registry without mutating or reconciling it.
+ * Legacy owned entries without category metadata use the tracked catalog's
+ * stable primary category, so upgrades do not require another installer run.
+ */
+export async function readInstallerTaxonomy(options: InstallerTaxonomyOptions = {}): Promise<Map<string, InstallerTaxonomyEntry>> {
+  const home = options.home ?? os.homedir();
+  const manifestPath = path.join(options.takomiHome ?? process.env.TAKOMI_HOME_DIR ?? path.join(home, ".takomi"), "skills-manifest.json");
+  try {
+    const manifest = JSON.parse(await readFile(manifestPath, "utf8")) as {
+      targetRoot?: unknown;
+      owned?: Record<string, unknown>;
+    };
+    const targetRoot = typeof manifest.targetRoot === "string" && manifest.targetRoot.trim()
+      ? manifest.targetRoot
+      : path.join(home, ".agents", "skills");
+    const taxonomy = new Map<string, InstallerTaxonomyEntry>();
+    for (const [name, rawEntry] of Object.entries(manifest.owned ?? {})) {
+      if (!rawEntry || (typeof rawEntry !== "object" && typeof rawEntry !== "string")) continue;
+      const entry = typeof rawEntry === "object" ? rawEntry as Record<string, unknown> : {};
+      const manifestCategory = typeof entry.category === "string" && entry.category.trim()
+        ? entry.category.trim()
+        : undefined;
+      const category = manifestCategory ?? getSkillCategory(name);
+      if (!category) continue;
+      const targetPath = typeof entry.targetPath === "string" && entry.targetPath.trim()
+        ? entry.targetPath
+        : path.join(targetRoot, name);
+      taxonomy.set(normalizeName(name), {
+        category,
+        skillFilePath: canonicalPath(path.join(targetPath, "SKILL.md")),
+      });
+    }
+    return taxonomy;
+  } catch {
+    return new Map();
+  }
+}
+
+/**
+ * Enrich records already supplied by Pi using exact name + canonical SKILL.md
+ * ownership. This remains independent from filesystem discovery and read-only.
+ */
+export function applyInstallerTaxonomy(skills: SkillRecord[], taxonomy: Map<string, InstallerTaxonomyEntry>): SkillRecord[] {
+  return skills.map((skill) => {
+    const entry = taxonomy.get(normalizeName(skill.name));
+    if (!entry || !skill.location || canonicalPath(skill.location) !== entry.skillFilePath) return skill;
+    return { ...skill, sourceCategory: skill.sourceCategory ?? entry.category };
+  });
+}
+
+export async function enrichSkillsWithInstallerTaxonomy(
+  skills: SkillRecord[],
+  options: InstallerTaxonomyOptions = {},
+): Promise<SkillRecord[]> {
+  if (skills.length === 0) return skills;
+  return applyInstallerTaxonomy(skills, await readInstallerTaxonomy(options));
+}
+
 function ancestorSkillRoots(cwd: string): string[] {
   const roots: string[] = [];
   let current = path.resolve(cwd || process.cwd());
@@ -190,8 +361,8 @@ function ancestorSkillRoots(cwd: string): string[] {
   return roots;
 }
 
-export async function discoverSkillsFromFilesystem(cwd = process.cwd()): Promise<SkillRecord[]> {
-  const home = os.homedir();
+export async function discoverSkillsFromFilesystem(cwd = process.cwd(), options: InstallerTaxonomyOptions = {}): Promise<SkillRecord[]> {
+  const home = options.home ?? os.homedir();
   const roots = [
     { root: path.join(home, ".pi", "agent", "skills"), directMarkdownFiles: true },
     { root: path.join(home, ".agents", "skills"), directMarkdownFiles: false },
@@ -202,6 +373,6 @@ export async function discoverSkillsFromFilesystem(cwd = process.cwd()): Promise
   for (const { root, directMarkdownFiles } of roots) {
     for (const file of await collectSkillFiles(root, directMarkdownFiles)) skillFiles.add(file);
   }
-  const skills = await Promise.all([...skillFiles].map(readSkillFile));
-  return skills.filter((skill): skill is SkillRecord => Boolean(skill));
+  const skills = (await Promise.all([...skillFiles].map(readSkillFile))).filter((skill): skill is SkillRecord => Boolean(skill));
+  return enrichSkillsWithInstallerTaxonomy(skills, options);
 }