@agentxm/extension-content 0.38.0 → 0.39.0

package/dist/src/content/frontmatter.js

@@ -13,7 +13,6 @@ import YAML, { YAMLParseError } from "yaml";
 /** Bounded, document-relative failure from parsing a YAML frontmatter block. */
 export class FrontmatterParseFailure extends Data.TaggedError("FrontmatterParseFailure") {
 }
-const FRONTMATTER_DELIMITER = "---";
 export const FRONTMATTER_PARSE_FALLBACK_REASON = "YAML frontmatter could not be parsed";
 const FRONTMATTER_PARSE_REASON_MAX_CODE_POINTS = 256;
 const boundedReason = (reason) => {
@@ -52,27 +51,15 @@ export const normalizeFrontmatterParseFailure = (error, documentLineOffset) => {
  * Returns [endOfOpening, startOfClosing] indices, or undefined if no frontmatter.
  */
 const findFrontmatterBoundaries = (content) => {
-    if (!content.startsWith(FRONTMATTER_DELIMITER)) {
+    const opening = /^---\r?\n/u.exec(content);
+    if (opening === null)
         return undefined;
-    }
-    const afterOpening = content.indexOf("\n");
-    if (afterOpening === -1) {
-        return undefined;
-    }
-    const closingIndex = content.indexOf(`\n${FRONTMATTER_DELIMITER}`, afterOpening);
-    if (closingIndex === -1) {
+    const yamlStart = opening[0].length;
+    const closing = /^---(?:\r?\n|$)/mu.exec(content.slice(yamlStart));
+    if (closing === null)
         return undefined;
-    }
-    const closingEnd = closingIndex + 1 + FRONTMATTER_DELIMITER.length;
-    const bodyStart = content.startsWith("\r\n", closingEnd)
-        ? closingEnd + 2
-        : content[closingEnd] === "\n"
-            ? closingEnd + 1
-            : closingEnd;
-    return {
-        yamlStart: afterOpening + 1,
-        bodyStart,
-    };
+    const yamlEnd = yamlStart + closing.index;
+    return { yamlStart, yamlEnd, bodyStart: yamlEnd + closing[0].length };
 };
 /**
  * Parse frontmatter from content synchronously.
@@ -86,10 +73,10 @@ export const parseFrontmatterSync = (content) => {
     if (boundaries === undefined) {
         return { frontmatter: undefined, body: content };
     }
-    const yamlContent = content.slice(boundaries.yamlStart, boundaries.bodyStart).split("---")[0];
+    const yamlContent = content.slice(boundaries.yamlStart, boundaries.yamlEnd);
     const frontmatter = (() => {
         try {
-            return YAML.parse(yamlContent ?? "");
+            return YAML.parse(yamlContent);
         }
         catch (error) {
             const documentLineOffset = content.slice(0, boundaries.yamlStart).split("\n").length - 1;

package/dist/src/content/skill-content.d.ts

@@ -30,6 +30,20 @@ export type SkillFrontmatterValidation = {
     readonly valid: false;
     readonly errors: ReadonlyArray<string>;
 };
+/** Best-effort display metadata from an externally distributed skill. */
+export interface ExtractedSkillMetadata {
+    readonly name?: string;
+    readonly description?: string;
+    readonly metadata?: unknown;
+    readonly frontmatter?: Readonly<Record<string, unknown>>;
+}
+/**
+ * Read external metadata without applying AXM's authoring contract. The source
+ * remains authoritative: unknown fields, display names and metadata values are
+ * retained as declared. Missing or malformed metadata does not make an explicit
+ * SKILL.md path unavailable to acquisition.
+ */
+export declare const extractSkillMetadata: (content: string) => ExtractedSkillMetadata;
 /** Validate parsed YAML against the pinned Agent Skills metadata contract. */
 export declare const validateSkillFrontmatter: (input: unknown, expectedDirectoryName?: string) => SkillFrontmatterValidation;
 /**

package/dist/src/content/skill-content.js

@@ -49,6 +49,30 @@ export const SkillFrontmatterSchema = Schema.Struct({
 });
 const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 const allowedFrontmatterFields = new Set(AGENT_SKILLS_FRONTMATTER_FIELDS);
+/**
+ * Read external metadata without applying AXM's authoring contract. The source
+ * remains authoritative: unknown fields, display names and metadata values are
+ * retained as declared. Missing or malformed metadata does not make an explicit
+ * SKILL.md path unavailable to acquisition.
+ */
+export const extractSkillMetadata = (content) => {
+    try {
+        const { frontmatter } = parseFrontmatterSync(content.replace(/^\uFEFF/, ""));
+        if (!isRecord(frontmatter))
+            return {};
+        const name = frontmatter["name"];
+        const description = frontmatter["description"];
+        return {
+            ...(typeof name === "string" && name.trim().length > 0 ? { name } : {}),
+            ...(typeof description === "string" && description.trim().length > 0 ? { description } : {}),
+            ...(frontmatter["metadata"] === undefined ? {} : { metadata: frontmatter["metadata"] }),
+            frontmatter,
+        };
+    }
+    catch {
+        return {};
+    }
+};
 /** Validate parsed YAML against the pinned Agent Skills metadata contract. */
 export const validateSkillFrontmatter = (input, expectedDirectoryName) => {
     if (!isRecord(input)) {

package/dist/src/content/subagent-content.d.ts

@@ -1,58 +1,82 @@
-/**
- * Subagent content file module for subagent content parsing.
- *
- * The content file's YAML frontmatter is largely free-form: only `name` is
- * required and validated. `agentOverrides`, when present, is recognized for
- * use in per-agent rendering. Any other frontmatter keys flow through
- * verbatim to the agent-native file produced by the renderer.
- *
- * @experimental This API is unstable and may change without notice.
- */
 import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import { type SubagentManifest } from "@agentxm/extension-model/unstable/subagents/manifest-schema";
 declare const SubagentContentError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
     readonly _tag: "SubagentContentError";
 } & Readonly<A>;
-/**
- * Typed failure produced while parsing a subagent content file. Application
- * layers translate this into their own error vocabulary.
- *
- * @experimental This API is unstable and may change without notice.
- */
 export declare class SubagentContentError extends SubagentContentError_base<{
-    readonly reason: "frontmatter-parse" | "missing-frontmatter" | "invalid-frontmatter" | "name-mismatch";
+    readonly reason: "manifest-invalid" | "reference-invalid" | "content-invalid" | "native-invalid";
     readonly detail: string;
-    readonly suggestion?: string;
+    readonly source?: string;
     readonly cause?: unknown;
 }> {
 }
-/**
- * Map of agent-id → merge patch applied during per-agent rendering.
- *
- * @experimental This API is unstable and may change without notice.
- */
-export type SubagentAgentOverrides = Readonly<Record<string, Readonly<Record<string, unknown>>>>;
-/**
- * Result of parsing a subagent content file.
- *
- * @experimental This API is unstable and may change without notice.
- */
-export interface SubagentContentResult {
-    /** The full frontmatter map, opaque except for `name`. Empty when no frontmatter. */
-    readonly frontmatter: Option.Option<Readonly<Record<string, unknown>>>;
-    /** The `agentOverrides` map keyed by agent id, when present and structurally valid. */
-    readonly agentOverrides: Option.Option<SubagentAgentOverrides>;
-    /** Content body after the frontmatter block, or full content if no frontmatter. */
-    readonly body: string;
+export interface NativeSubagentContent {
+    readonly format: "markdown" | "toml" | "json";
+    /** Exact author-supplied native source; AXM never merges a core into it. */
+    readonly content: string;
+    readonly configuration: Readonly<Record<string, unknown>>;
+    readonly name: string;
+    readonly description?: string;
+    readonly instructions: string;
 }
-/**
- * Parse a subagent content file into validated frontmatter and body.
- *
- * Validates only that frontmatter is present and that its `name` matches
- * the expected name. All other keys are preserved verbatim.
- *
- * @experimental This API is unstable and may change without notice.
- */
-export declare const parseSubagentMd: (content: string, expectedName: string) => Effect.Effect<SubagentContentResult, SubagentContentError>;
+/** Known native syntax, independent of AXM's scope, ownership, or writer support. */
+export declare const nativeSubagentFormat: (agentId: string) => NativeSubagentContent["format"] | undefined;
+export type ResolvedSubagentImplementation = {
+    readonly kind: "customized";
+    readonly configuration: Readonly<Record<string, unknown>>;
+    readonly instructions?: {
+        readonly mode: "append" | "replace";
+        readonly source: string;
+        readonly content: string;
+    };
+} | {
+    readonly kind: "native";
+    readonly source: string;
+    readonly native: NativeSubagentContent;
+};
+export interface DecodedSubagentPackage {
+    readonly manifest: SubagentManifest;
+    readonly core?: {
+        readonly name: string;
+        readonly description: string;
+        readonly instructions: string;
+        readonly source: string;
+    };
+    readonly implementations: Readonly<Record<string, ResolvedSubagentImplementation>>;
+}
+export type SelectedSubagentImplementation = {
+    readonly kind: "core" | "customized";
+    readonly name: string;
+    readonly description: string;
+    readonly instructions: string;
+    readonly configuration: Readonly<Record<string, unknown>>;
+    readonly sourceDependencies: ReadonlyArray<string>;
+} | {
+    readonly kind: "native";
+    readonly source: string;
+    readonly native: NativeSubagentContent;
+    readonly sourceDependencies: ReadonlyArray<string>;
+} | {
+    readonly kind: "unsupported";
+    readonly reason: string;
+    readonly sourceDependencies: ReadonlyArray<string>;
+};
+/** Parse a complete native definition without discarding unknown native fields. */
+export declare const parseNativeSubagent: (args: {
+    readonly agentId: string;
+    readonly source: string;
+    readonly content: string;
+}) => Effect.Effect<NativeSubagentContent, SubagentContentError>;
+/** Validate and resolve every declared compile-time input using a package-contained reader. */
+export declare const readSubagentPackage: <E, R>(args: {
+    readonly manifest: unknown;
+    readonly readFile: (relativePath: string) => Effect.Effect<string, E, R>;
+}) => Effect.Effect<DecodedSubagentPackage, SubagentContentError | E, R>;
+/** Read regular source files only after resolving them inside the owning package. */
+export declare const loadSubagentPackage: (packageRoot: string) => Effect.Effect<DecodedSubagentPackage, SubagentContentError, FileSystem.FileSystem | Path.Path>;
+/** Select one explicit implementation; a complete native definition bypasses the core. */
+export declare const selectSubagentImplementation: (pkg: DecodedSubagentPackage, agentId: string) => SelectedSubagentImplementation;
 export {};
 //# sourceMappingURL=subagent-content.d.ts.map

package/dist/src/content/subagent-content.js

@@ -1,101 +1,289 @@
-/**
- * Subagent content file module for subagent content parsing.
- *
- * The content file's YAML frontmatter is largely free-form: only `name` is
- * required and validated. `agentOverrides`, when present, is recognized for
- * use in per-agent rendering. Any other frontmatter keys flow through
- * verbatim to the agent-native file produced by the renderer.
- *
- * @experimental This API is unstable and may change without notice.
- */
+/** Native definition parsing and package selection shared by every subagent workflow. */
+// @effect-diagnostics anyUnknownInErrorContext:off — package readers preserve caller-owned read errors
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
 import * as Schema from "effect/Schema";
+import { parse as parseToml } from "smol-toml";
+import { MANIFEST_FILENAME, SubagentManifestSchema, SubagentNativeNameSchema, } from "@agentxm/extension-model/unstable/subagents/manifest-schema";
 import { parseFrontmatterEffect } from "./frontmatter.js";
-/**
- * Typed failure produced while parsing a subagent content file. Application
- * layers translate this into their own error vocabulary.
- *
- * @experimental This API is unstable and may change without notice.
- */
 export class SubagentContentError extends Data.TaggedError("SubagentContentError") {
 }
-/**
- * Schema for the only required frontmatter field — `name`.
- *
- * Used to validate that `name` is present and a string. The full frontmatter
- * map is preserved verbatim and surfaced as `frontmatter`.
- */
-const NameOnlySchema = Schema.Struct({
-    name: Schema.String,
-}).annotate({
-    identifier: "SubagentFrontmatterName",
-    description: "Required `name` field for subagent frontmatter.",
-});
-const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const extractAgentOverrides = (fm) => {
-    const raw = fm["agentOverrides"];
-    if (!isPlainObject(raw))
-        return Option.none();
-    const out = {};
-    for (const [agentId, patch] of Object.entries(raw)) {
-        if (isPlainObject(patch))
-            out[agentId] = patch;
-    }
-    return Option.some(out);
+const nativeFormats = {
+    antigravity: "markdown",
+    "antigravity-cli": "markdown",
+    "claude-code": "markdown",
+    "github-copilot-cli": "markdown",
+    cursor: "markdown",
+    "gemini-cli": "markdown",
+    opencode: "markdown",
+    augment: "markdown",
+    junie: "markdown",
+    kilo: "markdown",
+    "kimi-cli": "markdown",
+    codebuddy: "markdown",
+    "mimo-code": "markdown",
+    kode: "markdown",
+    "codearts-agent": "markdown",
+    "iflow-cli": "markdown",
+    rovodev: "markdown",
+    "qwen-code": "markdown",
+    qoder: "markdown",
+    "qoder-cn": "markdown",
+    "grok-cli": "markdown",
+    "command-code": "markdown",
+    mux: "markdown",
+    devin: "markdown",
+    codex: "toml",
+    "mistral-vibe": "toml",
+    "kiro-cli": "json",
+    roo: "json",
 };
-/**
- * Parse a subagent content file into validated frontmatter and body.
- *
- * Validates only that frontmatter is present and that its `name` matches
- * the expected name. All other keys are preserved verbatim.
- *
- * @experimental This API is unstable and may change without notice.
- */
-export const parseSubagentMd = (content, expectedName) => Effect.gen(function* () {
-    const parsed = yield* parseFrontmatterEffect(content).pipe(Effect.mapError((cause) => new SubagentContentError({
-        reason: "frontmatter-parse",
-        detail: "YAML frontmatter could not be parsed",
-        suggestion: "Ensure the frontmatter block contains valid YAML between --- delimiters.",
-        cause,
-    })));
-    if (parsed.frontmatter === undefined) {
-        return yield* new SubagentContentError({
-            reason: "missing-frontmatter",
-            detail: `Missing subagent frontmatter for "${expectedName}"`,
-            suggestion: `Add YAML frontmatter with name: ${expectedName}.`,
+/** Known native syntax, independent of AXM's scope, ownership, or writer support. */
+export const nativeSubagentFormat = (agentId) => nativeFormats[agentId];
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** Reject dangerous object keys, including nested keys, before downstream merging. */
+const hasUnsafeKeys = (value, seen = new Set()) => {
+    if (typeof value !== "object" || value === null)
+        return false;
+    if (seen.has(value))
+        return true;
+    seen.add(value);
+    const unsafe = Object.entries(value).some(([key, child]) => ["__proto__", "prototype", "constructor", "agentOverrides"].includes(key) ||
+        hasUnsafeKeys(child, seen));
+    seen.delete(value);
+    return unsafe;
+};
+/** Parse a complete native definition without discarding unknown native fields. */
+export const parseNativeSubagent = (args) => Effect.gen(function* () {
+    const invalid = (detail) => new SubagentContentError({
+        reason: "native-invalid",
+        source: args.source,
+        detail,
+    });
+    const extension = args.source.split(".").at(-1)?.toLowerCase();
+    const format = extension === "md"
+        ? "markdown"
+        : extension === "toml"
+            ? "toml"
+            : extension === "json"
+                ? "json"
+                : undefined;
+    if (format === undefined) {
+        return yield* invalid(`Native source "${args.source}" must be Markdown, TOML, or JSON.`);
+    }
+    const expectedFormat = nativeSubagentFormat(args.agentId);
+    if (expectedFormat !== undefined && expectedFormat !== format) {
+        return yield* invalid(`Native source "${args.source}" must use ${expectedFormat} for ${args.agentId}.`);
+    }
+    let configuration;
+    let instructions;
+    if (format === "markdown") {
+        const parsed = yield* parseFrontmatterEffect(args.content).pipe(Effect.mapError(() => invalid(`Native source "${args.source}" has invalid YAML frontmatter.`)));
+        if (!isRecord(parsed.frontmatter)) {
+            return yield* invalid(`Native source "${args.source}" requires an object frontmatter block.`);
+        }
+        configuration = parsed.frontmatter;
+        instructions = parsed.body;
+    }
+    else {
+        const parsed = yield* Effect.try({
+            try: () => format === "toml" ? parseToml(args.content) : JSON.parse(args.content),
+            catch: () => invalid(`Native source "${args.source}" is not valid ${format.toUpperCase()}.`),
         });
+        if (!isRecord(parsed))
+            return yield* invalid(`Native source "${args.source}" must be an object.`);
+        configuration = parsed;
+        const instructionKey = format === "toml"
+            ? args.agentId === "codex"
+                ? "developer_instructions"
+                : "system_prompt"
+            : "prompt";
+        const value = parsed[instructionKey];
+        if (value !== undefined && typeof value !== "string") {
+            return yield* invalid(`Native source "${args.source}" requires a string ${instructionKey}.`);
+        }
+        instructions = typeof value === "string" ? value : "";
+    }
+    if (hasUnsafeKeys(configuration)) {
+        return yield* invalid(`Native source "${args.source}" contains unsafe or obsolete object keys.`);
+    }
+    if (args.agentId === "codex" || args.agentId === "claude-code") {
+        const required = args.agentId === "codex"
+            ? ["name", "description", "developer_instructions"]
+            : ["name", "description"];
+        for (const key of required) {
+            const value = configuration[key];
+            if (typeof value !== "string" || value.trim().length === 0) {
+                return yield* invalid(`Native source "${args.source}" requires nonempty ${key} for ${args.agentId}.`);
+            }
+        }
     }
-    yield* Effect.try({
-        try: () => Schema.decodeUnknownSync(NameOnlySchema)(parsed.frontmatter),
-        catch: (error) => new SubagentContentError({
-            reason: "invalid-frontmatter",
-            detail: "Invalid subagent frontmatter",
-            suggestion: "Frontmatter must include a string `name` field.",
-            cause: error,
+    if (args.agentId === "mistral-vibe" && configuration["agent_type"] !== "subagent") {
+        return yield* invalid(`Native source "${args.source}" requires agent_type = "subagent".`);
+    }
+    const stem = args.source
+        .split("/")
+        .at(-1)
+        ?.replace(/\.[^.]+$/, "");
+    const nativeName = args.agentId === "opencode" || args.agentId === "mistral-vibe"
+        ? stem
+        : (configuration["name"] ?? stem);
+    const name = yield* Schema.decodeUnknownEffect(SubagentNativeNameSchema)(nativeName).pipe(Effect.mapError(() => invalid(`Native source "${args.source}" requires a safe native name.`)));
+    const description = configuration["description"];
+    if (description !== undefined && typeof description !== "string") {
+        return yield* invalid(`Native source "${args.source}" requires a string description.`);
+    }
+    return {
+        format,
+        content: args.content,
+        configuration,
+        name,
+        instructions,
+        ...(description === undefined ? {} : { description }),
+    };
+});
+/** Validate and resolve every declared compile-time input using a package-contained reader. */
+export const readSubagentPackage = (args) => Effect.gen(function* () {
+    const manifest = yield* Schema.decodeUnknownEffect(SubagentManifestSchema, {
+        onExcessProperty: "error",
+    })(args.manifest).pipe(Effect.mapError((cause) => new SubagentContentError({
+        reason: "manifest-invalid",
+        detail: "Invalid subagent package manifest.",
+        cause,
+    })));
+    const core = manifest.core === undefined
+        ? undefined
+        : {
+            name: manifest.core.name ?? manifest.name,
+            description: manifest.description ?? "",
+            instructions: yield* args.readFile(manifest.core.instructions),
+            source: manifest.core.instructions,
+        };
+    const entries = yield* Effect.forEach(Object.entries(manifest.implementations ?? {}), ([agentId, implementation]) => Effect.gen(function* () {
+        let resolved;
+        if (implementation.kind === "native") {
+            const content = yield* args.readFile(implementation.source);
+            const native = yield* parseNativeSubagent({
+                agentId,
+                source: implementation.source,
+                content,
+            });
+            resolved = { kind: "native", source: implementation.source, native };
+        }
+        else {
+            if (hasUnsafeKeys(implementation.configuration)) {
+                return yield* new SubagentContentError({
+                    reason: "manifest-invalid",
+                    detail: `Implementation "${agentId}" contains unsafe configuration keys.`,
+                });
+            }
+            const instructions = implementation.instructions === undefined
+                ? undefined
+                : {
+                    ...implementation.instructions,
+                    content: yield* args.readFile(implementation.instructions.source),
+                };
+            resolved = {
+                kind: "customized",
+                configuration: implementation.configuration ?? {},
+                ...(instructions === undefined ? {} : { instructions }),
+            };
+        }
+        return [agentId, resolved];
+    }));
+    return {
+        manifest,
+        ...(core === undefined ? {} : { core }),
+        implementations: Object.fromEntries(entries),
+    };
+});
+/** Read regular source files only after resolving them inside the owning package. */
+export const loadSubagentPackage = (packageRoot) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const realRoot = yield* fs.realPath(packageRoot).pipe(Effect.mapError((cause) => new SubagentContentError({
+        reason: "reference-invalid",
+        detail: "Subagent package root could not be resolved.",
+        cause,
+    })));
+    const readFile = (source) => Effect.gen(function* () {
+        const sourcePath = path.join(realRoot, source);
+        const realSource = yield* fs.realPath(sourcePath);
+        const relative = path.relative(realRoot, realSource);
+        if (relative === "" ||
+            relative === ".." ||
+            relative.startsWith(`..${path.sep}`) ||
+            path.isAbsolute(relative)) {
+            return yield* new SubagentContentError({
+                reason: "reference-invalid",
+                source,
+                detail: `Source "${source}" escapes its package.`,
+            });
+        }
+        const info = yield* fs.stat(realSource);
+        if (info.type !== "File") {
+            return yield* new SubagentContentError({
+                reason: "reference-invalid",
+                source,
+                detail: `Source "${source}" must be a regular file.`,
+            });
+        }
+        return yield* fs.readFileString(realSource);
+    }).pipe(Effect.mapError((cause) => cause instanceof SubagentContentError
+        ? cause
+        : new SubagentContentError({
+            reason: "reference-invalid",
+            source,
+            detail: `Source "${source}" could not be read.`,
+            cause,
+        })));
+    const manifestSource = yield* readFile(MANIFEST_FILENAME);
+    const manifest = yield* Effect.try({
+        try: () => JSON.parse(manifestSource),
+        catch: () => new SubagentContentError({
+            reason: "manifest-invalid",
+            source: MANIFEST_FILENAME,
+            detail: "Subagent manifest must contain valid JSON.",
         }),
     });
-    if (!isPlainObject(parsed.frontmatter)) {
-        return yield* new SubagentContentError({
-            reason: "invalid-frontmatter",
-            detail: "Subagent frontmatter must be a YAML mapping",
-            suggestion: `Add YAML frontmatter with name: ${expectedName}.`,
-        });
+    return yield* readSubagentPackage({ manifest, readFile });
+});
+/** Select one explicit implementation; a complete native definition bypasses the core. */
+export const selectSubagentImplementation = (pkg, agentId) => {
+    const implementation = pkg.implementations[agentId];
+    if (implementation?.kind === "native") {
+        return { ...implementation, sourceDependencies: [MANIFEST_FILENAME, implementation.source] };
     }
-    const fm = parsed.frontmatter;
-    const name = fm["name"];
-    if (name !== expectedName) {
-        return yield* new SubagentContentError({
-            reason: "name-mismatch",
-            detail: `Subagent frontmatter name "${String(name)}" does not match expected name "${expectedName}"`,
-            suggestion: `Set subagent.json name, frontmatter name, and filename to ${expectedName}.`,
-        });
+    const core = pkg.core;
+    if (core === undefined) {
+        return {
+            kind: "unsupported",
+            reason: `This package has no implementation for ${agentId}.`,
+            sourceDependencies: [MANIFEST_FILENAME],
+        };
     }
+    const customization = implementation?.kind === "customized" ? implementation : undefined;
+    const replacement = customization?.instructions;
+    const instructions = replacement === undefined
+        ? core.instructions
+        : replacement.mode === "replace"
+            ? replacement.content
+            : `${core.instructions}\n\n${replacement.content}`;
     return {
-        frontmatter: Option.some(fm),
-        agentOverrides: extractAgentOverrides(fm),
-        body: parsed.body,
+        kind: customization === undefined ? "core" : "customized",
+        name: core.name,
+        description: core.description,
+        instructions,
+        configuration: customization?.configuration ?? {},
+        sourceDependencies: [
+            ...new Set([
+                MANIFEST_FILENAME,
+                ...(replacement?.mode === "replace" ? [] : [core.source]),
+                ...(replacement === undefined ? [] : [replacement.source]),
+            ]),
+        ],
     };
-});
+};
 //# sourceMappingURL=subagent-content.js.map

package/dist/src/index.d.ts

@@ -12,13 +12,13 @@
  */
 export { AGENT_SKILLS_COMPATIBILITY_MAX_LENGTH, AGENT_SKILLS_DESCRIPTION_MAX_LENGTH, AGENT_SKILLS_FRONTMATTER_FIELDS, AGENT_SKILLS_NAME_MAX_LENGTH, AGENT_SKILLS_REFERENCE_VALIDATOR_URL, AGENT_SKILLS_SPECIFICATION_URL, AGENT_SKILLS_STANDARD_REVISION, } from "./content/agent-skills-standard.js";
 export { FRONTMATTER_PARSE_FALLBACK_REASON, FrontmatterParseFailure, type FrontmatterResult, parseFrontmatterEffect, parseFrontmatterSync, } from "./content/frontmatter.js";
-export { type SkillFrontmatter, SkillFrontmatterSchema, type SkillFrontmatterValidation, parseSkillMd, validateSkillFrontmatter, } from "./content/skill-content.js";
+export { type ExtractedSkillMetadata, type SkillFrontmatter, SkillFrontmatterSchema, type SkillFrontmatterValidation, parseSkillMd, extractSkillMetadata, validateSkillFrontmatter, } from "./content/skill-content.js";
 export { type Skill } from "./content/skill-types.js";
-export { type SubagentAgentOverrides, type SubagentContentResult, SubagentContentError, parseSubagentMd, } from "./content/subagent-content.js";
-export { ArchiveGuardrailError, type ArchiveGuardrailLimits, ZIP_LOCAL_SIGNATURE, type ZipEntry, checkForbiddenSourceEntries, parseZipCentralDirectory, validateArchive, } from "./packaging/archive-guardrails.js";
+export { type DecodedSubagentPackage, type NativeSubagentContent, type ResolvedSubagentImplementation, type SelectedSubagentImplementation, SubagentContentError, loadSubagentPackage, nativeSubagentFormat, parseNativeSubagent, readSubagentPackage, selectSubagentImplementation, } from "./content/subagent-content.js";
+export { ArchiveGuardrailError, type ArchiveGuardrailLimits, ZIP_LOCAL_SIGNATURE, type ZipEntry, checkForbiddenSourceEntries, defaultReadEntry, parseZipCentralDirectory, validateArchive, } from "./packaging/archive-guardrails.js";
 export { FilteredPackageError, type ValidateFilteredPackageArgs, validateFilteredPackage, } from "./packaging/filtered-package-validation.js";
 export { IngestLimitError, IngestUnsupportedContentTypeError, REGISTRY_PUBLISH_MAX_ARCHIVE_BYTES, REGISTRY_PUBLISH_MAX_REQUEST_BYTES, enforceArchiveContentType, enforceArchiveSizeLimit, enforceRequestSizeLimit, } from "./packaging/ingest-limits.js";
-export { type NormalizePublishInputArgs, type PublishArchiveInput, type PublishInput, defaultReadEntry, normalizePublishInput, } from "./packaging/input-normalization.js";
+export { type NormalizePublishInputArgs, type PublishArchiveInput, type PublishInput, normalizePublishInput, } from "./packaging/input-normalization.js";
 export { type DeclaredPublishIdentity, type ExtensionManifest, MANIFEST_FILENAME_BY_TYPE, MANIFEST_FILENAMES, MANIFEST_SCHEMA_BY_TYPE, ManifestError, type ManifestIdentity, ManifestIdentitySchema, type ManifestResolutionInput, type ResolvedManifest, manifestFilenameForType, extensionTypeForManifestFilename, manifestSchemaForType, resolveManifest, validateDeclaredManifestAlignment, validateManifestHasNoAgentsField, } from "./packaging/manifest-policy.js";
 export { readExtensionManifest } from "./packaging/manifest-file.js";
 //# sourceMappingURL=index.d.ts.map