@agentxm/registry-protocol 0.28.4-bootstrap.0

package/dist/src/unstable/lint/catalog/hook/decision-portability.d.ts

@@ -0,0 +1,4 @@
+import type { HookRuleContext } from "../../context.js";
+import type { AdvisoryRule } from "../../rule.js";
+export declare const decisionPortabilityRule: AdvisoryRule<HookRuleContext>;
+//# sourceMappingURL=decision-portability.d.ts.map

package/dist/src/unstable/lint/catalog/hook/decision-portability.js

@@ -0,0 +1,40 @@
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { HOOK_MANIFEST_FILENAME, HookManifestSchema, } from "@agentxm/extension-model/unstable/hooks/manifest-schema";
+import { isManifestJsonParseFailure } from "../shared/manifest-json.js";
+const RULE_ID = "hook/decision-portability";
+const decodeHookManifest = Schema.decodeUnknownResult(HookManifestSchema);
+export const decisionPortabilityRule = {
+    id: RULE_ID,
+    description: "Hook decision requirements state when native support is intentionally narrowed.",
+    kind: "advisory",
+    severity: "warning",
+    check: (context) => {
+        if (context.subject.hookJson === undefined ||
+            isManifestJsonParseFailure(context.subject.hookJson)) {
+            return Effect.succeed([]);
+        }
+        const decoded = decodeHookManifest(context.subject.hookJson, {
+            onExcessProperty: "ignore",
+            errors: "all",
+        });
+        if (Result.isFailure(decoded))
+            return Effect.succeed([]);
+        const findings = [];
+        for (const [index, binding] of decoded.success.bindings.entries()) {
+            const decision = binding.requires?.decision.kind;
+            if (decision === undefined || decision === "observe")
+                continue;
+            findings.push({
+                kind: "advisory",
+                ruleId: RULE_ID,
+                severity: "warning",
+                message: `hook.json bindings[${String(index)}].requires.decision.kind is ${decision}, which narrows native agent support and cannot use advisory fallback. Use observe when enforcement is not required, or retain ${decision} and expect unsupported configured agents to be blocked.`,
+                location: { file: HOOK_MANIFEST_FILENAME },
+            });
+        }
+        return Effect.succeed(findings);
+    },
+};
+//# sourceMappingURL=decision-portability.js.map

package/dist/src/unstable/lint/catalog/hook/entrypoint-exists.d.ts

@@ -0,0 +1,4 @@
+import type { HookRuleContext } from "../../context.js";
+import type { AdvisoryRule } from "../../rule.js";
+export declare const entrypointExistsRule: AdvisoryRule<HookRuleContext>;
+//# sourceMappingURL=entrypoint-exists.d.ts.map

package/dist/src/unstable/lint/catalog/hook/entrypoint-exists.js

@@ -0,0 +1,39 @@
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { HookManifestSchema, HOOK_MANIFEST_FILENAME, } from "@agentxm/extension-model/unstable/hooks/manifest-schema";
+import { isManifestJsonParseFailure } from "../shared/manifest-json.js";
+const RULE_ID = "hook/entrypoint-exists";
+const decodeHookManifest = Schema.decodeUnknownResult(HookManifestSchema);
+export const entrypointExistsRule = {
+    id: RULE_ID,
+    description: "hook.json entrypoint points to a package file.",
+    kind: "advisory",
+    severity: "error",
+    check: (context) => {
+        if (context.subject.hookJson === undefined ||
+            isManifestJsonParseFailure(context.subject.hookJson)) {
+            return Effect.succeed([]);
+        }
+        const decoded = decodeHookManifest(context.subject.hookJson, {
+            onExcessProperty: "ignore",
+            errors: "all",
+        });
+        if (Result.isFailure(decoded)) {
+            return Effect.succeed([]);
+        }
+        const entrypoint = decoded.success.entrypoint;
+        return Effect.map(context.files.exists(entrypoint), (present) => present
+            ? []
+            : [
+                {
+                    kind: "advisory",
+                    ruleId: RULE_ID,
+                    severity: "error",
+                    message: `hook.json entrypoint '${entrypoint}' does not exist. Add the hook body file or update \`entrypoint\`.`,
+                    location: { file: HOOK_MANIFEST_FILENAME },
+                },
+            ]);
+    },
+};
+//# sourceMappingURL=entrypoint-exists.js.map

