@prometheus-ai/agent 0.5.4 → 0.5.8

package/src/discovery/at-imports.ts

@@ -0,0 +1,273 @@
+/**
+ * @-import expansion for context files (AGENTS.md / CLAUDE.md / GEMINI.md / …).
+ *
+ * Other coding agents (Claude Code, Goose, Cline, …) treat `@path/to/file`
+ * references inside their markdown memory files as inline includes. prometheus
+ * loads the same files in their native shape, so this module performs the
+ * same expansion before content lands in the system prompt.
+ *
+ * Semantics mirror Claude Code's documented behavior:
+ * - `@` must sit at start of line or after whitespace (so `git@github.com`
+ *   and `user@example.com` are not treated as imports).
+ * - Relative paths resolve against the importing file's directory, not the
+ *   working directory.
+ * - `~/...` resolves to the user's home directory.
+ * - Imports inside fenced code blocks (` ``` ` / `~~~`) and inline code
+ *   spans (`` `…` ``) are preserved verbatim so technical examples like
+ *   `npm install @types/node` survive intact.
+ * - Recursive imports are followed up to {@link MAX_AT_IMPORT_DEPTH} hops;
+ *   cycles are broken silently.
+ * - When the referenced file cannot be read, the original `@token` is
+ *   left untouched and a debug log is emitted.
+ *
+ * @see https://docs.claude.com/en/docs/claude-code/memory#import-additional-files
+ */
+import * as os from "node:os";
+import * as path from "node:path";
+import { logger } from "@prometheus-ai/utils";
+import { readFile } from "../capability/fs";
+
+/** Maximum number of recursive `@`-import hops. Matches Claude Code's documented cap. */
+export const MAX_AT_IMPORT_DEPTH = 5;
+
+/**
+ * Matches a candidate `@import` token: a leading boundary (start-of-string
+ * or single whitespace char) and a token whose first character is path-like.
+ *
+ * The boundary character is captured separately so the slice arithmetic in
+ * {@link expandLine} aligns with the `@` position, not the whitespace.
+ */
+const AT_IMPORT_REGEX = /(^|[ \t])@([./~A-Za-z0-9_-][^\s]*)/g;
+
+/**
+ * Trailing characters stripped from a captured path token: sentence-ending
+ * punctuation, closing brackets, quotes. A lone trailing period is treated
+ * as sentence grammar (e.g. `See @AGENTS.md.`) — legitimate file extensions
+ * still match because the stripped set is anchored at the very end of the
+ * token, so `@AGENTS.md` keeps the `.md` (the `d` is not in the set).
+ */
+const TRAILING_PUNCT = /[.,;:!?)\]}"']+$/;
+
+export interface ExpandAtImportsOptions {
+	/** Maximum hop depth (default: {@link MAX_AT_IMPORT_DEPTH}). */
+	maxDepth?: number;
+	/** Override the home directory used to resolve `~/...` (default: `os.homedir()`). */
+	home?: string;
+}
+
+/**
+ * Expand `@path/to/file` references in `content` against `filePath`'s directory.
+ *
+ * Returns the expanded text. When no imports match, the original string is
+ * returned unchanged.
+ */
+export async function expandAtImports(
+	content: string,
+	filePath: string,
+	options: ExpandAtImportsOptions = {},
+): Promise<string> {
+	const maxDepth = options.maxDepth ?? MAX_AT_IMPORT_DEPTH;
+	const home = options.home ?? os.homedir();
+	const absoluteSource = path.resolve(filePath);
+	const visited = new Set<string>([absoluteSource]);
+	return await expand(content, path.dirname(absoluteSource), 0, maxDepth, home, visited);
+}
+
+async function expand(
+	content: string,
+	baseDir: string,
+	depth: number,
+	maxDepth: number,
+	home: string,
+	visited: Set<string>,
+): Promise<string> {
+	if (depth >= maxDepth) return content;
+
+	const segments = splitMarkdownSegments(content);
+	const out: string[] = [];
+	for (const segment of segments) {
+		if (segment.kind === "code") {
+			out.push(segment.text);
+			continue;
+		}
+		out.push(await expandTextSegment(segment.text, baseDir, depth, maxDepth, home, visited));
+	}
+	return out.join("");
+}
+
+async function expandTextSegment(
+	text: string,
+	baseDir: string,
+	depth: number,
+	maxDepth: number,
+	home: string,
+	visited: Set<string>,
+): Promise<string> {
+	const lines = text.split("\n");
+	for (let i = 0; i < lines.length; i++) {
+		lines[i] = await expandLine(lines[i], baseDir, depth, maxDepth, home, visited);
+	}
+	return lines.join("\n");
+}
+
+async function expandLine(
+	line: string,
+	baseDir: string,
+	depth: number,
+	maxDepth: number,
+	home: string,
+	visited: Set<string>,
+): Promise<string> {
+	if (!line.includes("@")) return line;
+
+	const matches: Array<{ start: number; end: number; importPath: string }> = [];
+	for (const m of line.matchAll(AT_IMPORT_REGEX)) {
+		const matchIndex = m.index ?? 0;
+		const leading = m[1];
+		const rawToken = m[2];
+		const atPos = matchIndex + leading.length;
+		if (isInsideInlineCode(line, atPos)) continue;
+
+		const trimmedToken = rawToken.replace(TRAILING_PUNCT, "");
+		if (trimmedToken.length === 0) continue;
+
+		matches.push({
+			start: atPos,
+			end: atPos + 1 + trimmedToken.length,
+			importPath: trimmedToken,
+		});
+	}
+
+	if (matches.length === 0) return line;
+
+	const parts: string[] = [];
+	let cursor = 0;
+	for (const m of matches) {
+		parts.push(line.slice(cursor, m.start));
+		const expanded = await resolveAndExpand(m.importPath, baseDir, depth, maxDepth, home, visited);
+		parts.push(expanded ?? line.slice(m.start, m.end));
+		cursor = m.end;
+	}
+	parts.push(line.slice(cursor));
+	return parts.join("");
+}
+
+async function resolveAndExpand(
+	importPath: string,
+	baseDir: string,
+	depth: number,
+	maxDepth: number,
+	home: string,
+	visited: Set<string>,
+): Promise<string | null> {
+	const resolved = resolveImportPath(importPath, baseDir, home);
+	if (visited.has(resolved)) {
+		logger.debug("@-import: skipping cyclic include", { path: resolved });
+		return null;
+	}
+
+	const content = await readFile(resolved);
+	if (content === null) {
+		logger.debug("@-import: file not found", { path: resolved });
+		return null;
+	}
+
+	// Visited is shared across the whole expansion tree to break cycles,
+	// even cycles that span multiple importing files.
+	visited.add(resolved);
+	return await expand(content, path.dirname(resolved), depth + 1, maxDepth, home, visited);
+}
+
+function resolveImportPath(importPath: string, baseDir: string, home: string): string {
+	if (importPath === "~") return path.resolve(home);
+	if (importPath.startsWith("~/")) return path.resolve(home, importPath.slice(2));
+	if (path.isAbsolute(importPath)) return path.resolve(importPath);
+	return path.resolve(baseDir, importPath);
+}
+
+interface MarkdownSegment {
+	kind: "text" | "code";
+	text: string;
+}
+
+/**
+ * Split markdown into alternating text/code segments by tracking fenced
+ * code blocks. Inline code spans are handled per-line by {@link isInsideInlineCode}.
+ *
+ * A fence is recognized as a line whose first non-whitespace run is three or
+ * more backticks (or tildes). The closing fence must use the same character
+ * with at least as many marks as the opener.
+ */
+function splitMarkdownSegments(content: string): MarkdownSegment[] {
+	const segments: MarkdownSegment[] = [];
+	const lines = content.split("\n");
+	let buffer: string[] = [];
+	let bufferKind: MarkdownSegment["kind"] = "text";
+	let fenceChar = "";
+	let fenceLen = 0;
+
+	const flush = (): void => {
+		if (buffer.length === 0) return;
+		segments.push({ kind: bufferKind, text: buffer.join("") });
+		buffer = [];
+	};
+
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		const isLast = i === lines.length - 1;
+		// Re-attach each line's trailing newline so adjacent segments
+		// concatenate without losing the boundary `\n`.
+		const lineText = isLast ? line : `${line}\n`;
+		const fence = matchFence(line);
+
+		if (fence && bufferKind === "text") {
+			flush();
+			bufferKind = "code";
+			buffer.push(lineText);
+			fenceChar = fence.char;
+			fenceLen = fence.len;
+		} else if (fence && bufferKind === "code" && fence.char === fenceChar && fence.len >= fenceLen) {
+			buffer.push(lineText);
+			flush();
+			bufferKind = "text";
+			fenceChar = "";
+			fenceLen = 0;
+		} else {
+			buffer.push(lineText);
+		}
+
+		if (isLast) flush();
+	}
+	return segments;
+}
+
+function matchFence(line: string): { char: string; len: number } | null {
+	let i = 0;
+	while (i < line.length && (line[i] === " " || line[i] === "\t")) i++;
+	const char = line[i];
+	if (char !== "`" && char !== "~") return null;
+	let len = 0;
+	while (i + len < line.length && line[i + len] === char) len++;
+	if (len < 3) return null;
+	return { char, len };
+}
+
+/**
+ * Returns `true` when `position` falls inside an unclosed inline-code span on
+ * this line. Implemented as a backtick-parity scan so it handles repeated
+ * delimiters like `` `` literal ` backtick `` `` correctly enough for the
+ * "@-imports inside `code` should not expand" case.
+ */
+function isInsideInlineCode(line: string, position: number): boolean {
+	let inSpan = false;
+	let i = 0;
+	while (i < position && i < line.length) {
+		if (line[i] === "`") {
+			while (i < line.length && line[i] === "`") i++;
+			inSpan = !inSpan;
+		} else {
+			i++;
+		}
+	}
+	return inSpan;
+}

