@agentxm/extension-content 0.28.14-preview.1789139351.5cd4595aa

package/dist/src/lint/catalog/shared/schema-rule.js

@@ -0,0 +1,102 @@
+/**
+ * Shared schema-delegation plumbing for `-schema-valid` rules.
+ *
+ * Every rule whose id ends in `-schema-valid` implements `check` by
+ * running the canonical schema through `Schema.decodeUnknownResult` with
+ * `onExcessProperty: "ignore"` and `errors: "all"`, then mapping the issues
+ * through `issuesToFindings`.
+ *
+ * The helper is intentionally narrow — only the surface the `-schema-valid`
+ * rules need.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { describeSchemaDocument } from "../../describe-document.js";
+import { issuesToFindings } from "../../issues-to-findings.js";
+import { isManifestJsonParseFailure, manifestJsonParseFailureToFinding } from "./manifest-json.js";
+// -----------------------------------------------------------------------------
+// schemaDecodeFindings
+// -----------------------------------------------------------------------------
+/**
+ * Decode `input` against `schema` (excess keys ignored, all issues collected)
+ * and return one advisory finding per leaf issue. Success produces `[]`.
+ *
+ * `input` of `undefined` short-circuits to `[]` — the caller is expected to
+ * have already guarded on "manifest exists" via the complementary
+ * `-present` rule.
+ *
+ * @param ruleId   - `<namespace>/<name>` id of the calling rule.
+ * @param severity - Severity to stamp on each emitted finding.
+ * @param file     - Accessor-relative file path to stamp on `location.file`.
+ * @param schema   - Canonical Effect schema; `Schema.decodeUnknownResult`
+ *                   runs with `onExcessProperty: "ignore"` and `errors: "all"`.
+ * @param input    - Raw decoded JSON value to check (typically `subject.*Json`).
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const schemaDecodeFindings = (ruleId, severity, file, schema, input) => {
+    if (input === undefined) {
+        return Effect.succeed([]);
+    }
+    if (isManifestJsonParseFailure(input)) {
+        return Effect.succeed([manifestJsonParseFailureToFinding(ruleId, severity, file, input)]);
+    }
+    const result = Schema.decodeUnknownResult(schema)(input, {
+        onExcessProperty: "ignore",
+        errors: "all",
+    });
+    if (Result.isSuccess(result)) {
+        return Effect.succeed([]);
+    }
+    return Effect.succeed(issuesToFindings(ruleId, severity, file, result.failure.issue));
+};
+// -----------------------------------------------------------------------------
+// enumerateUnknownTopLevelKeys
+// -----------------------------------------------------------------------------
+/**
+ * Read the top-level field names of a `Schema.Struct` value.
+ *
+ * Callers produce an `allowedKeys` set in one place, driven by the schema
+ * itself — no copy-paste of field names into rule bodies. If the schema
+ * gains a field the allowed-keys set grows by construction.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const structFieldKeys = (struct) => new Set(Object.keys(struct.fields));
+/**
+ * Enumerate top-level keys present on `input` that are not declared by
+ * `allowedKeys`. Returns one advisory finding per unknown key.
+ *
+ * `input` of `undefined` or non-object short-circuits to `[]`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const enumerateUnknownTopLevelKeys = (ruleId, severity, file, allowedKeys, input) => {
+    if (isManifestJsonParseFailure(input)) {
+        return [];
+    }
+    if (!isPlainRecord(input)) {
+        return [];
+    }
+    const findings = [];
+    for (const key of Object.keys(input)) {
+        if (allowedKeys.has(key)) {
+            continue;
+        }
+        findings.push({
+            kind: "advisory",
+            ruleId,
+            severity,
+            message: `${describeSchemaDocument(file)} has unrecognized top-level field '${key}'. ` +
+                `The current schema does not recognize this field.`,
+            location: { file },
+        });
+    }
+    return findings;
+};
+const isPlainRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+//# sourceMappingURL=schema-rule.js.map

package/dist/src/lint/catalog/skill/frontmatter-parseable.d.ts

@@ -0,0 +1,31 @@
+/**
+ * `skill/frontmatter-parseable` — SKILL.md frontmatter parses as a YAML
+ * mapping.
+ *
+ * Cascade (reports the first failure in the order below; later arms
+ * short-circuit):
+ *
+ * 1. SKILL.md begins with `---` at byte 0 (no BOM, no leading whitespace, no
+ *    leading HTML comment). This is the arm that caught the
+ *    `@agentxm/skills/axm` regression — an HTML comment preceded the
+ *    frontmatter delimiter, so YAML parsers silently treated the content as
+ *    body.
+ * 2. Frontmatter YAML parses without error.
+ * 3. Parsed frontmatter is a mapping (not a list, not a scalar).
+ *
+ * Presence is handled by `skill/skill-md-present`; this rule early-returns
+ * `[]` when `SKILL.md` is absent.
+ *
+ * Advisory-only — the cascade mixes one mechanically-fixable arm
+ * (strip-leading-bytes) with arms requiring human judgment (fix YAML
+ * syntax). Per the lint design, splitting by
+ * kind or adding a byte-range mutation Operation is deferred until a second
+ * mechanical arm justifies it.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { SkillRuleContext } from "../../context.js";
+import type { AdvisoryRule } from "../../rule.js";
+export declare const frontmatterParseableRule: AdvisoryRule<SkillRuleContext>;
+//# sourceMappingURL=frontmatter-parseable.d.ts.map

package/dist/src/lint/catalog/skill/frontmatter-parseable.js

@@ -0,0 +1,148 @@
+/**
+ * `skill/frontmatter-parseable` — SKILL.md frontmatter parses as a YAML
+ * mapping.
+ *
+ * Cascade (reports the first failure in the order below; later arms
+ * short-circuit):
+ *
+ * 1. SKILL.md begins with `---` at byte 0 (no BOM, no leading whitespace, no
+ *    leading HTML comment). This is the arm that caught the
+ *    `@agentxm/skills/axm` regression — an HTML comment preceded the
+ *    frontmatter delimiter, so YAML parsers silently treated the content as
+ *    body.
+ * 2. Frontmatter YAML parses without error.
+ * 3. Parsed frontmatter is a mapping (not a list, not a scalar).
+ *
+ * Presence is handled by `skill/skill-md-present`; this rule early-returns
+ * `[]` when `SKILL.md` is absent.
+ *
+ * Advisory-only — the cascade mixes one mechanically-fixable arm
+ * (strip-leading-bytes) with arms requiring human judgment (fix YAML
+ * syntax). Per the lint design, splitting by
+ * kind or adding a byte-range mutation Operation is deferred until a second
+ * mechanical arm justifies it.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+import YAML from "yaml";
+const RULE_ID = "skill/frontmatter-parseable";
+const SKILL_MD = "SKILL.md";
+const DELIMITER = "---";
+// U+FEFF — UTF-8 BOM as a single code point. Escape form so the editor /
+// formatter can't silently strip the literal.
+const UTF8_BOM = "\uFEFF";
+// `ignoreBOM: true` here means "pass the BOM through to the decoded string,
+// don't strip it" — cascade arm 1 must see the BOM to flag it.
+const decoder = new TextDecoder("utf-8", { fatal: false, ignoreBOM: true });
+export const frontmatterParseableRule = {
+    id: RULE_ID,
+    description: "SKILL.md frontmatter is a valid YAML mapping.",
+    kind: "advisory",
+    severity: "error",
+    check: (context) => Effect.gen(function* () {
+        const exists = yield* context.files.exists(SKILL_MD);
+        if (!exists) {
+            // Presence is covered by `skill/skill-md-present`.
+            return [];
+        }
+        const bytesResult = yield* context.files.readBytes(SKILL_MD).pipe(Effect.map((bytes) => ({ kind: "ok", bytes })), 
+        // Treat read errors the same as absence — presence rule already owns
+        // that path. If `exists` said true but read fails, the cascade can't
+        // run anyway; silence here keeps the finding count at one.
+        Effect.catch(() => Effect.succeed({ kind: "none" })));
+        if (bytesResult.kind === "none") {
+            return [];
+        }
+        const content = decoder.decode(bytesResult.bytes);
+        return evaluateCascade(content);
+    }),
+};
+// -----------------------------------------------------------------------------
+// Cascade
+// -----------------------------------------------------------------------------
+const evaluateCascade = (content) => {
+    const leading = detectLeadingBytes(content);
+    if (leading !== undefined) {
+        return [leading];
+    }
+    const parsed = parseFrontmatterYaml(content);
+    if (parsed === undefined) {
+        // No frontmatter block. Treat as bad (cascade arm 1 "begins with ---"
+        // already handled the "literally no ---" case; reaching here means the
+        // delimiter was found but the closing delimiter is missing).
+        return [
+            finding("SKILL.md frontmatter is malformed because the closing `---` delimiter is missing. Add a closing `---` after the frontmatter block."),
+        ];
+    }
+    if (parsed.kind === "parse-error") {
+        return [
+            finding(`SKILL.md frontmatter YAML is invalid. Detail: ${parsed.message}. Fix the YAML syntax in the frontmatter block.`),
+        ];
+    }
+    if (!isMapping(parsed.value)) {
+        return [
+            finding("SKILL.md frontmatter must be a YAML mapping, not a list or scalar. Rewrite the frontmatter block in `SKILL.md` as `key: value` pairs."),
+        ];
+    }
+    return [];
+};
+// -----------------------------------------------------------------------------
+// Arm 1: leading bytes before `---`
+// -----------------------------------------------------------------------------
+const detectLeadingBytes = (content) => {
+    if (content.startsWith(UTF8_BOM)) {
+        return finding("SKILL.md starts with a UTF-8 BOM before the frontmatter delimiter. Remove the BOM so the file starts with `---`.", { line: 1 });
+    }
+    if (content.startsWith(DELIMITER)) {
+        return undefined;
+    }
+    // Any non-`---` leading content is a cascade-arm-1 violation. Detect the
+    // common HTML-comment case explicitly so the finding message is clear.
+    if (/^\s*<!--/.test(content)) {
+        return finding("SKILL.md starts with an HTML comment before the frontmatter delimiter. Move or remove the comment so the file starts with `---`.", { line: 1 });
+    }
+    return finding("SKILL.md must start with the frontmatter delimiter `---`. Remove any leading content so the file starts with `---`.", { line: 1 });
+};
+const parseFrontmatterYaml = (content) => {
+    // content starts with `---` (arm 1 guaranteed). Find closing delimiter on a
+    // new line.
+    const afterOpening = content.indexOf("\n");
+    if (afterOpening === -1) {
+        return undefined;
+    }
+    const closingIndex = content.indexOf(`\n${DELIMITER}`, afterOpening);
+    if (closingIndex === -1) {
+        return undefined;
+    }
+    const yamlContent = content.slice(afterOpening + 1, closingIndex);
+    try {
+        // YAML.parse returns `null | undefined` for empty input; we care about
+        // shape, not emptiness at this arm.
+        const value = YAML.parse(yamlContent);
+        return { kind: "parsed", value };
+    }
+    catch (error) {
+        return {
+            kind: "parse-error",
+            message: error instanceof Error ? error.message : String(error),
+        };
+    }
+};
+const isMapping = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+// -----------------------------------------------------------------------------
+// Finding helpers
+// -----------------------------------------------------------------------------
+const finding = (message, position) => ({
+    kind: "advisory",
+    ruleId: RULE_ID,
+    severity: "error",
+    message,
+    location: {
+        file: SKILL_MD,
+        ...(position?.line !== undefined ? { line: position.line } : {}),
+        ...(position?.column !== undefined ? { column: position.column } : {}),
+    },
+});
+//# sourceMappingURL=frontmatter-parseable.js.map

package/dist/src/lint/catalog/skill/frontmatter-standard-valid.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `skill/frontmatter-standard-valid` — SKILL.md metadata conforms to the
+ * pinned Agent Skills specification and reference validator.
+ *
+ * Parsing failures are owned by `skill/frontmatter-parseable`; this rule
+ * returns no findings until the frontmatter is a YAML mapping.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import type { SkillRuleContext } from "../../context.js";
+import type { AdvisoryRule } from "../../rule.js";
+export declare const frontmatterStandardValidRule: AdvisoryRule<SkillRuleContext>;
+//# sourceMappingURL=frontmatter-standard-valid.d.ts.map

package/dist/src/lint/catalog/skill/frontmatter-standard-valid.js

@@ -0,0 +1,61 @@
+/**
+ * `skill/frontmatter-standard-valid` — SKILL.md metadata conforms to the
+ * pinned Agent Skills specification and reference validator.
+ *
+ * Parsing failures are owned by `skill/frontmatter-parseable`; this rule
+ * returns no findings until the frontmatter is a YAML mapping.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import YAML from "yaml";
+import { validateSkillFrontmatter } from "../../../content/skill-content.js";
+const RULE_ID = "skill/frontmatter-standard-valid";
+const SKILL_MD = "SKILL.md";
+const decoder = new TextDecoder("utf-8", { fatal: false, ignoreBOM: true });
+const parseFrontmatterMapping = (content) => {
+    if (!content.startsWith("---"))
+        return undefined;
+    const openingEnd = content.indexOf("\n");
+    if (openingEnd === -1)
+        return undefined;
+    const closingStart = content.indexOf("\n---", openingEnd);
+    if (closingStart === -1)
+        return undefined;
+    try {
+        const parsed = YAML.parse(content.slice(openingEnd + 1, closingStart));
+        return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+const finding = (message) => ({
+    kind: "advisory",
+    ruleId: RULE_ID,
+    severity: "error",
+    message,
+    location: { file: SKILL_MD, line: 1 },
+});
+export const frontmatterStandardValidRule = {
+    id: RULE_ID,
+    description: "SKILL.md metadata conforms to the pinned Agent Skills standard.",
+    kind: "advisory",
+    severity: "error",
+    check: (context) => Effect.gen(function* () {
+        const exists = yield* context.files.exists(SKILL_MD);
+        if (!exists)
+            return [];
+        const content = yield* context.files.readBytes(SKILL_MD).pipe(Effect.map((bytes) => decoder.decode(bytes)), Effect.catch(() => Effect.succeed(undefined)));
+        if (content === undefined)
+            return [];
+        const parsed = parseFrontmatterMapping(content);
+        if (parsed === undefined)
+            return [];
+        const validation = validateSkillFrontmatter(parsed, context.subject.expectedName);
+        return validation.valid ? [] : validation.errors.map(finding);
+    }),
+};
+//# sourceMappingURL=frontmatter-standard-valid.js.map

package/dist/src/lint/catalog/skill/manifest-keys-recognized.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `skill/manifest-keys-recognized` — `skill.json` contains only keys
+ * declared by `SkillManifestSchema`.
+ *
+ * The paired `-schema-valid` rule ignores excess properties by construction
+ * (`onExcessProperty: "ignore"`); this rule rejects them so publish never
+ * silently drops unrecognized manifest data.
+ *
+ * Allowed-keys set is derived from `SkillManifestSchema.fields` — no
+ * copy-paste of field names. A schema gain (or rename) automatically updates
+ * the allowlist.
+ *
+ * Early-return arms (no findings):
+ *
+ * - `subject.isNative === false` — non-native skills have no manifest to
+ *   check.
+ * - `subject.skillJson === undefined` / non-object — nothing to enumerate;
+ *   `skill/manifest-present` owns the absence case.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { SkillRuleContext } from "../../context.js";
+import type { AdvisoryRule } from "../../rule.js";
+export declare const manifestKeysRecognizedRule: AdvisoryRule<SkillRuleContext>;
+//# sourceMappingURL=manifest-keys-recognized.d.ts.map

package/dist/src/lint/catalog/skill/manifest-keys-recognized.js

@@ -0,0 +1,41 @@
+/**
+ * `skill/manifest-keys-recognized` — `skill.json` contains only keys
+ * declared by `SkillManifestSchema`.
+ *
+ * The paired `-schema-valid` rule ignores excess properties by construction
+ * (`onExcessProperty: "ignore"`); this rule rejects them so publish never
+ * silently drops unrecognized manifest data.
+ *
+ * Allowed-keys set is derived from `SkillManifestSchema.fields` — no
+ * copy-paste of field names. A schema gain (or rename) automatically updates
+ * the allowlist.
+ *
+ * Early-return arms (no findings):
+ *
+ * - `subject.isNative === false` — non-native skills have no manifest to
+ *   check.
+ * - `subject.skillJson === undefined` / non-object — nothing to enumerate;
+ *   `skill/manifest-present` owns the absence case.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+import { SkillManifestSchema } from "@agentxm/extension-model/unstable/skills/manifest-schema";
+import { enumerateUnknownTopLevelKeys, structFieldKeys } from "../shared/schema-rule.js";
+const RULE_ID = "skill/manifest-keys-recognized";
+const SKILL_JSON = "skill.json";
+const allowedKeys = structFieldKeys(SkillManifestSchema);
+export const manifestKeysRecognizedRule = {
+    id: RULE_ID,
+    description: "skill.json uses only supported top-level fields.",
+    kind: "advisory",
+    severity: "error",
+    check: (context) => {
+        if (!context.subject.isNative) {
+            return Effect.succeed([]);
+        }
+        return Effect.succeed(enumerateUnknownTopLevelKeys(RULE_ID, "error", SKILL_JSON, allowedKeys, context.subject.skillJson));
+    },
+};
+//# sourceMappingURL=manifest-keys-recognized.js.map

package/dist/src/lint/catalog/skill/manifest-present.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `skill/manifest-present` — native skills must have a `skill.json` at the
+ * package root.
+ *
+ * Reads through `context.packageFiles` (package-root accessor) rather than
+ * `context.files` (content-root accessor). For native skills, the package
+ * root contains `skill.json` and a `src/` directory holding the skill
+ * content; `context.files` is rooted at `src/`, so `skill.json` is only
+ * reachable via `packageFiles`.
+ *
+ * Native-only via `check` early-return: when `subject.isNative === false`
+ * (managed-external skills without a declared manifest), the rule produces
+ * no findings. No separate `applies` predicate per
+ * the lint design.
+ *
+ * Advisory-only — scaffolding a manifest is a user-authored action.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { SkillRuleContext } from "../../context.js";
+export declare const manifestPresentRule: import("../../rule.ts").AdvisoryRule<SkillRuleContext<import("../../context.js").SkillContent>>;
+//# sourceMappingURL=manifest-present.d.ts.map

package/dist/src/lint/catalog/skill/manifest-present.js

@@ -0,0 +1,32 @@
+/**
+ * `skill/manifest-present` — native skills must have a `skill.json` at the
+ * package root.
+ *
+ * Reads through `context.packageFiles` (package-root accessor) rather than
+ * `context.files` (content-root accessor). For native skills, the package
+ * root contains `skill.json` and a `src/` directory holding the skill
+ * content; `context.files` is rooted at `src/`, so `skill.json` is only
+ * reachable via `packageFiles`.
+ *
+ * Native-only via `check` early-return: when `subject.isNative === false`
+ * (managed-external skills without a declared manifest), the rule produces
+ * no findings. No separate `applies` predicate per
+ * the lint design.
+ *
+ * Advisory-only — scaffolding a manifest is a user-authored action.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import { makeManifestPresentRule } from "../shared/manifest-present.js";
+const RULE_ID = "skill/manifest-present";
+const SKILL_JSON = "skill.json";
+export const manifestPresentRule = makeManifestPresentRule({
+    ruleId: RULE_ID,
+    description: "Native skills include a root skill.json manifest.",
+    manifestFile: SKILL_JSON,
+    missingMessage: "skill.json is missing for this native skill. Create skill.json with the required manifest fields (`owner`, `type`, `name`, `version`).",
+    getFiles: (context) => context.packageFiles,
+    applies: (context) => context.subject.isNative,
+});
+//# sourceMappingURL=manifest-present.js.map

package/dist/src/lint/catalog/skill/manifest-schema-valid.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `skill/manifest-schema-valid` — `skill.json` conforms to
+ * `SkillManifestSchema`.
+ *
+ * Delegates to Effect Schema. Issues map 1:1 to findings via
+ * `issuesToFindings`.
+ *
+ * Early-return arms (no findings):
+ *
+ * - `subject.isNative === false` — non-native skills have no manifest to
+ *   check (complement of `skill/manifest-present`).
+ * - `subject.skillJson === undefined` — manifest is absent (covered by
+ *   `skill/manifest-present`).
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { SkillRuleContext } from "../../context.js";
+import type { AdvisoryRule } from "../../rule.js";
+export declare const manifestSchemaValidRule: AdvisoryRule<SkillRuleContext>;
+//# sourceMappingURL=manifest-schema-valid.d.ts.map

package/dist/src/lint/catalog/skill/manifest-schema-valid.js

@@ -0,0 +1,36 @@
+/**
+ * `skill/manifest-schema-valid` — `skill.json` conforms to
+ * `SkillManifestSchema`.
+ *
+ * Delegates to Effect Schema. Issues map 1:1 to findings via
+ * `issuesToFindings`.
+ *
+ * Early-return arms (no findings):
+ *
+ * - `subject.isNative === false` — non-native skills have no manifest to
+ *   check (complement of `skill/manifest-present`).
+ * - `subject.skillJson === undefined` — manifest is absent (covered by
+ *   `skill/manifest-present`).
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import { SkillManifestSchema } from "@agentxm/extension-model/unstable/skills/manifest-schema";
+import { schemaDecodeFindings } from "../shared/schema-rule.js";
+const RULE_ID = "skill/manifest-schema-valid";
+const SKILL_JSON = "skill.json";
+export const manifestSchemaValidRule = {
+    id: RULE_ID,
+    description: "skill.json defines a valid skill manifest.",
+    kind: "advisory",
+    severity: "error",
+    check: (context) => {
+        if (!context.subject.isNative) {
+            // Non-native skills have no skill.json to schema-validate. The
+            // presence rule (manifest-present) does not fire for non-native either.
+            return schemaDecodeFindings(RULE_ID, "error", SKILL_JSON, SkillManifestSchema, undefined);
+        }
+        return schemaDecodeFindings(RULE_ID, "error", SKILL_JSON, SkillManifestSchema, context.subject.skillJson);
+    },
+};
+//# sourceMappingURL=manifest-schema-valid.js.map

package/dist/src/lint/catalog/skill/recommended-packs-valid.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `skill/recommended-packs-valid` — recommended packs are bare FQNs, never
+ * version-ranged specs. See `../shared/recommended-packs-rules.ts`.
+ */
+import type { SkillRuleContext } from "../../context.js";
+import type { AdvisoryRule } from "../../rule.js";
+export declare const recommendedPacksValidRule: AdvisoryRule<SkillRuleContext>;
+//# sourceMappingURL=recommended-packs-valid.d.ts.map