package/dist/src/unstable/lint/catalog/hook/envelope.d.ts

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

package/dist/src/unstable/lint/catalog/hook/envelope.js

@@ -0,0 +1,15 @@
+/**
+ * `hook/*` manifest envelope — see `../shared/envelope-rules.ts`.
+ */
+import { HookManifestSchema, HOOK_MANIFEST_FILENAME, } from "@agentxm/extension-model/unstable/hooks/manifest-schema";
+import { makeManifestEnvelopeRules } from "../shared/envelope-rules.js";
+export const hookEnvelopeRules = makeManifestEnvelopeRules({
+    namespace: "hook",
+    manifestFile: HOOK_MANIFEST_FILENAME,
+    schema: HookManifestSchema,
+    manifestJson: (context) => context.subject.hookJson,
+    presentDescription: "Hooks include a root hook.json manifest.",
+    presentMissingMessage: "hook.json is missing. Create hook.json with the required manifest fields (`owner`, `type`, `name`, `version`, `runtime`, `entrypoint`, `bindings`).",
+    schemaDescription: "hook.json defines a valid hook manifest.",
+});
+//# sourceMappingURL=envelope.js.map

package/dist/src/unstable/lint/catalog/hook/matcher-raw-portability.d.ts

@@ -0,0 +1,4 @@
+import type { HookRuleContext } from "../../context.js";
+import type { AdvisoryRule } from "../../rule.js";
+export declare const matcherRawPortabilityRule: AdvisoryRule<HookRuleContext>;
+//# sourceMappingURL=matcher-raw-portability.d.ts.map

package/dist/src/unstable/lint/catalog/hook/matcher-raw-portability.js

@@ -0,0 +1,51 @@
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { HookManifestSchema, HOOK_MANIFEST_FILENAME, } from "@agentxm/extension-model/unstable/hooks/manifest-schema";
+import { isManifestJsonParseFailure } from "../shared/manifest-json.js";
+const RULE_ID = "hook/matcher-raw-portability";
+const decodeHookManifest = Schema.decodeUnknownResult(HookManifestSchema);
+export const matcherRawPortabilityRule = {
+    id: RULE_ID,
+    description: "Hook matchers use portable canonical tool matches where possible.",
+    kind: "advisory",
+    severity: "warning",
+    check: (context) => {
+        if (context.subject.hookJson === undefined ||
+            isManifestJsonParseFailure(context.subject.hookJson)) {
+            return Effect.succeed([]);
+        }
+        const decoded = decodeHookManifest(context.subject.hookJson, {
+            onExcessProperty: "ignore",
+            errors: "all",
+        });
+        if (Result.isFailure(decoded)) {
+            return Effect.succeed([]);
+        }
+        const findings = [];
+        for (const binding of decoded.success.bindings) {
+            if (binding.matcherRaw !== undefined) {
+                findings.push({
+                    kind: "advisory",
+                    ruleId: RULE_ID,
+                    severity: "warning",
+                    message: "hook.json uses matcherRaw, which is native-agent-specific and not portable. Prefer `match.tools` with canonical tool IDs.",
+                    location: { file: HOOK_MANIFEST_FILENAME },
+                });
+            }
+            for (const target of Object.values(binding.targets ?? {})) {
+                if (target.matcherRaw !== undefined) {
+                    findings.push({
+                        kind: "advisory",
+                        ruleId: RULE_ID,
+                        severity: "warning",
+                        message: "hook.json uses a target matcherRaw override, which is native-agent-specific and not portable.",
+                        location: { file: HOOK_MANIFEST_FILENAME },
+                    });
+                }
+            }
+        }
+        return Effect.succeed(findings);
+    },
+};
+//# sourceMappingURL=matcher-raw-portability.js.map

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

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

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