package/src/discovery/builtin-rules/index.ts

@@ -20,8 +20,10 @@ import tsNoAny from "./ts-no-any.md" with { type: "text" };
 import tsNoDeprecatedLeftovers from "./ts-no-deprecated-leftovers.md" with { type: "text" };
 import tsNoDynamicImport from "./ts-no-dynamic-import.md" with { type: "text" };
 import tsNoReturnType from "./ts-no-return-type.md" with { type: "text" };
+import tsNoTestTimers from "./ts-no-test-timers.md" with { type: "text" };
 import tsNoTinyFunctions from "./ts-no-tiny-functions.md" with { type: "text" };
 import tsPromiseWithResolvers from "./ts-promise-with-resolvers.md" with { type: "text" };
+import tsRedundantClearGuard from "./ts-redundant-clear-guard.md" with { type: "text" };
 import tsSetMap from "./ts-set-map.md" with { type: "text" };
 
 /** A bundled rule's stable name and raw markdown (frontmatter + body). */
@@ -44,7 +46,9 @@ export const BUILTIN_RULE_SOURCES: readonly BuiltinRuleSource[] = [
 	{ name: "ts-no-deprecated-leftovers", content: tsNoDeprecatedLeftovers },
 	{ name: "ts-no-dynamic-import", content: tsNoDynamicImport },
 	{ name: "ts-no-return-type", content: tsNoReturnType },
+	{ name: "ts-no-test-timers", content: tsNoTestTimers },
 	{ name: "ts-no-tiny-functions", content: tsNoTinyFunctions },
 	{ name: "ts-promise-with-resolvers", content: tsPromiseWithResolvers },
+	{ name: "ts-redundant-clear-guard", content: tsRedundantClearGuard },
 	{ name: "ts-set-map", content: tsSetMap },
 ];

