@bastani/atomic 0.9.13 → 0.9.14-alpha.2

package/dist/builtin/subagents/src/agents/agent-loaders.ts

@@ -1,17 +1,17 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { normalizeMaxSubagentDepth } from "../shared/types.ts";
-import { splitToolList } from "./agent-overrides.ts";
-import { shouldPreserveAgentExtraField } from "./agent-serializer.ts";
+import { normalizeMaxSubagentDepth } from "../shared/types.js";
+import { splitToolList } from "./agent-overrides.js";
+import { shouldPreserveAgentExtraField } from "./agent-serializer.js";
 import {
 	type AgentConfig,
 	type AgentSource,
 	defaultInheritProjectContext,
 	defaultInheritSkills,
 	defaultSystemPromptMode,
-} from "./agent-types.ts";
-import { parseFrontmatter } from "./frontmatter.ts";
-import { buildRuntimeName, parsePackageName } from "./identity.ts";
+} from "./agent-types.js";
+import { type FrontmatterValue, parseFrontmatter } from "./frontmatter.js";
+import { buildRuntimeName, parsePackageName } from "./identity.js";
 
 function listFilesRecursive(dir: string, predicate: (fileName: string) => boolean): string[] {
 	const files: string[] = [];
@@ -45,8 +45,74 @@ function parseCommaSeparatedList(value: string | undefined): string[] | undefine
 	return parsed && parsed.length > 0 ? parsed : undefined;
 }
 