@@ -0,0 +1,17 @@
+import { registerLintRuleIds } from "../config.js";
+import { entrypointExistsRule } from "./hook/entrypoint-exists.js";
+import { decisionPortabilityRule } from "./hook/decision-portability.js";
+import { hookEnvelopeRules } from "./hook/envelope.js";
+import { matcherRawPortabilityRule } from "./hook/matcher-raw-portability.js";
+export const hookRules = [
+    hookEnvelopeRules.manifestPresent,
+    hookEnvelopeRules.manifestSchemaValid,
+    hookEnvelopeRules.manifestKeysRecognized,
+    decisionPortabilityRule,
+    matcherRawPortabilityRule,
+    entrypointExistsRule,
+    hookEnvelopeRules.standaloneDeclarationValid,
+    hookEnvelopeRules.recommendedPacksValid,
+];
+registerLintRuleIds(hookRules.map((r) => r.id));
+//# sourceMappingURL=hook.js.map

package/dist/src/unstable/lint/catalog/knowledge/diagnostics.d.ts

@@ -0,0 +1,128 @@
+import type { KnowledgeRuleContext } from "../../context.js";
+import type { AdvisoryRule } from "../../rule.js";
+export declare const knowledgeDiagnosticRuleDefinitions: readonly [{
+    readonly code: "bundle-too-large";
+    readonly severity: "error";
+}, {
+    readonly code: "file-too-large";
+    readonly severity: "error";
+}, {
+    readonly code: "invalid-tags";
+    readonly severity: "error";
+}, {
+    readonly code: "missing-root-index";
+    readonly severity: "error";
+}, {
+    readonly code: "missing-okf-version";
+    readonly severity: "error";
+}, {
+    readonly code: "missing-title";
+    readonly severity: "warning";
+}, {
+    readonly code: "missing-description";
+    readonly severity: "warning";
+}, {
+    readonly code: "missing-manifest-description";
+    readonly severity: "warning";
+}, {
+    readonly code: "empty-bundle";
+    readonly severity: "warning";
+}, {
+    readonly code: "missing-tags";
+    readonly severity: "warning";
+}, {
+    readonly code: "symbolic-link";
+    readonly severity: "error";
+}, {
+    readonly code: "too-many-files";
+    readonly severity: "error";
+}, {
+    readonly code: "unsupported-okf-version";
+    readonly severity: "error";
+}, {
+    readonly code: "missing-type";
+    readonly severity: "error";
+}, {
+    readonly code: "invalid-frontmatter";
+    readonly severity: "error";
+}, {
+    readonly code: "case-collision";
+    readonly severity: "error";
+}, {
+    readonly code: "dangerous-uri";
+    readonly severity: "error";
+}, {
+    readonly code: "detected-secret";
+    readonly severity: "error";
+}, {
+    readonly code: "unsafe-path";
+    readonly severity: "error";
+}, {
+    readonly code: "invalid-index";
+    readonly severity: "error";
+}, {
+    readonly code: "invalid-log";
+    readonly severity: "error";
+}, {
+    readonly code: "invalid-resource";
+    readonly severity: "error";
+}, {
+    readonly code: "escaping-resource";
+    readonly severity: "error";
+}, {
+    readonly code: "unresolved-resource";
+    readonly severity: "warning";
+}, {
+    readonly code: "broken-internal-link";
+    readonly severity: "warning";
+}, {
+    readonly code: "escaping-link";
+    readonly severity: "warning";
+}, {
+    readonly code: "unreachable-concept";
+    readonly severity: "warning";
+}, {
+    readonly code: "missing-index-entry";
+    readonly severity: "warning";
+}, {
+    readonly code: "stale-index-entry";
+    readonly severity: "warning";
+}, {
+    readonly code: "embedded-html";
+    readonly severity: "warning";
+}, {
+    readonly code: "duplicate-resource";
+    readonly severity: "warning";
+}, {
+    readonly code: "inconsistent-type";
+    readonly severity: "warning";
+}, {
+    readonly code: "large-concept";
+    readonly severity: "warning";
+}, {
+    readonly code: "large-index";
+    readonly severity: "warning";
+}, {
+    readonly code: "unreferenced-asset";
+    readonly severity: "warning";
+}, {
+    readonly code: "invalid-sources";
+    readonly severity: "error";
+}, {
+    readonly code: "invalid-generated";
+    readonly severity: "error";
+}, {
+    readonly code: "invalid-verified";
+    readonly severity: "error";
+}, {
+    readonly code: "invalid-status";
+    readonly severity: "error";
+}, {
+    readonly code: "invalid-stale-after";
+    readonly severity: "error";
+}, {
+    readonly code: "invalid-attestation";
+    readonly severity: "error";
+}];
+export declare const knowledgeDiagnosticRules: ReadonlyArray<AdvisoryRule<KnowledgeRuleContext>>;
+//# sourceMappingURL=diagnostics.d.ts.map

