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

package/dist/src/lint/catalog/skill-accessor/contexts.d.ts

@@ -0,0 +1,61 @@
+/**
+ * `buildSkillRuleContexts` — build `SkillRuleContext[]` from a structural
+ * `installedSkills` input. The full lint workspace view
+ * (`LintWorkspaceView`) satisfies this by construction.
+ *
+ * The minimal shape is **exactly** the set of fields the function reads per
+ * installed skill:
+ *
+ * - `isNative` — whether the skill is expected to expose `skill.json`
+ *   (registry-installed natives: `true`; managed external: `false`).
+ * - `skillJson` — pre-decoded `skill.json` when present (caller decodes
+ *   once per skill, so rules don't re-read + re-parse).
+ * - `displayRoot` — posix-relative root used by the renderer; the caller
+ *   picks per provenance (see the table below).
+ * - `files` — the pre-bound content-root `SkillFileAccessor` (rooted at the
+ *   directory containing `SKILL.md`). The caller chooses VFT or
+ *   platform-backed.
+ * - `packageFiles` — the pre-bound package-root `SkillFileAccessor` (rooted
+ *   at the directory containing `skill.json` for native skills). For
+ *   non-native skills, callers MAY alias `files`.
+ *
+ * Provenance → `displayRoot` table:
+ *
+ * | Surface                                   | `displayRoot`                                 |
+ * | ----------------------------------------- | --------------------------------------------- |
+ * | Publish                                   | `""`                                          |
+ * | Registry-installed native skill           | `agent_extensions/<source>/<@owner>/skills/<name>/src` |
+ * | Portable acquired skill                   | `agent_extensions/<source>/<source-full-name>`         |
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { SkillFileAccessor, SkillRuleContext } from "../../context.js";
+/**
+ * Minimal structural shape `buildSkillRuleContexts` needs per installed
+ * skill. The full lint workspace view exposes
+ * `installedSkills: ReadonlyArray<InstalledSkillInfo>`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export interface InstalledSkillInfo {
+    readonly isNative: boolean;
+    readonly skillJson: unknown;
+    readonly expectedName?: string;
+    readonly displayRoot: string;
+    readonly files: SkillFileAccessor;
+    readonly packageFiles: SkillFileAccessor;
+}
+/**
+ * Project an input's `installedSkills` into `SkillRuleContext`s with their
+ * `displayRoot` and `subject` fields pre-populated.
+ *
+ * Publish callers bypass this helper and construct a single context directly
+ * — they have exactly one skill in play and no workspace.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const buildSkillRuleContexts: (input: {
+    readonly installedSkills: ReadonlyArray<InstalledSkillInfo>;
+}) => ReadonlyArray<SkillRuleContext>;
+//# sourceMappingURL=contexts.d.ts.map

package/dist/src/lint/catalog/skill-accessor/contexts.js

@@ -0,0 +1,55 @@
+/**
+ * `buildSkillRuleContexts` — build `SkillRuleContext[]` from a structural
+ * `installedSkills` input. The full lint workspace view
+ * (`LintWorkspaceView`) satisfies this by construction.
+ *
+ * The minimal shape is **exactly** the set of fields the function reads per
+ * installed skill:
+ *
+ * - `isNative` — whether the skill is expected to expose `skill.json`
+ *   (registry-installed natives: `true`; managed external: `false`).
+ * - `skillJson` — pre-decoded `skill.json` when present (caller decodes
+ *   once per skill, so rules don't re-read + re-parse).
+ * - `displayRoot` — posix-relative root used by the renderer; the caller
+ *   picks per provenance (see the table below).
+ * - `files` — the pre-bound content-root `SkillFileAccessor` (rooted at the
+ *   directory containing `SKILL.md`). The caller chooses VFT or
+ *   platform-backed.
+ * - `packageFiles` — the pre-bound package-root `SkillFileAccessor` (rooted
+ *   at the directory containing `skill.json` for native skills). For
+ *   non-native skills, callers MAY alias `files`.
+ *
+ * Provenance → `displayRoot` table:
+ *
+ * | Surface                                   | `displayRoot`                                 |
+ * | ----------------------------------------- | --------------------------------------------- |
+ * | Publish                                   | `""`                                          |
+ * | Registry-installed native skill           | `agent_extensions/<source>/<@owner>/skills/<name>/src` |
+ * | Portable acquired skill                   | `agent_extensions/<source>/<source-full-name>`         |
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+// -----------------------------------------------------------------------------
+// buildSkillRuleContexts
+// -----------------------------------------------------------------------------
+/**
+ * Project an input's `installedSkills` into `SkillRuleContext`s with their
+ * `displayRoot` and `subject` fields pre-populated.
+ *
+ * Publish callers bypass this helper and construct a single context directly
+ * — they have exactly one skill in play and no workspace.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const buildSkillRuleContexts = (input) => input.installedSkills.map((info) => ({
+    subject: {
+        isNative: info.isNative,
+        skillJson: info.skillJson,
+        ...(info.expectedName === undefined ? {} : { expectedName: info.expectedName }),
+    },
+    files: info.files,
+    packageFiles: info.packageFiles,
+    displayRoot: info.displayRoot,
+}));
+//# sourceMappingURL=contexts.js.map

package/dist/src/lint/catalog/skill-accessor/platform.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Platform-backed `SkillFileAccessor` for `axm lint`.
+ *
+ * Maps accessor-relative posix paths to on-disk absolute paths rooted at
+ * the caller-supplied skill-root directory. Layout conventions per
+ * the lint design "Skill accessor root":
+ *
+ * - **Native acquired package:** the source-qualified package's `src/` directory.
+ * - **Portable Agent Skill:** the source-qualified selected package directory.
+ *
+ * The accessor is provenance-agnostic — rules see one uniform contract and
+ * never branch on native-vs-non-native. The caller (`buildSkillRuleContexts`
+ * or the CLI entry point) picks the root.
+ *
+ * Bounds enforcement:
+ *
+ * - No `..` segments in accessor-relative paths.
+ * - No absolute paths (posix or Windows drive letters).
+ * - Resolved absolute paths are verified to stay under the accessor root.
+ *
+ * The accessor is built via a factory that captures a pre-resolved
+ * `FileSystem.FileSystem` + `Path.Path` services and an absolute root, so
+ * `SkillFileAccessor` stays Layer-free at rule-evaluation time (per
+ * `lint-engine` spec "Rule contexts expose narrow caller-bound accessors").
+ * It mirrors the VFT-backed accessor in `./vft.ts`; the two are the only
+ * `SkillFileAccessor` implementations, one for on-disk roots and one for an
+ * extracted archive.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type * as FileSystem from "effect/FileSystem";
+import type * as Path from "effect/Path";
+import type { SkillFileAccessor } from "../../context.js";
+/**
+ * Platform services needed by the platform-backed skill accessor.
+ */
+export interface SkillAccessorPlatform {
+    readonly fs: FileSystem.FileSystem;
+    readonly path: Path.Path;
+}
+/**
+ * Build a platform-backed `SkillFileAccessor` rooted at `absoluteRoot`.
+ *
+ * `absoluteRoot` SHOULD be the absolute path to the skill root directory
+ * (either `.../src/` for native, or the selected package directory for a
+ * portable Agent Skill). The caller typically sources it from
+ * `computeSkillPathsForLayout` in `@agentxm/workspace-state`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const makePlatformSkillFileAccessor: (platform: SkillAccessorPlatform, absoluteRoot: string) => SkillFileAccessor;
+//# sourceMappingURL=platform.d.ts.map

package/dist/src/lint/catalog/skill-accessor/platform.js

@@ -0,0 +1,90 @@
+/**
+ * Platform-backed `SkillFileAccessor` for `axm lint`.
+ *
+ * Maps accessor-relative posix paths to on-disk absolute paths rooted at
+ * the caller-supplied skill-root directory. Layout conventions per
+ * the lint design "Skill accessor root":
+ *
+ * - **Native acquired package:** the source-qualified package's `src/` directory.
+ * - **Portable Agent Skill:** the source-qualified selected package directory.
+ *
+ * The accessor is provenance-agnostic — rules see one uniform contract and
+ * never branch on native-vs-non-native. The caller (`buildSkillRuleContexts`
+ * or the CLI entry point) picks the root.
+ *
+ * Bounds enforcement:
+ *
+ * - No `..` segments in accessor-relative paths.
+ * - No absolute paths (posix or Windows drive letters).
+ * - Resolved absolute paths are verified to stay under the accessor root.
+ *
+ * The accessor is built via a factory that captures a pre-resolved
+ * `FileSystem.FileSystem` + `Path.Path` services and an absolute root, so
+ * `SkillFileAccessor` stays Layer-free at rule-evaluation time (per
+ * `lint-engine` spec "Rule contexts expose narrow caller-bound accessors").
+ * It mirrors the VFT-backed accessor in `./vft.ts`; the two are the only
+ * `SkillFileAccessor` implementations, one for on-disk roots and one for an
+ * extracted archive.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+/**
+ * Build a platform-backed `SkillFileAccessor` rooted at `absoluteRoot`.
+ *
+ * `absoluteRoot` SHOULD be the absolute path to the skill root directory
+ * (either `.../src/` for native, or the selected package directory for a
+ * portable Agent Skill). The caller typically sources it from
+ * `computeSkillPathsForLayout` in `@agentxm/workspace-state`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const makePlatformSkillFileAccessor = (platform, absoluteRoot) => {
+    const { fs, path } = platform;
+    const normalizedRoot = path.resolve(absoluteRoot);
+    const resolveWithinRoot = (input) => {
+        if (input === "" || input === "." || input === "./") {
+            return { kind: "ok", absolute: normalizedRoot };
+        }
+        if (/^[a-z]:[\\/]/i.test(input) || input.startsWith("/") || input.startsWith("\\")) {
+            return { kind: "escape" };
+        }
+        const normalized = input.replace(/\\/g, "/").replace(/^\.\//, "");
+        for (const segment of normalized.split("/")) {
+            if (segment === "..") {
+                return { kind: "escape" };
+            }
+        }
+        const absolute = path.resolve(normalizedRoot, normalized);
+        if (absolute !== normalizedRoot && !absolute.startsWith(`${normalizedRoot}${path.sep}`)) {
+            return { kind: "escape" };
+        }
+        return { kind: "ok", absolute };
+    };
+    const makeAccessError = (p, reason, message) => ({
+        _tag: "FileAccessError",
+        path: p,
+        reason,
+        message,
+    });
+    return {
+        exists: (p) => {
+            const resolved = resolveWithinRoot(p);
+            if (resolved.kind !== "ok") {
+                return Effect.succeed(false);
+            }
+            return fs.exists(resolved.absolute).pipe(Effect.catch(() => Effect.succeed(false)));
+        },
+        readBytes: (p) => {
+            const resolved = resolveWithinRoot(p);
+            if (resolved.kind === "escape") {
+                return Effect.fail(makeAccessError(p, "path-escape", `path escapes the accessor root: ${p}`));
+            }
+            return fs
+                .readFile(resolved.absolute)
+                .pipe(Effect.mapError((cause) => makeAccessError(p, "read-error", `read failed at ${p}: ${String(cause)}`)));
+        },
+    };
+};
+//# sourceMappingURL=platform.js.map

package/dist/src/lint/catalog/skill-accessor/vft.d.ts

@@ -0,0 +1,77 @@
+/**
+ * VFT-backed `SkillFileAccessor` for publish callers.
+ *
+ * A Virtual File Tree (VFT) is an in-memory representation of an extracted
+ * archive — the registry publish pipeline extracts an upload into a VFT, then
+ * passes that tree into Phase 4 decode/lint. The VFT's schema and bounds
+ * (max size, file count, path depth) are owned by the registry extract phase
+ * (Phase 4 concern); this accessor treats the tree as a read-only
+ * `path -> Uint8Array` map and enforces its own rooted-read + no-`..`-escape
+ * invariants at the rule boundary.
+ *
+ * Bounds enforcement here:
+ *
+ * - Paths are normalized to posix, `./` prefixes are stripped.
+ * - Empty path resolves to the accessor root itself (useful for
+ *   `location.file = ""` findings but not currently exercised by the v1
+ *   catalog).
+ * - Any path containing a `..` segment raises `FileAccessError {
+ *   reason: "path-escape" }` from `readBytes` and resolves to `false` from
+ *   `exists`.
+ * - Absolute paths (starting with `/` or a Windows drive letter) are
+ *   treated as escape attempts.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { SkillFileAccessor } from "../../context.js";
+/**
+ * Minimal shape of a Virtual File Tree consumed by the accessor.
+ *
+ * The registry VFT (Phase 4, this-repo) MUST satisfy this interface. The
+ * registry may (and will) expose additional methods — file count, archive
+ * bounds, iteration — but those are the extract phase's concern.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export interface VFTNode {
+    /**
+     * Whether the given posix path points to a file within the tree.
+     */
+    readonly hasFile: (posixPath: string) => boolean;
+    /**
+     * Return the bytes for the given posix path, or `undefined` when the path
+     * does not resolve to a file (missing, directory, or outside the tree).
+     */
+    readonly getFile: (posixPath: string) => Uint8Array | undefined;
+}
+/**
+ * Build a VFT-backed `SkillFileAccessor` rooted at the tree's root.
+ *
+ * Callers that root the skill at a sub-path of the archive should pre-strip
+ * that sub-path before constructing the tree — the accessor enforces no
+ * `..` escape above the root it was given.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const makeVftSkillFileAccessor: (tree: VFTNode) => SkillFileAccessor;
+/**
+ * Build a VFT-backed `SkillFileAccessor` rooted at a sub-path of the tree.
+ *
+ * Publish callers use this when the archive layout nests the skill content
+ * under a directory (for native managed skills: `src/` holds the content
+ * accessor root while the archive root holds the package). The
+ * `prefix` is a posix path relative to the tree root; every rule-supplied
+ * path is resolved as `<prefix>/<path>` before dispatching to the tree.
+ *
+ * Bounds enforcement matches {@link makeVftSkillFileAccessor} — path traversal
+ * checks run on the caller-supplied path before the prefix is applied, so
+ * rules still cannot escape above the scoped root.
+ *
+ * The prefix itself is normalized posix (leading `./` and trailing `/` stripped);
+ * an empty or `.` prefix is equivalent to {@link makeVftSkillFileAccessor}.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const makeVftSkillFileAccessorScoped: (tree: VFTNode, prefix: string) => SkillFileAccessor;
+//# sourceMappingURL=vft.d.ts.map

package/dist/src/lint/catalog/skill-accessor/vft.js

@@ -0,0 +1,135 @@
+/**
+ * VFT-backed `SkillFileAccessor` for publish callers.
+ *
+ * A Virtual File Tree (VFT) is an in-memory representation of an extracted
+ * archive — the registry publish pipeline extracts an upload into a VFT, then
+ * passes that tree into Phase 4 decode/lint. The VFT's schema and bounds
+ * (max size, file count, path depth) are owned by the registry extract phase
+ * (Phase 4 concern); this accessor treats the tree as a read-only
+ * `path -> Uint8Array` map and enforces its own rooted-read + no-`..`-escape
+ * invariants at the rule boundary.
+ *
+ * Bounds enforcement here:
+ *
+ * - Paths are normalized to posix, `./` prefixes are stripped.
+ * - Empty path resolves to the accessor root itself (useful for
+ *   `location.file = ""` findings but not currently exercised by the v1
+ *   catalog).
+ * - Any path containing a `..` segment raises `FileAccessError {
+ *   reason: "path-escape" }` from `readBytes` and resolves to `false` from
+ *   `exists`.
+ * - Absolute paths (starting with `/` or a Windows drive letter) are
+ *   treated as escape attempts.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+/**
+ * Build a VFT-backed `SkillFileAccessor` rooted at the tree's root.
+ *
+ * Callers that root the skill at a sub-path of the archive should pre-strip
+ * that sub-path before constructing the tree — the accessor enforces no
+ * `..` escape above the root it was given.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const makeVftSkillFileAccessor = (tree) => {
+    return {
+        exists: (path) => {
+            const normalized = normalizeAndCheck(path);
+            if (normalized.kind !== "ok") {
+                return Effect.succeed(false);
+            }
+            return Effect.succeed(tree.hasFile(normalized.path));
+        },
+        readBytes: (path) => {
+            const normalized = normalizeAndCheck(path);
+            if (normalized.kind === "escape") {
+                return failFileAccess(path, "path-escape", `path escapes the accessor root: ${path}`);
+            }
+            const bytes = tree.getFile(normalized.path);
+            if (bytes === undefined) {
+                return failFileAccess(path, "read-error", `file not found at ${path}`);
+            }
+            return Effect.succeed(bytes);
+        },
+    };
+};
+/**
+ * Build a VFT-backed `SkillFileAccessor` rooted at a sub-path of the tree.
+ *
+ * Publish callers use this when the archive layout nests the skill content
+ * under a directory (for native managed skills: `src/` holds the content
+ * accessor root while the archive root holds the package). The
+ * `prefix` is a posix path relative to the tree root; every rule-supplied
+ * path is resolved as `<prefix>/<path>` before dispatching to the tree.
+ *
+ * Bounds enforcement matches {@link makeVftSkillFileAccessor} — path traversal
+ * checks run on the caller-supplied path before the prefix is applied, so
+ * rules still cannot escape above the scoped root.
+ *
+ * The prefix itself is normalized posix (leading `./` and trailing `/` stripped);
+ * an empty or `.` prefix is equivalent to {@link makeVftSkillFileAccessor}.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const makeVftSkillFileAccessorScoped = (tree, prefix) => {
+    const normalizedPrefix = normalizePrefix(prefix);
+    if (normalizedPrefix === "") {
+        return makeVftSkillFileAccessor(tree);
+    }
+    const join = (path) => path === "" ? normalizedPrefix : `${normalizedPrefix}/${path}`;
+    return {
+        exists: (path) => {
+            const normalized = normalizeAndCheck(path);
+            if (normalized.kind !== "ok") {
+                return Effect.succeed(false);
+            }
+            return Effect.succeed(tree.hasFile(join(normalized.path)));
+        },
+        readBytes: (path) => {
+            const normalized = normalizeAndCheck(path);
+            if (normalized.kind === "escape") {
+                return failFileAccess(path, "path-escape", `path escapes the accessor root: ${path}`);
+            }
+            const bytes = tree.getFile(join(normalized.path));
+            if (bytes === undefined) {
+                return failFileAccess(path, "read-error", `file not found at ${path}`);
+            }
+            return Effect.succeed(bytes);
+        },
+    };
+};
+const normalizePrefix = (prefix) => {
+    const stripped = prefix.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
+    if (stripped === "" || stripped === ".") {
+        return "";
+    }
+    return stripped;
+};
+const normalizeAndCheck = (path) => {
+    if (path === "" || path === "." || path === "./") {
+        return { kind: "ok", path: "" };
+    }
+    // Windows drive letters (`C:/`) and absolute posix paths both count as
+    // escape attempts at a skill-rooted accessor.
+    if (/^[a-z]:[\\/]/i.test(path) || path.startsWith("/") || path.startsWith("\\")) {
+        return { kind: "escape" };
+    }
+    const normalized = path.replace(/\\/g, "/").replace(/^\.\//, "");
+    const segments = normalized.split("/");
+    for (const segment of segments) {
+        if (segment === "..") {
+            return { kind: "escape" };
+        }
+    }
+    return { kind: "ok", path: normalized };
+};
+const failFileAccess = (path, reason, message) => Effect.fail({
+    _tag: "FileAccessError",
+    path,
+    reason,
+    message,
+});
+//# sourceMappingURL=vft.js.map

package/dist/src/lint/catalog/skill.d.ts

@@ -0,0 +1,38 @@
+/**
+ * `skill/*` rule catalog.
+ *
+ * Per the lint design, registry publish and `axm lint`
+ * run exactly these rules against each skill context:
+ *
+ * | ID                                     | Severity | Autofix |
+ * | -------------------------------------- | -------- | ------- |
+ * | `skill/skill-md-present`               | error    | —       |
+ * | `skill/manifest-present`               | error    | —       |
+ * | `skill/frontmatter-parseable`          | error    | —       |
+ * | `skill/frontmatter-standard-valid`      | error    | —       |
+ * | `skill/manifest-schema-valid`          | error    | —       |
+ * | `skill/manifest-keys-recognized`       | error    | —       |
+ * | `skill/standalone-declaration-valid`   | warning  | —       |
+ * | `skill/recommended-packs-valid`        | warning  | —       |
+ *
+ * The last two come from `catalog/shared/recommended-packs-rules.ts`; every
+ * non-pack catalog applies the same pair against its own manifest.
+ *
+ * All ship `kind: "advisory"`. Native-vs-non-native applicability is
+ * expressed via `check` early-return (no separate `applies` predicate); see
+ * each rule's module for the guard.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { LintRule } from "../rule.js";
+import type { SkillRuleContext } from "../context.js";
+/**
+ * Ordered v1 `skill/*` rule catalog. Declaration order is the evaluation
+ * order within a single `evaluateContexts` call (deterministic ordering is
+ * test-observable; see `evaluate.ts`).
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const skillRules: ReadonlyArray<LintRule<SkillRuleContext>>;
+//# sourceMappingURL=skill.d.ts.map

package/dist/src/lint/catalog/skill.js

@@ -0,0 +1,53 @@
+/**
+ * `skill/*` rule catalog.
+ *
+ * Per the lint design, registry publish and `axm lint`
+ * run exactly these rules against each skill context:
+ *
+ * | ID                                     | Severity | Autofix |
+ * | -------------------------------------- | -------- | ------- |
+ * | `skill/skill-md-present`               | error    | —       |
+ * | `skill/manifest-present`               | error    | —       |
+ * | `skill/frontmatter-parseable`          | error    | —       |
+ * | `skill/frontmatter-standard-valid`      | error    | —       |
+ * | `skill/manifest-schema-valid`          | error    | —       |
+ * | `skill/manifest-keys-recognized`       | error    | —       |
+ * | `skill/standalone-declaration-valid`   | warning  | —       |
+ * | `skill/recommended-packs-valid`        | warning  | —       |
+ *
+ * The last two come from `catalog/shared/recommended-packs-rules.ts`; every
+ * non-pack catalog applies the same pair against its own manifest.
+ *
+ * All ship `kind: "advisory"`. Native-vs-non-native applicability is
+ * expressed via `check` early-return (no separate `applies` predicate); see
+ * each rule's module for the guard.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import { skillMdPresentRule } from "./skill/skill-md-present.js";
+import { manifestPresentRule } from "./skill/manifest-present.js";
+import { frontmatterParseableRule } from "./skill/frontmatter-parseable.js";
+import { frontmatterStandardValidRule } from "./skill/frontmatter-standard-valid.js";
+import { manifestSchemaValidRule } from "./skill/manifest-schema-valid.js";
+import { manifestKeysRecognizedRule } from "./skill/manifest-keys-recognized.js";
+import { recommendedPacksValidRule } from "./skill/recommended-packs-valid.js";
+import { standaloneDeclarationValidRule } from "./skill/standalone-declaration-valid.js";
+/**
+ * Ordered v1 `skill/*` rule catalog. Declaration order is the evaluation
+ * order within a single `evaluateContexts` call (deterministic ordering is
+ * test-observable; see `evaluate.ts`).
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const skillRules = [
+    skillMdPresentRule,
+    manifestPresentRule,
+    frontmatterParseableRule,
+    frontmatterStandardValidRule,
+    manifestSchemaValidRule,
+    manifestKeysRecognizedRule,
+    standaloneDeclarationValidRule,
+    recommendedPacksValidRule,
+];
+//# sourceMappingURL=skill.js.map

package/dist/src/lint/catalog/subagent/envelope.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `subagent/*` manifest envelope — see `../shared/envelope-rules.ts`.
+ */
+import type { SubagentRuleContext } from "../../context.js";
+export declare const subagentEnvelopeRules: import("../shared/envelope-rules.js").ManifestEnvelopeRules<SubagentRuleContext<import("../../context.js").SubagentContent>>;
+//# sourceMappingURL=envelope.d.ts.map