-export function loadAgentsFromDir(dir: string, source: AgentSource): AgentConfig[] {
+/**
+ * Narrow a frontmatter value to its scalar spelling. A YAML sequence where a
+ * scalar belongs (`model: [anthropic, x]`) reads as undefined rather than a
+ * stringified list, matching upstream's `typeof` narrowing.
+ */
+function frontmatterString(value: FrontmatterValue | undefined): string | undefined {
+	return typeof value === "string" ? value : undefined;
+}
+
+/**
+ * Narrow a frontmatter value to a boolean. The real YAML parser yields true
+ * booleans for the unquoted spellings `serializeAgent` itself writes
+ * (`interactive: true`); quoted or hand-written `"true"`/`"false"` strings
+ * from the legacy line-reader era stay accepted.
+ */
+function frontmatterBoolean(value: FrontmatterValue | undefined): boolean | undefined {
+	if (typeof value === "boolean") return value;
+	if (value === "true") return true;
+	if (value === "false") return false;
+	return undefined;
+}
+
+/**
+ * Normalize a frontmatter `tools` value to a list of tool names.
+ *
+ * Both spellings are valid YAML and both are in use (upstream pi #7598):
+ *
+ *     tools: read, bash        # string, comma-separated
+ *     tools: [read, bash]      # flow sequence
+ *     tools:                   # block sequence
+ *       - read
+ *       - bash
+ *
+ * so accept either. Anything else yields no tools rather than throwing: this
+ * runs inside agent discovery, where a single bad file must not take down
+ * every other agent in the same directory.
+ */
+function parseToolList(value: FrontmatterValue | undefined): string[] | undefined {
+	const raw = Array.isArray(value) ? value : typeof value === "string" ? value.split(",") : [];
+	const tools = raw
+		.filter((tool): tool is string => typeof tool === "string")
+		.map((tool) => tool.trim())
+		.filter(Boolean);
+	return tools.length > 0 ? tools : undefined;
+}
+
+export interface AgentLoadDiagnostic {
+	/** Absolute path of the skipped file. */
+	path: string;
+	/** Why the file was skipped, from the YAML parser when it threw. */
+	message: string;
+}
+
+export interface AgentDirLoadResult {
+	agents: AgentConfig[];
+	diagnostics: AgentLoadDiagnostic[];
+}
+
+/**
+ * Load every agent file in a directory, collecting a diagnostic per file
+ * skipped for invalid YAML frontmatter. The real YAML parser is stricter
+ * than the line reader it replaced (`description: Deploy: fast` is a
+ * nested-mapping error, not a description), so without this record those
+ * files would vanish from discovery with no signal.
+ */
+export function loadAgentsFromDirWithDiagnostics(dir: string, source: AgentSource): AgentDirLoadResult {
 	const agents: AgentConfig[] = [];
+	const diagnostics: AgentLoadDiagnostic[] = [];
 
 	for (const filePath of listFilesRecursive(dir, (fileName) => fileName.endsWith(".md"))) {
 		let content: string;
@@ -56,59 +122,61 @@ export function loadAgentsFromDir(dir: string, source: AgentSource): AgentConfig
 			continue;
 		}
 
-		const { frontmatter, body } = parseFrontmatter(content);
+		const { frontmatter, body, parseError } = parseFrontmatter(content);
+		if (parseError !== undefined) {
+			diagnostics.push({ path: filePath, message: parseError });
+			continue;
+		}
 
-		if (!frontmatter.name || !frontmatter.description) {
+		// Sequences are legal frontmatter but not valid `name`/`description`
+		// spellings; a file whose identity fields are not plain strings is
+		// skipped whole, exactly as upstream's loader does.
+		const localName = frontmatterString(frontmatter.name);
+		const description = frontmatterString(frontmatter.description);
+		if (!localName || !description) {
 			continue;
 		}
 
-		const localName = frontmatter.name;
-		const parsedPackage = parsePackageName(frontmatter.package, `Agent '${localName}' package`);
+		const parsedPackage = parsePackageName(frontmatterString(frontmatter.package), `Agent '${localName}' package`);
 		if (parsedPackage.error) continue;
 		const packageName = parsedPackage.packageName;
 		const runtimeName = buildRuntimeName(localName, packageName);
 
-		const rawTools = parseCommaSeparatedList(frontmatter.tools);
+		const rawTools = parseToolList(frontmatter.tools);
 		const parsedTools = splitToolList(rawTools);
-		const defaultReads = parseCommaSeparatedList(frontmatter.defaultReads);
-		const skillStr = frontmatter.skill || frontmatter.skills;
+		const inheritProjectContextRaw = frontmatterBoolean(frontmatter.inheritProjectContext);
+		const inheritSkillsRaw = frontmatterBoolean(frontmatter.inheritSkills);
+		const defaultContextRaw = frontmatterString(frontmatter.defaultContext);
+		const extensionsRaw = frontmatterString(frontmatter.extensions);
+		const systemPromptModeRaw = frontmatterString(frontmatter.systemPromptMode);
+		const defaultReads = parseCommaSeparatedList(frontmatterString(frontmatter.defaultReads));
+		const skillStr = frontmatterString(frontmatter.skill) || frontmatterString(frontmatter.skills) || undefined;
 		const skills = parseCommaSeparatedList(skillStr);
-		const fallbackModels = parseCommaSeparatedList(frontmatter.fallbackModels);
-		const fallbackThinkingLevels = parseCommaSeparatedList(frontmatter.fallbackThinkingLevels);
+		const fallbackModels = parseCommaSeparatedList(frontmatterString(frontmatter.fallbackModels));
+		const fallbackThinkingLevels = parseCommaSeparatedList(frontmatterString(frontmatter.fallbackThinkingLevels));
+		const inheritProjectContext = inheritProjectContextRaw ?? defaultInheritProjectContext(localName);
+		const inheritSkills = inheritSkillsRaw ?? defaultInheritSkills();
 		const systemPromptMode =
-			frontmatter.systemPromptMode === "replace"
+			systemPromptModeRaw === "replace"
 				? "replace"
-				: frontmatter.systemPromptMode === "append"
+				: systemPromptModeRaw === "append"
 					? "append"
 					: defaultSystemPromptMode(localName);
-		const inheritProjectContext =
-			frontmatter.inheritProjectContext === "true"
-				? true
-				: frontmatter.inheritProjectContext === "false"
-					? false
-					: defaultInheritProjectContext(localName);
-		const inheritSkills =
-			frontmatter.inheritSkills === "true"
-				? true
-				: frontmatter.inheritSkills === "false"
-					? false
-					: defaultInheritSkills();
 		const defaultContext =
-			frontmatter.defaultContext === "fork"
+			defaultContextRaw === "fork"
 				? ("fork" as const)
-				: frontmatter.defaultContext === "fresh"
+				: defaultContextRaw === "fresh"
 					? ("fresh" as const)
 					: undefined;
-
 		let extensions: string[] | undefined;
-		if (frontmatter.extensions !== undefined) {
-			extensions = frontmatter.extensions
+		if (extensionsRaw !== undefined) {
+			extensions = extensionsRaw
 				.split(",")
 				.map((extension) => extension.trim())
 				.filter(Boolean);
 		}
 
-		const extraFields: Record<string, string> = {};
+		const extraFields: Record<string, FrontmatterValue> = {};
 		for (const [key, value] of Object.entries(frontmatter)) {
 			if (shouldPreserveAgentExtraField(key)) extraFields[key] = value;
 		}
@@ -119,13 +187,13 @@ export function loadAgentsFromDir(dir: string, source: AgentSource): AgentConfig
 			name: runtimeName,
 			localName,
 			packageName,
-			description: frontmatter.description,
+			description,
 			tools: parsedTools.tools,
 			mcpDirectTools: parsedTools.mcpDirectTools,
-			model: frontmatter.model,
+			model: frontmatterString(frontmatter.model),
 			fallbackModels,
 			fallbackThinkingLevels,
-			thinking: frontmatter.thinking,
+			thinking: frontmatterString(frontmatter.thinking),
 			systemPromptMode,
 			inheritProjectContext,
 			inheritSkills,
@@ -135,14 +203,18 @@ export function loadAgentsFromDir(dir: string, source: AgentSource): AgentConfig
 			filePath,
 			skills,
 			extensions,
-			output: frontmatter.output,
+			output: frontmatterString(frontmatter.output),
 			defaultReads,
-			defaultProgress: frontmatter.defaultProgress === "true",
-			interactive: frontmatter.interactive === "true",
+			defaultProgress: frontmatterBoolean(frontmatter.defaultProgress) === true,
+			interactive: frontmatterBoolean(frontmatter.interactive) === true,
 			maxSubagentDepth: parsedMaxSubagentDepth,
 			extraFields: Object.keys(extraFields).length > 0 ? extraFields : undefined,
 		});
 	}
 
-	return agents;
+	return { agents, diagnostics };
+}
+
+export function loadAgentsFromDir(dir: string, source: AgentSource): AgentConfig[] {
+	return loadAgentsFromDirWithDiagnostics(dir, source).agents;
 }