package/dist/src/unstable/lint/catalog/knowledge/diagnostics.js

@@ -0,0 +1,78 @@
+import * as Effect from "effect/Effect";
+import { KNOWLEDGE_MANIFEST_FILENAME, KNOWLEDGE_SOURCE_DIR, } from "@agentxm/extension-model/unstable/knowledge";
+import {} from "../../../knowledge/index.js";
+const makeDiagnosticRule = (definition) => {
+    const ruleId = `knowledge/${definition.code}`;
+    return {
+        id: ruleId,
+        description: `Knowledge packages satisfy the ${definition.code} diagnostic invariant.`,
+        kind: "advisory",
+        severity: definition.severity,
+        check: (context) => {
+            const diagnostics = context.subject.inspection?.diagnostics ?? [];
+            const findings = diagnostics
+                .filter((diagnostic) => diagnostic.code === definition.code)
+                .map((diagnostic) => ({
+                kind: "advisory",
+                ruleId,
+                severity: definition.severity,
+                message: diagnostic.message,
+                location: {
+                    file: diagnostic.code === "missing-manifest-description"
+                        ? KNOWLEDGE_MANIFEST_FILENAME
+                        : diagnostic.relativePath === "."
+                            ? KNOWLEDGE_SOURCE_DIR
+                            : `${KNOWLEDGE_SOURCE_DIR}/${diagnostic.relativePath}`,
+                    ...(diagnostic.line === undefined ? {} : { line: diagnostic.line }),
+                    ...(diagnostic.column === undefined ? {} : { column: diagnostic.column }),
+                },
+            }));
+            return Effect.succeed(findings);
+        },
+    };
+};
+export const knowledgeDiagnosticRuleDefinitions = [
+    { code: "bundle-too-large", severity: "error" },
+    { code: "file-too-large", severity: "error" },
+    { code: "invalid-tags", severity: "error" },
+    { code: "missing-root-index", severity: "error" },
+    { code: "missing-okf-version", severity: "error" },
+    { code: "missing-title", severity: "warning" },
+    { code: "missing-description", severity: "warning" },
+    { code: "missing-manifest-description", severity: "warning" },
+    { code: "empty-bundle", severity: "warning" },
+    { code: "missing-tags", severity: "warning" },
+    { code: "symbolic-link", severity: "error" },
+    { code: "too-many-files", severity: "error" },
+    { code: "unsupported-okf-version", severity: "error" },
+    { code: "missing-type", severity: "error" },
+    { code: "invalid-frontmatter", severity: "error" },
+    { code: "case-collision", severity: "error" },
+    { code: "dangerous-uri", severity: "error" },
+    { code: "detected-secret", severity: "error" },
+    { code: "unsafe-path", severity: "error" },
+    { code: "invalid-index", severity: "error" },
+    { code: "invalid-log", severity: "error" },
+    { code: "invalid-resource", severity: "error" },
+    { code: "escaping-resource", severity: "error" },
+    { code: "unresolved-resource", severity: "warning" },
+    { code: "broken-internal-link", severity: "warning" },
+    { code: "escaping-link", severity: "warning" },
+    { code: "unreachable-concept", severity: "warning" },
+    { code: "missing-index-entry", severity: "warning" },
+    { code: "stale-index-entry", severity: "warning" },
+    { code: "embedded-html", severity: "warning" },
+    { code: "duplicate-resource", severity: "warning" },
+    { code: "inconsistent-type", severity: "warning" },
+    { code: "large-concept", severity: "warning" },
+    { code: "large-index", severity: "warning" },
+    { code: "unreferenced-asset", severity: "warning" },
+    { code: "invalid-sources", severity: "error" },
+    { code: "invalid-generated", severity: "error" },
+    { code: "invalid-verified", severity: "error" },
+    { code: "invalid-status", severity: "error" },
+    { code: "invalid-stale-after", severity: "error" },
+    { code: "invalid-attestation", severity: "error" },
+];
+export const knowledgeDiagnosticRules = knowledgeDiagnosticRuleDefinitions.map(makeDiagnosticRule);
+//# sourceMappingURL=diagnostics.js.map