package/dist/src/lint/catalog/subagent/envelope.js

@@ -0,0 +1,15 @@
+/**
+ * `subagent/*` manifest envelope — see `../shared/envelope-rules.ts`.
+ */
+import { MANIFEST_FILENAME, SubagentManifestSchema, } from "@agentxm/extension-model/unstable/subagents/manifest-schema";
+import { makeManifestEnvelopeRules } from "../shared/envelope-rules.js";
+export const subagentEnvelopeRules = makeManifestEnvelopeRules({
+    namespace: "subagent",
+    manifestFile: MANIFEST_FILENAME,
+    schema: SubagentManifestSchema,
+    manifestJson: (context) => context.subject.subagentJson,
+    presentDescription: "Subagents include a root subagent.json manifest.",
+    presentMissingMessage: "subagent.json is missing. Create subagent.json with the required manifest fields (`owner`, `type`, `name`, `version`).",
+    schemaDescription: "subagent.json defines a valid subagent manifest.",
+});
+//# sourceMappingURL=envelope.js.map

package/dist/src/lint/catalog/subagent.d.ts

@@ -0,0 +1,4 @@
+import type { SubagentRuleContext } from "../context.js";
+import type { LintRule } from "../rule.js";
+export declare const subagentRules: ReadonlyArray<LintRule<SubagentRuleContext>>;
+//# sourceMappingURL=subagent.d.ts.map

package/dist/src/lint/catalog/subagent.js

@@ -0,0 +1,4 @@
+import { orderedEnvelopeRules } from "./shared/envelope-rules.js";
+import { subagentEnvelopeRules } from "./subagent/envelope.js";
+export const subagentRules = orderedEnvelopeRules(subagentEnvelopeRules);
+//# sourceMappingURL=subagent.js.map