package/src/discovery/builtin-rules/ts-no-test-timers.md

@@ -0,0 +1,55 @@
+---
+description: Do not use real timers (Bun.sleep, setTimeout, setInterval) in tests — drive time with fake timers instead
+condition:
+  - "Bun\\.sleep\\("
+  - "\\bsetInterval\\("
+  - "\\bsetTimeout\\("
+scope: "tool:edit(*.test.ts), tool:write(*.test.ts)"
+interruptMode: never
+---
+
+**Do not reach for real wall-clock timers in test files.** `Bun.sleep(...)`, `setTimeout(...)`, and `setInterval(...)` tie a test's duration to real time: they slow the suite on every run, and any delay tuned to "long enough" eventually races on a loaded machine and flakes.
+
+## Why it's wrong
+
+- Real delays add fixed latency to every invocation; CI pays it on every run.
+- A sleep sized to mask a race is a guess — the race resurfaces under load.
+- A fixed wait hides *what* you are waiting for, so a failure points at a timeout instead of the real cause.
+
+## Avoid
+
+```typescript
+test("debounce fires once", async () => {
+	const fn = debounce(handler, 100);
+	fn();
+	await Bun.sleep(150); // real delay — slow and timing-dependent
+	expect(handler).toHaveBeenCalledTimes(1);
+});
+```
+
+## Use
+
+Drive time deterministically with fake timers:
+
+```typescript
+import { expect, test, vi } from "bun:test";
+
+test("debounce fires once", () => {
+	vi.useFakeTimers();
+	const fn = debounce(handler, 100);
+	fn();
+	vi.advanceTimersByTime(150); // advance the clock, no real wait
+	expect(handler).toHaveBeenCalledTimes(1);
+});
+```
+
+When the code under test resolves a promise or emits an event, await that signal directly instead of guessing a duration:
+
+```typescript
+await once(emitter, "done"); // await the real event
+const value = await pending; // await the promise the code already exposes
+```
+
+## Exceptions
+
+An integration test that deliberately exercises real timer behavior against the platform clock may need a genuine delay. Keep it rare, and add a short comment naming why deterministic time control will not work.

