@agentxm/client-core 0.2.0 → 0.3.1

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

@@ -0,0 +1,53 @@
+/**
+ * Platform-backed `PackFileAccessor` for `axm lint`.
+ *
+ * Maps accessor-relative posix paths to on-disk absolute paths rooted at
+ * the caller-supplied pack-root directory. Layout conventions per
+ * `docs/design/lint-engine.md §3` "Pack accessor root":
+ *
+ * - **Registry-installed:**
+ *   `<workspaceRoot>/.axm/extensions/<@owner>/packs/<sanitized-name>/`
+ *
+ * Packs are registry-only at v1 — there is no non-native variant. The caller
+ * (`buildPackRuleContexts` or the CLI entry point) picks the root from
+ * `computeExtensionPackPaths` in `../../../packs/paths.ts`.
+ *
+ * The `extension-pack.json` sits directly under `canonicalPath`; there is no
+ * `src/` subdirectory like skills have — see
+ * `../../../packs/operations/install.ts` for the authoritative layout.
+ *
+ * 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
+ * `PackFileAccessor` stays Layer-free at rule-evaluation time (per
+ * `lint-engine` spec "Rule contexts expose narrow caller-bound accessors").
+ *
+ * @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 { PackFileAccessor } from "../../context.js";
+/**
+ * Platform services needed by the platform-backed pack accessor.
+ */
+export interface PackAccessorPlatform {
+    readonly fs: FileSystem.FileSystem;
+    readonly path: Path.Path;
+}
+/**
+ * Build a platform-backed `PackFileAccessor` rooted at `absoluteRoot`.
+ *
+ * `absoluteRoot` SHOULD be the absolute path to the pack root directory
+ * (`canonicalPath` from `computeExtensionPackPaths` in
+ * `../../../packs/paths.ts`).
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const makePlatformPackFileAccessor: (platform: PackAccessorPlatform, absoluteRoot: string) => PackFileAccessor;
+//# sourceMappingURL=platform.d.ts.map

package/dist/src/unstable/lint/catalog/pack-accessor/platform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../../../../../src/unstable/lint/catalog/pack-accessor/platform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAGH,OAAO,KAAK,KAAK,UAAU,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,KAAK,IAAI,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,EAAmB,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAM1E;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,EAAE,UAAU,CAAC,UAAU,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC;CAC1B;AAMD;;;;;;;;GAQG;AACH,eAAO,MAAM,4BAA4B,GACvC,UAAU,oBAAoB,EAC9B,cAAc,MAAM,KACnB,gBA2DF,CAAC"}

package/dist/src/unstable/lint/catalog/pack-accessor/platform.js

@@ -0,0 +1,90 @@
+/**
+ * Platform-backed `PackFileAccessor` for `axm lint`.
+ *
+ * Maps accessor-relative posix paths to on-disk absolute paths rooted at
+ * the caller-supplied pack-root directory. Layout conventions per
+ * `docs/design/lint-engine.md §3` "Pack accessor root":
+ *
+ * - **Registry-installed:**
+ *   `<workspaceRoot>/.axm/extensions/<@owner>/packs/<sanitized-name>/`
+ *
+ * Packs are registry-only at v1 — there is no non-native variant. The caller
+ * (`buildPackRuleContexts` or the CLI entry point) picks the root from
+ * `computeExtensionPackPaths` in `../../../packs/paths.ts`.
+ *
+ * The `extension-pack.json` sits directly under `canonicalPath`; there is no
+ * `src/` subdirectory like skills have — see
+ * `../../../packs/operations/install.ts` for the authoritative layout.
+ *
+ * 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
+ * `PackFileAccessor` stays Layer-free at rule-evaluation time (per
+ * `lint-engine` spec "Rule contexts expose narrow caller-bound accessors").
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+/**
+ * Build a platform-backed `PackFileAccessor` rooted at `absoluteRoot`.
+ *
+ * `absoluteRoot` SHOULD be the absolute path to the pack root directory
+ * (`canonicalPath` from `computeExtensionPackPaths` in
+ * `../../../packs/paths.ts`).
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const makePlatformPackFileAccessor = (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/unstable/lint/catalog/pack-accessor/platform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform.js","sourceRoot":"","sources":["../../../../../../src/unstable/lint/catalog/pack-accessor/platform.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,60 @@
+/**
+ * VFT-backed `PackFileAccessor` 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.
+ * - 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.
+ *
+ * Mirrors the skill VFT accessor (`../skill-accessor/vft.ts`). The VFTNode
+ * interface is intentionally the same so a publish caller can extract a
+ * single archive once and pass the same tree to either accessor factory.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { PackFileAccessor } from "../../context.js";
+/**
+ * Minimal shape of a Virtual File Tree consumed by the accessor.
+ *
+ * Shape-compatible with `../skill-accessor/vft.ts#VFTNode`; kept as a local
+ * declaration to avoid a cross-subfolder import and to document what this
+ * accessor uses.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export interface PackVFTNode {
+    /**
+     * 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 `PackFileAccessor` rooted at the tree's root.
+ *
+ * Callers that root the pack 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 makeVftPackFileAccessor: (tree: PackVFTNode) => PackFileAccessor;
+//# sourceMappingURL=vft.d.ts.map

package/dist/src/unstable/lint/catalog/pack-accessor/vft.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vft.d.ts","sourceRoot":"","sources":["../../../../../../src/unstable/lint/catalog/pack-accessor/vft.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAGH,OAAO,KAAK,EAAmB,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAM1E;;;;;;;;GAQG;AACH,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;IACjD;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,UAAU,GAAG,SAAS,CAAC;CACjE;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,GAAI,MAAM,WAAW,KAAG,gBAqB3D,CAAC"}

package/dist/src/unstable/lint/catalog/pack-accessor/vft.js

@@ -0,0 +1,85 @@
+/**
+ * VFT-backed `PackFileAccessor` 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.
+ * - 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.
+ *
+ * Mirrors the skill VFT accessor (`../skill-accessor/vft.ts`). The VFTNode
+ * interface is intentionally the same so a publish caller can extract a
+ * single archive once and pass the same tree to either accessor factory.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+/**
+ * Build a VFT-backed `PackFileAccessor` rooted at the tree's root.
+ *
+ * Callers that root the pack 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 makeVftPackFileAccessor = (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);
+        },
+    };
+};
+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 pack-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/unstable/lint/catalog/pack-accessor/vft.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vft.js","sourceRoot":"","sources":["../../../../../../src/unstable/lint/catalog/pack-accessor/vft.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AA4BxC;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,IAAiB,EAAoB,EAAE;IAC7E,OAAO;QACL,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE;YACf,MAAM,UAAU,GAAG,iBAAiB,CAAC,IAAI,CAAC,CAAC;YAC3C,IAAI,UAAU,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;gBAC7B,OAAO,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAC/B,CAAC;YACD,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC;QACvD,CAAC;QACD,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE;YAClB,MAAM,UAAU,GAAG,iBAAiB,CAAC,IAAI,CAAC,CAAC;YAC3C,IAAI,UAAU,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACjC,OAAO,cAAc,CAAC,IAAI,EAAE,aAAa,EAAE,mCAAmC,IAAI,EAAE,CAAC,CAAC;YACxF,CAAC;YACD,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YAC5C,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;gBACxB,OAAO,cAAc,CAAC,IAAI,EAAE,YAAY,EAAE,qBAAqB,IAAI,EAAE,CAAC,CAAC;YACzE,CAAC;YACD,OAAO,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QAC/B,CAAC;KACF,CAAC;AACJ,CAAC,CAAC;AAQF,MAAM,iBAAiB,GAAG,CAAC,IAAY,EAAmB,EAAE;IAC1D,IAAI,IAAI,KAAK,EAAE,IAAI,IAAI,KAAK,GAAG,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;QACjD,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC;IAClC,CAAC;IACD,uEAAuE;IACvE,6CAA6C;IAC7C,IAAI,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QAChF,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;IAC5B,CAAC;IACD,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;IACjE,MAAM,QAAQ,GAAG,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACvC,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;YACrB,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;QAC5B,CAAC;IACH,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;AAC1C,CAAC,CAAC;AAEF,MAAM,cAAc,GAAG,CACrB,IAAY,EACZ,MAAiC,EACjC,OAAe,EAC6B,EAAE,CAC9C,MAAM,CAAC,IAAI,CAAC;IACV,IAAI,EAAE,iBAA0B;IAChC,IAAI;IACJ,MAAM;IACN,OAAO;CACR,CAAC,CAAC"}

package/dist/src/unstable/lint/catalog/pack.d.ts

@@ -0,0 +1,37 @@
+/**
+ * `pack/*` rule catalog — the v1 three-rule set.
+ *
+ * Per `docs/design/lint-engine.md §10.pack`, registry publish and `axm lint`
+ * run exactly these rules against each pack context:
+ *
+ * | ID                              | Severity | Autofix |
+ * | ------------------------------- | -------- | ------- |
+ * | `pack/manifest-present`         | error    | —       |
+ * | `pack/manifest-schema-valid`    | error    | —       |
+ * | `pack/manifest-keys-recognized` | warning  | —       |
+ *
+ * All three ship `kind: "advisory"`. Packs are registry-only at v1 (no
+ * non-native arm), so there is no applicability discriminator — every pack
+ * context runs every rule and the `check` body's early-return arms handle
+ * manifest-absent cases.
+ *
+ * Rule ids are **registered with the lint config allowlist at module-load
+ * time**, so importing this catalog extends the set of accepted
+ * `.axm/settings.json` `lint.rules` keys. Consumers that never import the
+ * catalog (the registry Worker bundle for `skill`-only routes, e.g.) don't
+ * pay the registration cost.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { LintRule } from "../rule.js";
+import type { PackRuleContext } from "../context.js";
+/**
+ * Ordered v1 `pack/*` 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 packRules: ReadonlyArray<LintRule<PackRuleContext>>;
+//# sourceMappingURL=pack.d.ts.map

package/dist/src/unstable/lint/catalog/pack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack.d.ts","sourceRoot":"","sources":["../../../../../src/unstable/lint/catalog/pack.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAKrD;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,EAAE,aAAa,CAAC,QAAQ,CAAC,eAAe,CAAC,CAI9D,CAAC"}

package/dist/src/unstable/lint/catalog/pack.js

@@ -0,0 +1,47 @@
+/**
+ * `pack/*` rule catalog — the v1 three-rule set.
+ *
+ * Per `docs/design/lint-engine.md §10.pack`, registry publish and `axm lint`
+ * run exactly these rules against each pack context:
+ *
+ * | ID                              | Severity | Autofix |
+ * | ------------------------------- | -------- | ------- |
+ * | `pack/manifest-present`         | error    | —       |
+ * | `pack/manifest-schema-valid`    | error    | —       |
+ * | `pack/manifest-keys-recognized` | warning  | —       |
+ *
+ * All three ship `kind: "advisory"`. Packs are registry-only at v1 (no
+ * non-native arm), so there is no applicability discriminator — every pack
+ * context runs every rule and the `check` body's early-return arms handle
+ * manifest-absent cases.
+ *
+ * Rule ids are **registered with the lint config allowlist at module-load
+ * time**, so importing this catalog extends the set of accepted
+ * `.axm/settings.json` `lint.rules` keys. Consumers that never import the
+ * catalog (the registry Worker bundle for `skill`-only routes, e.g.) don't
+ * pay the registration cost.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import { registerLintRuleIds } from "../config.js";
+import { manifestPresentRule } from "./pack/manifest-present.js";
+import { manifestSchemaValidRule } from "./pack/manifest-schema-valid.js";
+import { manifestKeysRecognizedRule } from "./pack/manifest-keys-recognized.js";
+/**
+ * Ordered v1 `pack/*` 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 packRules = [
+    manifestPresentRule,
+    manifestSchemaValidRule,
+    manifestKeysRecognizedRule,
+];
+// Register ids into the `LintConfig.rules` allowlist. Module-load side effect:
+// a consumer that imports this catalog (or the `catalog/index` barrel) enables
+// `.axm/settings.json` `lint.rules` to reference any of the above rule ids.
+registerLintRuleIds(packRules.map((r) => r.id));
+//# sourceMappingURL=pack.js.map

package/dist/src/unstable/lint/catalog/pack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack.js","sourceRoot":"","sources":["../../../../../src/unstable/lint/catalog/pack.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAGnD,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAEhF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,SAAS,GAA6C;IACjE,mBAAmB;IACnB,uBAAuB;IACvB,0BAA0B;CAC3B,CAAC;AAEF,+EAA+E;AAC/E,+EAA+E;AAC/E,4EAA4E;AAC5E,mBAAmB,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

package/dist/src/unstable/lint/catalog/shared/schema-rule.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Shared schema-delegation plumbing for `-schema-valid` rules.
+ *
+ * Per `docs/design/lint-engine.md §4` ("Schema-valid rules delegate to Effect
+ * Schema"), 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`.
+ *
+ * Phase 3a is the first catalog; landing the helper now keeps the Phase 3b
+ * pack catalog from duplicating the composition when it arrives. 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 Schema from "effect/Schema";
+import type { AdvisoryFinding, Severity } from "../../rule.js";
+/**
+ * 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 declare const schemaDecodeFindings: <A, I>(ruleId: string, severity: Severity, file: string, schema: Schema.Codec<A, I>, input: unknown) => Effect.Effect<ReadonlyArray<AdvisoryFinding>>;
+/**
+ * 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 declare const structFieldKeys: (struct: {
+    readonly fields: Readonly<Record<string, unknown>>;
+}) => ReadonlySet<string>;
+/**
+ * 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 declare const enumerateUnknownTopLevelKeys: (ruleId: string, severity: Severity, file: string, allowedKeys: ReadonlySet<string>, input: unknown) => ReadonlyArray<AdvisoryFinding>;
+//# sourceMappingURL=schema-rule.d.ts.map

package/dist/src/unstable/lint/catalog/shared/schema-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-rule.d.ts","sourceRoot":"","sources":["../../../../../../src/unstable/lint/catalog/shared/schema-rule.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAM/D;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,oBAAoB,GAAI,CAAC,EAAE,CAAC,EACvC,QAAQ,MAAM,EACd,UAAU,QAAQ,EAClB,MAAM,MAAM,EACZ,QAAQ,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,OAAO,OAAO,KACb,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,eAAe,CAAC,CAY9C,CAAC;AAMF;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,GAAI,QAAQ;IACtC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACpD,KAAG,WAAW,CAAC,MAAM,CAAwC,CAAC;AAE/D;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B,GACvC,QAAQ,MAAM,EACd,UAAU,QAAQ,EAClB,MAAM,MAAM,EACZ,aAAa,WAAW,CAAC,MAAM,CAAC,EAChC,OAAO,OAAO,KACb,aAAa,CAAC,eAAe,CAsB/B,CAAC"}

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

@@ -0,0 +1,99 @@
+/**
+ * Shared schema-delegation plumbing for `-schema-valid` rules.
+ *
+ * Per `docs/design/lint-engine.md §4` ("Schema-valid rules delegate to Effect
+ * Schema"), 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`.
+ *
+ * Phase 3a is the first catalog; landing the helper now keeps the Phase 3b
+ * pack catalog from duplicating the composition when it arrives. 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 { issuesToFindings } from "../../issues-to-findings.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([]);
+    }
+    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));
+};
+// -----------------------------------------------------------------------------
+// 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 (!isPlainRecord(input)) {
+        return [];
+    }
+    const findings = [];
+    for (const key of Object.keys(input)) {
+        if (allowedKeys.has(key)) {
+            continue;
+        }
+        findings.push({
+            kind: "advisory",
+            ruleId,
+            severity,
+            message: `unrecognized top-level key '${key}'; remove it or rename to a canonical field.`,
+            suggestions: [
+                `Remove the '${key}' key from the manifest.`,
+                `Rename '${key}' to the intended canonical field.`,
+            ],
+            location: { file },
+        });
+    }
+    return findings;
+};
+const isPlainRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+//# sourceMappingURL=schema-rule.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema-rule.js","sourceRoot":"","sources":["../../../../../../src/unstable/lint/catalog/shared/schema-rule.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAG/D,gFAAgF;AAChF,uBAAuB;AACvB,gFAAgF;AAEhF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAClC,MAAc,EACd,QAAkB,EAClB,IAAY,EACZ,MAA0B,EAC1B,KAAc,EACiC,EAAE;IACjD,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,OAAO,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;IAC5B,CAAC;IACD,MAAM,MAAM,GAAG,MAAM,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE;QACvD,gBAAgB,EAAE,QAAQ;QAC1B,MAAM,EAAE,KAAK;KACd,CAAC,CAAC;IACH,IAAI,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC;QAC7B,OAAO,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;IAC5B,CAAC;IACD,OAAO,MAAM,CAAC,OAAO,CAAC,gBAAgB,CAAC,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;AAClF,CAAC,CAAC;AAEF,gFAAgF;AAChF,+BAA+B;AAC/B,gFAAgF;AAEhF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,MAE/B,EAAuB,EAAE,CAAC,IAAI,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;AAE/D;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAC1C,MAAc,EACd,QAAkB,EAClB,IAAY,EACZ,WAAgC,EAChC,KAAc,EACkB,EAAE;IAClC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,MAAM,QAAQ,GAA2B,EAAE,CAAC;IAC5C,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACrC,IAAI,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACzB,SAAS;QACX,CAAC;QACD,QAAQ,CAAC,IAAI,CAAC;YACZ,IAAI,EAAE,UAAU;YAChB,MAAM;YACN,QAAQ;YACR,OAAO,EAAE,+BAA+B,GAAG,8CAA8C;YACzF,WAAW,EAAE;gBACX,eAAe,GAAG,0BAA0B;gBAC5C,WAAW,GAAG,oCAAoC;aACnD;YACD,QAAQ,EAAE,EAAE,IAAI,EAAE;SACnB,CAAC,CAAC;IACL,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC;AAEF,MAAM,aAAa,GAAG,CAAC,KAAc,EAA8C,EAAE,CACnF,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC"}

package/dist/src/unstable/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 `docs/design/lint-engine.md §10.skill (Notes)`, 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/unstable/lint/catalog/skill/frontmatter-parseable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontmatter-parseable.d.ts","sourceRoot":"","sources":["../../../../../../src/unstable/lint/catalog/skill/frontmatter-parseable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,KAAK,EAAmB,YAAY,EAAE,MAAM,eAAe,CAAC;AAanE,eAAO,MAAM,wBAAwB,EAAE,YAAY,CAAC,gBAAgB,CAyBnE,CAAC"}