package/dist/src/lint/catalog/skill/recommended-packs-valid.js

@@ -0,0 +1,12 @@
+/**
+ * `skill/recommended-packs-valid` — recommended packs are bare FQNs, never
+ * version-ranged specs. See `../shared/recommended-packs-rules.ts`.
+ */
+import { MANIFEST_FILENAME } from "@agentxm/extension-model/unstable/skills/manifest-schema";
+import { makeRecommendedPacksValidRule } from "../shared/recommended-packs-rules.js";
+export const recommendedPacksValidRule = makeRecommendedPacksValidRule({
+    namespace: "skill",
+    manifestFile: MANIFEST_FILENAME,
+    manifestJson: (context) => context.subject.skillJson,
+});
+//# sourceMappingURL=recommended-packs-valid.js.map

package/dist/src/lint/catalog/skill/skill-md-present.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `skill/skill-md-present` — every skill must have a `SKILL.md` at its root.
+ *
+ * Applies to every skill context (native and non-native). Upstream-required
+ * by the agentskills specification; also the precondition for the
+ * `skill/frontmatter-parseable` cascade.
+ *
+ * Advisory-only (no autofix). Scaffolding `SKILL.md` requires user-authored
+ * content and is not a meaning-preserving normalization.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { SkillRuleContext } from "../../context.js";
+import type { AdvisoryRule } from "../../rule.js";
+export declare const skillMdPresentRule: AdvisoryRule<SkillRuleContext>;
+//# sourceMappingURL=skill-md-present.d.ts.map