package/src/discovery/builtin-rules/ts-redundant-clear-guard.md

@@ -0,0 +1,75 @@
+---
+description: Do not guard clearTimeout/clearInterval/clearImmediate with a truthiness or null/undefined check — they accept null and undefined
+scope: "tool:edit(*.{ts,tsx,js,jsx,mts,cts,mjs,cjs}), tool:write(*.{ts,tsx,js,jsx,mts,cts,mjs,cjs})"
+interruptMode: never
+astCondition:
+  - "if ($X) clearTimeout($X)"
+  - "if ($X) { clearTimeout($X) }"
+  - "if ($X) clearInterval($X)"
+  - "if ($X) { clearInterval($X) }"
+  - "if ($X) clearImmediate($X)"
+  - "if ($X) { clearImmediate($X) }"
+  - "if ($X !== null) clearTimeout($X)"
+  - "if ($X !== null) { clearTimeout($X) }"
+  - "if ($X !== null) clearInterval($X)"
+  - "if ($X !== null) { clearInterval($X) }"
+  - "if ($X !== null) clearImmediate($X)"
+  - "if ($X !== null) { clearImmediate($X) }"
+  - "if ($X != null) clearTimeout($X)"
+  - "if ($X != null) { clearTimeout($X) }"
+  - "if ($X != null) clearInterval($X)"
+  - "if ($X != null) { clearInterval($X) }"
+  - "if ($X != null) clearImmediate($X)"
+  - "if ($X != null) { clearImmediate($X) }"
+  - "if ($X !== undefined) clearTimeout($X)"
+  - "if ($X !== undefined) { clearTimeout($X) }"
+  - "if ($X !== undefined) clearInterval($X)"
+  - "if ($X !== undefined) { clearInterval($X) }"
+  - "if ($X !== undefined) clearImmediate($X)"
+  - "if ($X !== undefined) { clearImmediate($X) }"
+  - "if ($X != undefined) clearTimeout($X)"
+  - "if ($X != undefined) { clearTimeout($X) }"
+  - "if ($X != undefined) clearInterval($X)"
+  - "if ($X != undefined) { clearInterval($X) }"
+  - "if ($X != undefined) clearImmediate($X)"
+  - "if ($X != undefined) { clearImmediate($X) }"
+---
+
+**Do not guard `clearTimeout` / `clearInterval` / `clearImmediate` with a truthiness or `null`/`undefined` check.** Per the WHATWG/Node timers spec these functions are no-ops when handed `null`, `undefined`, or any value that doesn't correspond to a live timer. The guard adds a redundant branch that the reader must still reason about.
+
+## Why it's wrong
+
+- The branch can never change behavior — clearing a missing/`null`/`undefined` handle does nothing.
+- Extra branches inflate the code and hide the one line that matters.
+- It signals a misunderstanding of the timer API to future readers.
+
+## Avoid
+
+```ts
+if (this.timer) clearTimeout(this.timer);
+if (handle !== null) clearInterval(handle);
+if (id != undefined) {
+	clearImmediate(id);
+}
+```
+
+## Use
+
+```ts
+clearTimeout(this.timer);
+clearInterval(handle);
+clearImmediate(id);
+```
+
+## When a guard *is* warranted
+
+Keep the check only when the body does more than clear — e.g. it also reassigns the handle or runs other cleanup:
+
+```ts
+if (this.timer) {
+	clearTimeout(this.timer);
+	this.timer = undefined; // extra work → guard is not purely redundant
+}
+```
+
+This rule only fires when the clear call is the sole statement in the guarded branch, so those legitimate cases are left alone.

package/src/discovery/builtin.ts