package/dist/src/unstable/lint/catalog/knowledge/envelope.d.ts

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

package/dist/src/unstable/lint/catalog/knowledge/envelope.js

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

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

@@ -0,0 +1,5 @@
+import type { KnowledgeRuleContext } from "../context.js";
+import type { LintRule } from "../rule.js";
+export declare const knowledgeRules: ReadonlyArray<LintRule<KnowledgeRuleContext>>;
+export { knowledgeDiagnosticRuleDefinitions, knowledgeDiagnosticRules, } from "./knowledge/diagnostics.js";
+//# sourceMappingURL=knowledge.d.ts.map

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

@@ -0,0 +1,11 @@
+import { registerLintRuleIds } from "../config.js";
+import { knowledgeEnvelopeRules } from "./knowledge/envelope.js";
+import { orderedEnvelopeRules } from "./shared/envelope-rules.js";
+import { knowledgeDiagnosticRules } from "./knowledge/diagnostics.js";
+export const knowledgeRules = [
+    ...orderedEnvelopeRules(knowledgeEnvelopeRules),
+    ...knowledgeDiagnosticRules,
+];
+export { knowledgeDiagnosticRuleDefinitions, knowledgeDiagnosticRules, } from "./knowledge/diagnostics.js";
+registerLintRuleIds(knowledgeRules.map((r) => r.id));
+//# sourceMappingURL=knowledge.js.map

package/dist/src/unstable/lint/catalog/mcp-server/envelope.d.ts

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

package/dist/src/unstable/lint/catalog/mcp-server/envelope.js

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

package/dist/src/unstable/lint/catalog/mcp-server.d.ts

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

package/dist/src/unstable/lint/catalog/mcp-server.js

@@ -0,0 +1,6 @@
+import { registerLintRuleIds } from "../config.js";
+import { mcpServerEnvelopeRules } from "./mcp-server/envelope.js";
+import { orderedEnvelopeRules } from "./shared/envelope-rules.js";
+export const mcpServerRules = orderedEnvelopeRules(mcpServerEnvelopeRules);
+registerLintRuleIds(mcpServerRules.map((r) => r.id));
+//# sourceMappingURL=mcp-server.js.map

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