package/dist/builtin/subagents/src/agents/agent-management-helpers.ts

@@ -1,8 +1,9 @@
-import { MAX_SUBAGENT_NESTING_DEPTH, type SubagentToolResult } from "../shared/types.ts";
-import type { ManagementContext, ManagementScope } from "./agent-management.ts";
-import type { AgentConfig, AgentScope } from "./agents.ts";
-import { discoverAgentsAll, parsePackageName } from "./agents.ts";
-import { discoverAvailableSkills } from "./skills.ts";
+import type { SkillCatalog } from "@bastani/atomic";
+import { MAX_SUBAGENT_NESTING_DEPTH, type SubagentToolResult } from "../shared/types.js";
+import type { ManagementContext, ManagementScope } from "./agent-management.js";
+import type { AgentConfig, AgentScope } from "./agents.js";
+import { discoverAgentsAll, parsePackageName } from "./agents.js";
+import { discoverAvailableSkills, resolveSkillsFromCatalog } from "./skills.js";
 
 export function result(text: string, isError = false): SubagentToolResult {
 	return { content: [{ type: "text", text }], isError, details: { mode: "management", results: [] } };
@@ -105,10 +106,11 @@ export function fallbackModelsWarning(
 		: undefined;
 }
 
-export function skillsWarning(cwd: string, skills: string[] | undefined): string | undefined {
+export function skillsWarning(cwd: string, skills: string[] | undefined, catalog?: SkillCatalog): string | undefined {
 	if (!skills || skills.length === 0) return undefined;
-	const available = new Set(discoverAvailableSkills(cwd).map((s) => s.name));
-	const missing = skills.filter((s) => !available.has(s));
+	const missing = catalog
+		? resolveSkillsFromCatalog(skills, catalog, cwd).missing
+		: skills.filter((skill) => !new Set(discoverAvailableSkills(cwd).map((entry) => entry.name)).has(skill));
 	return missing.length ? `Warning: skills not found: ${missing.join(", ")}.` : undefined;
 }
 

package/dist/builtin/subagents/src/agents/agent-management.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { ExtensionContext } from "@bastani/atomic";
 import { CONFIG_DIR_NAME } from "@bastani/atomic";
-import type { SubagentToolResult } from "../shared/types.ts";
+import type { SubagentToolResult } from "../shared/types.js";
 import {
 	allAgents,
 	applyAgentConfig,
@@ -19,8 +19,8 @@ import {
 	result,
 	sanitizeName,
 	skillsWarning,
-} from "./agent-management-helpers.ts";
-import { serializeAgent } from "./agent-serializer.ts";
+} from "./agent-management-helpers.js";
+import { serializeAgent } from "./agent-serializer.js";
 import {
 	type AgentConfig,
 	type AgentSource,
@@ -30,11 +30,12 @@ import {
 	defaultSystemPromptMode,
 	discoverAgentsAll,
 	frontmatterNameForConfig,
-} from "./agents.ts";
+} from "./agents.js";
 
 type ManagementAction = "list" | "get" | "create" | "update" | "delete";
 export type ManagementScope = "user" | "project";
-export type ManagementContext = Pick<ExtensionContext, "cwd" | "modelRegistry">;
+export type ManagementContext = Pick<ExtensionContext, "cwd" | "modelRegistry"> &
+	Pick<Partial<ExtensionContext>, "getSkillCatalog">;
 
 interface ManagementParams {
 	action?: string;
@@ -208,7 +209,7 @@ export function handleCreate(params: ManagementParams, ctx: ManagementContext):
 	if (mw) warnings.push(mw);
 	const fmw = fallbackModelsWarning(ctx, agent.fallbackModels);
 	if (fmw) warnings.push(fmw);
-	const sw = skillsWarning(ctx.cwd, agent.skills);
+	const sw = skillsWarning(ctx.cwd, agent.skills, ctx.getSkillCatalog?.());
 	if (sw) warnings.push(sw);
 	fs.writeFileSync(targetPath, serializeAgent(agent), "utf-8");
 	return result([`Created agent '${runtimeName}' at ${targetPath}.`, ...warnings].join("\n"));
@@ -262,7 +263,7 @@ export function handleUpdate(params: ManagementParams, ctx: ManagementContext):
 		if (warning) warnings.push(warning);
 	}
 	if (hasKey(cfg, "skills")) {
-		const warning = skillsWarning(ctx.cwd, updated.skills);
+		const warning = skillsWarning(ctx.cwd, updated.skills, ctx.getSkillCatalog?.());
 		if (warning) warnings.push(warning);
 	}
 	if (updated.name !== oldName) {

package/dist/builtin/subagents/src/agents/agent-overrides.ts

@@ -1,13 +1,13 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { getProjectAgentSettingsPath, getUserAgentSettingsPath } from "./agent-paths.ts";
+import { getProjectAgentSettingsPath, getUserAgentSettingsPath } from "./agent-paths.js";
 import {
 	type AgentConfig,
 	type BuiltinAgentOverrideBase,
 	type BuiltinAgentOverrideConfig,
 	EMPTY_SUBAGENT_SETTINGS,
 	type SubagentSettings,
-} from "./agent-types.ts";
+} from "./agent-types.js";
 
 export function splitToolList(rawTools: string[] | undefined): { tools?: string[]; mcpDirectTools?: string[] } {
 	const mcpDirectTools: string[] = [];

package/dist/builtin/subagents/src/agents/agent-scope.ts

@@ -1,4 +1,4 @@
-import type { AgentScope } from "./agents.ts";
+import type { AgentScope } from "./agents.js";
 
 export function resolveExecutionAgentScope(scope: unknown): AgentScope {
 	if (scope === "user" || scope === "project" || scope === "both") return scope;

package/dist/builtin/subagents/src/agents/agent-selection.ts

@@ -1,4 +1,4 @@
-import type { AgentConfig, AgentScope } from "./agents.ts";
+import type { AgentConfig, AgentScope } from "./agents.js";
 
 export function mergeAgentsForScope(
 	scope: AgentScope,

package/dist/builtin/subagents/src/agents/agent-serializer.ts

@@ -1,5 +1,7 @@
-import type { AgentConfig } from "./agents.ts";
-import { frontmatterNameForConfig } from "./identity.ts";
+import { stringify } from "yaml";
+import type { AgentConfig } from "./agents.js";
+import type { FrontmatterValue } from "./frontmatter.js";
+import { frontmatterNameForConfig } from "./identity.js";
 
 export const KNOWN_FIELDS = new Set([
 	"name",
@@ -35,6 +37,25 @@ function joinComma(values: string[] | undefined): string | undefined {
 	return values.join(", ");
 }
 
+/**
+ * Render one extra frontmatter field through the real YAML emitter so an
+ * unknown custom field survives an agent update without changing meaning.
+ * The yaml package quotes scalars a hand-joined spelling corrupts: `a #b`
+ * would open a comment mid-flow-sequence and leave the file unparseable,
+ * `a, b` would split into two items, `a: b` would start a nested mapping,
+ * and an unquoted `""` or `"true"` would change type on re-parse. Keys are
+ * emitted by the same call, so a custom key that needs quoting gets it.
+ * Sequences render as block collections and may span several lines; nested
+ * maps are dropped at parse (they have no agent-frontmatter spelling) and
+ * so never reach this path. Every emitted shape re-parses to itself, so
+ * load → serialize → load is stable.
+ */
+function serializeExtraFieldEntry(key: string, value: FrontmatterValue): string[] {
+	return stringify({ [key]: value }, { lineWidth: 0 })
+		.trimEnd()
+		.split("\n");
+}
+
 export function serializeAgent(config: AgentConfig): string {
 	const lines: string[] = [];
 	lines.push("---");
@@ -80,7 +101,7 @@ export function serializeAgent(config: AgentConfig): string {
 	if (config.extraFields) {
 		for (const [key, value] of Object.entries(config.extraFields)) {
 			if (!shouldPreserveAgentExtraField(key)) continue;
-			lines.push(`${key}: ${value}`);
+			lines.push(...serializeExtraFieldEntry(key, value));
 		}
 	}
 

package/dist/builtin/subagents/src/agents/agent-types.ts

@@ -1,3 +1,5 @@
+import type { FrontmatterValue } from "./frontmatter.js";
+
 export type AgentScope = "user" | "project" | "both";
 
 export type AgentSource = "builtin" | "user" | "project";
@@ -79,7 +81,7 @@ export interface AgentConfig {
 	interactive?: boolean;
 	maxSubagentDepth?: number;
 	disabled?: boolean;
-	extraFields?: Record<string, string>;
+	extraFields?: Record<string, FrontmatterValue>;
 	override?: BuiltinAgentOverrideInfo;
 }
 

package/dist/builtin/subagents/src/agents/agents.ts

@@ -2,22 +2,24 @@
  * Agent discovery and configuration public surface.
  */
 
-export { discoverAgents, discoverAgentsAll } from "./agent-discovery.ts";
+export { discoverAgents, discoverAgentsAll } from "./agent-discovery.js";
+export type { AgentDirLoadResult, AgentLoadDiagnostic } from "./agent-loaders.js";
+export { loadAgentsFromDir, loadAgentsFromDirWithDiagnostics } from "./agent-loaders.js";
 export {
 	buildBuiltinOverrideConfig,
 	removeBuiltinAgentOverride,
 	saveBuiltinAgentOverride,
-} from "./agent-overrides.ts";
+} from "./agent-overrides.js";
 export type {
 	AgentConfig,
 	AgentDefaultContext,
 	AgentScope,
 	AgentSource,
 	BuiltinAgentOverrideBase,
-} from "./agent-types.ts";
+} from "./agent-types.js";
 export {
 	defaultInheritProjectContext,
 	defaultInheritSkills,
 	defaultSystemPromptMode,
-} from "./agent-types.ts";
-export { buildRuntimeName, frontmatterNameForConfig, parsePackageName } from "./identity.ts";
+} from "./agent-types.js";
+export { buildRuntimeName, frontmatterNameForConfig, parsePackageName } from "./identity.js";

package/dist/builtin/subagents/src/agents/frontmatter.ts

@@ -1,29 +1,74 @@
-export function parseFrontmatter(content: string): { frontmatter: Record<string, string>; body: string } {
-	const frontmatter: Record<string, string> = {};
-	const normalized = content.replace(/\r\n/g, "\n");
+import { parseFrontmatter as parseYamlFrontmatter } from "@bastani/atomic";
 
-	if (!normalized.startsWith("---")) {
-		return { frontmatter, body: normalized };
-	}
+/**
+ * A frontmatter value as a real YAML parser produces it (upstream pi #7598
+ * parses agent frontmatter with the yaml library, not a line reader): scalars
+ * parse to strings, booleans, numbers, or null; sequences — flow
+ * (`tools: [read, bash]`, single- or multi-line) and block (`tools:` followed
+ * by `- read` lines at any indentation) — parse to arrays of their string
+ * items. Nested maps have no agent-frontmatter spelling and are dropped at
+ * parse, so every consumer narrows over a finite union instead of
+ * re-deriving YAML semantics per field.
+ */
+export type FrontmatterValue = string | string[] | boolean | number | null;
+export type Frontmatter = Record<string, FrontmatterValue>;
+
+type RawFrontmatterValue =
+	| string
+	| boolean
+	| number
+	| null
+	| RawFrontmatterValue[]
+	| { [key: string]: RawFrontmatterValue };
+type ParsedYamlDocument = { frontmatter: Record<string, RawFrontmatterValue>; body: string };
 
-	const endIndex = normalized.indexOf("\n---", 3);
-	if (endIndex === -1) {
-		return { frontmatter, body: normalized };
+function toFrontmatterValue(value: RawFrontmatterValue): FrontmatterValue | undefined {
+	if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number") {
+		return value;
 	}
+	if (Array.isArray(value)) {
+		return value.filter((item): item is string => typeof item === "string");
+	}
+	return undefined;
+}
 
-	const frontmatterBlock = normalized.slice(4, endIndex);
-	const body = normalized.slice(endIndex + 4).trim();
+export interface ParsedAgentFrontmatter {
+	frontmatter: Frontmatter;
+	body: string;
+	/**
+	 * The YAML parser's error message when the document does not parse.
+	 * The switch from a line reader to the real parser made previously
+	 * loadable files (a colon-space inside a plain scalar, duplicate keys,
+	 * tab-indented block lists) read as frontmatter-less; carrying the
+	 * error lets the loader report the skipped file instead of letting it
+	 * vanish silently.
+	 */
+	parseError?: string;
+}
 
-	for (const line of frontmatterBlock.split("\n")) {
-		const match = line.match(/^([\w-]+):\s*(.*)$/);
-		if (match) {
-			let value = match[2].trim();
-			if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
-				value = value.slice(1, -1);
-			}
-			frontmatter[match[1]] = value;
-		}
+/**
+ * Parse a markdown file's frontmatter with the real YAML parser exported by
+ * `@bastani/atomic`. This function never throws: agent discovery loads every
+ * `.md` file in a directory, and one file with invalid YAML (an unclosed flow
+ * sequence, a colon-space inside a plain scalar) must not take down every
+ * other agent there. An unparseable document reads as no frontmatter, which
+ * makes the loader skip that file for lacking `name`/`description`, and the
+ * parse error is returned so discovery can surface a diagnostic.
+ */
+export function parseFrontmatter(content: string): ParsedAgentFrontmatter {
+	let parsed: ParsedYamlDocument;
+	try {
+		parsed = parseYamlFrontmatter<Record<string, RawFrontmatterValue>>(content);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return { frontmatter: {}, body: content, parseError: message };
 	}
-
-	return { frontmatter, body };
+	const frontmatter: Frontmatter = {};
+	const raw = parsed.frontmatter;
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return { frontmatter, body: parsed.body };
+	for (const [key, value] of Object.entries(raw)) {
+		const narrowed = toFrontmatterValue(value);
+		if (narrowed !== undefined) frontmatter[key] = narrowed;
+	}
+	return { frontmatter, body: parsed.body };
 }

package/dist/builtin/subagents/src/agents/identity.ts

@@ -1,4 +1,4 @@
-import type { AgentConfig } from "./agents.ts";
+import type { AgentConfig } from "./agents.js";
 
 const IDENTIFIER_PATTERN = /^[a-z0-9][a-z0-9-]*(?:\.[a-z0-9][a-z0-9-]*)*$/;
 

package/dist/builtin/subagents/src/agents/skills-paths.ts

@@ -9,7 +9,7 @@ import {
 	getBuiltinPackagePaths,
 	getProjectConfigDirs,
 } from "@bastani/atomic";
-import type { SkillSource } from "./skills.ts";
+import type { SkillSource } from "./skills.js";
 
 export interface SkillSearchPath {
 	path: string;