@@ -6,6 +6,7 @@
 import * as path from "node:path";
 import { logger, parseFrontmatter, tryParseJson } from "@prometheus-ai/utils";
 import { YAML } from "bun";
+import { getManagedSkillsDir, MANAGED_SKILLS_PROVIDER_ID } from "../autolearn/managed-skills";
 import { registerProvider } from "../capability";
 import { type ContextFile, contextFileCapability } from "../capability/context-file";
 import { type Extension, type ExtensionManifest, extensionCapability } from "../capability/extension";
@@ -23,7 +24,6 @@ import { type SystemPrompt, systemPromptCapability } from "../capability/system-
 import { type CustomTool, toolCapability } from "../capability/tool";
 import type { LoadContext, LoadResult } from "../capability/types";
 import { expandTilde } from "../tools/path-utils";
-import { loadMergedContextFileGroup, PROMETHEUS_GENERAL_CONTEXT_FILES } from "./context-files";
 import {
 	buildRuleFromMarkdown,
 	createSourceMeta,
@@ -284,13 +284,26 @@ async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
 	});
 
 	const results = await Promise.all([...projectScans, userScan]);
-
 	return {
 		items: results.flatMap(r => r.items),
 		warnings: results.flatMap(r => r.warnings ?? []),
 	};
 }
 