package/dist/src/lint/catalog/skill/skill-md-present.js

@@ -0,0 +1,37 @@
+/**
+ * `skill/skill-md-present` — every skill must have a `SKILL.md` at its root.
+ *
+ * Applies to every skill context (native and non-native). Upstream-required
+ * by the agentskills specification; also the precondition for the
+ * `skill/frontmatter-parseable` cascade.
+ *
+ * Advisory-only (no autofix). Scaffolding `SKILL.md` requires user-authored
+ * content and is not a meaning-preserving normalization.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+const RULE_ID = "skill/skill-md-present";
+const SKILL_MD = "SKILL.md";
+export const skillMdPresentRule = {
+    id: RULE_ID,
+    description: "Skills include a root SKILL.md file.",
+    kind: "advisory",
+    severity: "error",
+    check: (context) => Effect.map(context.files.exists(SKILL_MD), (present) => {
+        if (present) {
+            return [];
+        }
+        return [
+            {
+                kind: "advisory",
+                ruleId: RULE_ID,
+                severity: "error",
+                message: "SKILL.md is missing. Create SKILL.md with the required frontmatter (`name`, `description`).",
+                location: { file: SKILL_MD },
+            },
+        ];
+    }),
+};
+//# sourceMappingURL=skill-md-present.js.map

package/dist/src/lint/catalog/skill/standalone-declaration-valid.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `skill/standalone-declaration-valid` — a manifest that opts out of standalone
+ * use names the packs it needs. See `../shared/recommended-packs-rules.ts`.
+ */
+import type { SkillRuleContext } from "../../context.js";
+import type { AdvisoryRule } from "../../rule.js";
+export declare const standaloneDeclarationValidRule: AdvisoryRule<SkillRuleContext>;
+//# sourceMappingURL=standalone-declaration-valid.d.ts.map

package/dist/src/lint/catalog/skill/standalone-declaration-valid.js

@@ -0,0 +1,12 @@
+/**
+ * `skill/standalone-declaration-valid` — a manifest that opts out of standalone
+ * use names the packs it needs. See `../shared/recommended-packs-rules.ts`.
+ */
+import { MANIFEST_FILENAME } from "@agentxm/extension-model/unstable/skills/manifest-schema";
+import { makeStandaloneDeclarationValidRule } from "../shared/recommended-packs-rules.js";
+export const standaloneDeclarationValidRule = makeStandaloneDeclarationValidRule({
+    namespace: "skill",
+    manifestFile: MANIFEST_FILENAME,
+    manifestJson: (context) => context.subject.skillJson,
+});
+//# sourceMappingURL=standalone-declaration-valid.js.map