@@ -0,0 +1,28 @@
+/**
+ * `pack/manifest-keys-recognized` — `pack.json` contains only keys
+ * declared by `PackManifestSchema`.
+ *
+ * The paired `-schema-valid` rule ignores excess properties by construction
+ * (`onExcessProperty: "ignore"`); this rule rejects them so publish never
+ * silently drops unrecognized manifest data.
+ *
+ * A forbidden `packs:` dependency section (ONTOLOGY D015 "Cross-Domain
+ * Pack Semantics") decodes as an unrecognized top-level key here
+ * and surfaces at error severity here.
+ *
+ * Allowed-keys set is derived from `PackManifestSchema.fields` — no
+ * copy-paste of field names. A schema gain (or rename) automatically updates
+ * the allowlist.
+ *
+ * Early-return arm (no findings):
+ *
+ * - `subject.packJson === undefined` / non-object — nothing to enumerate;
+ *   `pack/manifest-present` owns the absence case.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { PackRuleContext } from "../../context.js";
+import type { AdvisoryRule } from "../../rule.js";
+export declare const manifestKeysRecognizedRule: AdvisoryRule<PackRuleContext>;
+//# sourceMappingURL=manifest-keys-recognized.d.ts.map

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

@@ -0,0 +1,38 @@
+/**
+ * `pack/manifest-keys-recognized` — `pack.json` contains only keys
+ * declared by `PackManifestSchema`.
+ *
+ * The paired `-schema-valid` rule ignores excess properties by construction
+ * (`onExcessProperty: "ignore"`); this rule rejects them so publish never
+ * silently drops unrecognized manifest data.
+ *
+ * A forbidden `packs:` dependency section (ONTOLOGY D015 "Cross-Domain
+ * Pack Semantics") decodes as an unrecognized top-level key here
+ * and surfaces at error severity here.
+ *
+ * Allowed-keys set is derived from `PackManifestSchema.fields` — no
+ * copy-paste of field names. A schema gain (or rename) automatically updates
+ * the allowlist.
+ *
+ * Early-return arm (no findings):
+ *
+ * - `subject.packJson === undefined` / non-object — nothing to enumerate;
+ *   `pack/manifest-present` owns the absence case.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+import { PackManifestSchema } from "@agentxm/extension-model/unstable/packs/manifest-schema";
+import { enumerateUnknownTopLevelKeys, structFieldKeys } from "../shared/schema-rule.js";
+const RULE_ID = "pack/manifest-keys-recognized";
+const PACK_JSON = "pack.json";
+const allowedKeys = structFieldKeys(PackManifestSchema);
+export const manifestKeysRecognizedRule = {
+    id: RULE_ID,
+    description: "pack.json uses only supported top-level fields.",
+    kind: "advisory",
+    severity: "error",
+    check: (context) => Effect.succeed(enumerateUnknownTopLevelKeys(RULE_ID, "error", PACK_JSON, allowedKeys, context.subject.packJson)),
+};
+//# sourceMappingURL=manifest-keys-recognized.js.map

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

@@ -0,0 +1,17 @@
+/**
+ * `pack/manifest-present` — packs must have a `pack.json` at the
+ * pack root.
+ *
+ * Packs are registry-only at v1; every pack context is expected to expose a
+ * manifest. Unlike `skill/manifest-present`, there is no native-vs-non-native
+ * split — the rule applies to every pack context unconditionally.
+ *
+ * Advisory-only — scaffolding a manifest is `axm packs new` (a user-authored
+ * action) per the lint design.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { PackRuleContext } from "../../context.js";
+export declare const manifestPresentRule: import("../../rule.ts").AdvisoryRule<PackRuleContext<import("../../context.js").PackContent>>;
+//# sourceMappingURL=manifest-present.d.ts.map

package/dist/src/unstable/lint/catalog/pack/manifest-present.js

@@ -0,0 +1,24 @@
+/**
+ * `pack/manifest-present` — packs must have a `pack.json` at the
+ * pack root.
+ *
+ * Packs are registry-only at v1; every pack context is expected to expose a
+ * manifest. Unlike `skill/manifest-present`, there is no native-vs-non-native
+ * split — the rule applies to every pack context unconditionally.
+ *
+ * Advisory-only — scaffolding a manifest is `axm packs new` (a user-authored
+ * action) per the lint design.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import { makeManifestPresentRule } from "../shared/manifest-present.js";
+const RULE_ID = "pack/manifest-present";
+const PACK_JSON = "pack.json";
+export const manifestPresentRule = makeManifestPresentRule({
+    ruleId: RULE_ID,
+    description: "Packs include a root pack.json manifest.",
+    manifestFile: PACK_JSON,
+    missingMessage: "pack.json is missing. Create pack.json with the required manifest fields (`owner`, `type`, `name`, `version`).",
+});
+//# sourceMappingURL=manifest-present.js.map

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

@@ -0,0 +1,25 @@
+/**
+ * `pack/manifest-schema-valid` — `pack.json` conforms to
+ * `PackManifestSchema`.
+ *
+ * Delegates to Effect Schema. Issues map 1:1 to findings via
+ * `issuesToFindings`.
+ *
+ * Early-return arm (no findings):
+ *
+ * - `subject.packJson === undefined` — manifest is absent (covered by
+ *   `pack/manifest-present`).
+ *
+ * Dependency-map FQN grammar and `VersionRange` decode arms are owned by
+ * `PackManifestSchema` itself — the dependency sections are typed
+ * `Record<FQN, VersionRange>` so unknown FQNs, malformed grammar, and
+ * bad semver ranges surface as normal schema issues through the shared
+ * `schemaDecodeFindings` plumbing.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { PackRuleContext } from "../../context.js";
+import type { AdvisoryRule } from "../../rule.js";
+export declare const manifestSchemaValidRule: AdvisoryRule<PackRuleContext>;
+//# sourceMappingURL=manifest-schema-valid.d.ts.map