+// Managed skills (auto-learn) are a SEPARATE provider at the lowest skill
+// priority, so an authored skill of the same name from ANY other provider wins
+// the capability-level priority dedup. Discovery is unconditional (an empty
+// managed dir is a no-op); only writing/nudging is gated by `autolearn.enabled`.
+const MANAGED_SKILLS_PRIORITY = 5;
+async function loadManagedSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
+	return scanSkillsFromDir(ctx, {
+		dir: getManagedSkillsDir(ctx.home),
+		providerId: MANAGED_SKILLS_PROVIDER_ID,
+		level: "user",
+		requireDescription: true,
+	});
+}
+
 registerProvider<Skill>(skillCapability.id, {
 	id: PROVIDER_ID,
 	displayName: DISPLAY_NAME,
@@ -299,6 +312,14 @@ registerProvider<Skill>(skillCapability.id, {
 	load: loadSkills,
 });
 
+registerProvider<Skill>(skillCapability.id, {
+	id: MANAGED_SKILLS_PROVIDER_ID,
+	displayName: "Managed Skills (auto-learn)",
+	description: "Auto-generated managed skills from ~/.prometheus/agent/managed-skills",
+	priority: MANAGED_SKILLS_PRIORITY,
+	load: loadManagedSkills,
+});
+
 // Slash Commands
 async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashCommand>> {
 	const items: SlashCommand[] = [];
@@ -348,7 +369,7 @@ async function loadRules(ctx: LoadContext): Promise<LoadResult<Rule>> {
 	}
 
 	// Top-level RULES.md is a sticky always-apply rule. Documented in
-	// https://prometheus.trivlab.com/docs/context-files as the file that gets "re-injected near
+	// https://prometheus.sh/docs/context-files as the file that gets "re-injected near
 	// the current turn so they keep hold across long conversations".
 	// User scope:    ~/.prometheus/agent/RULES.md
 	// Project scope: nearest .prometheus/RULES.md walking up from cwd to repoRoot
@@ -864,33 +885,34 @@ registerProvider<Settings>(settingsCapability.id, {
 	load: loadSettings,
 });
 
-// Context Files (AGENTS.md, USER.md, SOUL.md)
+// Context Files (AGENTS.md)
 async function loadContextFiles(ctx: LoadContext): Promise<LoadResult<ContextFile>> {
 	const items: ContextFile[] = [];
 	const warnings: string[] = [];
 
-	const userDir = path.join(ctx.home, PATHS.userAgent);
-	const userContext = await loadMergedContextFileGroup({
-		ctx,
-		dir: userDir,
-		level: "user",
-		providerId: PROVIDER_ID,
-	});
-	if (userContext) {
-		items.push(userContext);
+	const userPath = path.join(ctx.home, PATHS.userAgent, "AGENTS.md");
+	const userContent = await readFile(userPath);
+	if (userContent) {
+		items.push({
+			path: userPath,
+			content: userContent,
+			level: "user",
+			_source: createSourceMeta(PROVIDER_ID, userPath, "user"),
+		});
 	}
 
 	const nearestProjectConfigDir = await findNearestProjectConfigDir(ctx.cwd, ctx.repoRoot);
 	if (nearestProjectConfigDir) {
-		const projectContext = await loadMergedContextFileGroup({
-			ctx,
-			dir: nearestProjectConfigDir.dir,
-			level: "project",
-			providerId: PROVIDER_ID,
-			depth: nearestProjectConfigDir.depth,
-		});
-		if (projectContext) {
-			items.push(projectContext);
+		const projectPath = path.join(nearestProjectConfigDir.dir, "AGENTS.md");
+		const projectContent = await readFile(projectPath);
+		if (projectContent) {
+			items.push({
+				path: projectPath,
+				content: projectContent,
+				level: "project",
+				depth: nearestProjectConfigDir.depth,
+				_source: createSourceMeta(PROVIDER_ID, projectPath, "project"),
+			});
 			return { items, warnings };
 		}
 	}
@@ -900,7 +922,7 @@ async function loadContextFiles(ctx: LoadContext): Promise<LoadResult<ContextFil
 registerProvider<ContextFile>(contextFileCapability.id, {
 	id: PROVIDER_ID,
 	displayName: DISPLAY_NAME,
-	description: `Load ${PROMETHEUS_GENERAL_CONTEXT_FILES.join(", ")} from .prometheus/ directories`,
+	description: "Load AGENTS.md from .prometheus/ directories",
 	priority: PRIORITY,
 	load: loadContextFiles,
 });

package/src/discovery/claude-plugins.ts

@@ -124,6 +124,43 @@ async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
 	}
 	return { items, warnings };
 }
+async function loadSkillSlashCommands(ctx: LoadContext, root: ClaudePluginRoot): Promise<LoadResult<SlashCommand>> {
+	const { dir: skillsDir, warning } = await resolvePluginDir(root, ["skills"], "skills");
+	const warnings: string[] = warning ? [warning] : [];
+	const skillsResult = await scanSkillsFromDir(ctx, {
+		dir: skillsDir,
+		providerId: PROVIDER_ID,
+		level: root.scope,
+	});
+	warnings.push(...(skillsResult.warnings ?? []));
+
+	const commands = await Promise.all(
+		skillsResult.items.map(async skill => {
+			const content = await readFile(skill.path);
+			if (content === null) {
+				warnings.push(`Failed to read skill slash command: ${skill.path}`);
+				return null;
+			}
+			// Slash command name MUST come from the skill directory basename, not
+			// frontmatter `name`: `expandSlashCommand` splits the command at the first
+			// whitespace, so a display name like "Understand Anything" would never match
+			// `/understand`. The documented layout is `skills/<name>/SKILL.md` → `/<name>`.
+			const command: SlashCommand = {
+				name: path.basename(path.dirname(skill.path)),
+				path: skill.path,
+				content,
+				level: skill.level,
+				_source: skill._source,
+			};
+			return command;
+		}),
+	);
+
+	return {
+		items: commands.filter((command): command is SlashCommand => command !== null),
+		warnings,
+	};
+}
 
 // =============================================================================
 // Slash Commands
@@ -139,7 +176,7 @@ async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashComm
 	const results = await Promise.all(
 		roots.map(async root => {
 			const { dir: commandsDir, warning } = await resolvePluginDir(root, ["commands", "slash-commands"], "commands");
-			const result = await loadFilesFromDir<SlashCommand>(ctx, commandsDir, PROVIDER_ID, root.scope, {
+			const commandResult = await loadFilesFromDir<SlashCommand>(ctx, commandsDir, PROVIDER_ID, root.scope, {
 				extensions: ["md"],
 				transform: (name, content, filePath, source) => {
 					const cmdName = name.replace(/\.md$/, "");
@@ -152,14 +189,16 @@ async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashComm
 					};
 				},
 			});
-			return { result, warning };
+			const skillCommandResult = await loadSkillSlashCommands(ctx, root);
+			return { commandResult, skillCommandResult, warning };
 		}),
 	);
 
-	for (const { result, warning } of results) {
+	for (const { commandResult, skillCommandResult, warning } of results) {
 		if (warning) warnings.push(warning);
-		items.push(...result.items);
-		if (result.warnings) warnings.push(...result.warnings);
+		items.push(...commandResult.items, ...skillCommandResult.items);
+		if (commandResult.warnings) warnings.push(...commandResult.warnings);
+		if (skillCommandResult.warnings) warnings.push(...skillCommandResult.warnings);
 	}
 
 	return { items, warnings };