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

package/dist/src/knowledge/package-inspection.d.ts

@@ -0,0 +1,125 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+import { ManifestError } from "../packaging/manifest-policy.js";
+import { type KnowledgeInspection } from "./okf.js";
+/** Read and decode one Knowledge package manifest without inspecting its bundle body. */
+export declare const readKnowledgePackageManifest: (packageRoot: string) => Effect.Effect<{
+    sourceRoot: string;
+    manifest: {
+        readonly name: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly type: "knowledge";
+        readonly format: {
+            readonly name: "okf";
+            readonly version: "0.2";
+        };
+        readonly owner: string & import("effect/Brand").Brand<"Handle">;
+        readonly version: string & import("effect/Brand").Brand<"Version">;
+        readonly bundleRoot: "src";
+        readonly description?: string | undefined;
+        readonly license?: string | undefined;
+        readonly metadata?: {
+            readonly [x: string]: Schema.Json;
+        } | undefined;
+        readonly enhances?: readonly string[] | undefined;
+        readonly requires?: readonly string[] | undefined;
+        readonly fallback?: "auto" | "none" | undefined;
+        readonly recommendedPacks?: readonly (string & import("effect/Brand").Brand<"PackSpec">)[] | undefined;
+        readonly standalone?: boolean | undefined;
+        readonly publish?: {
+            readonly visibility?: "public" | "private" | undefined;
+            readonly ignore?: readonly string[] | undefined;
+        } | undefined;
+        readonly keywords?: readonly string[] | undefined;
+        readonly repository?: string | {
+            readonly url: string;
+            readonly type?: string | undefined;
+            readonly directory?: string | undefined;
+        } | undefined;
+        readonly homepage?: string | undefined;
+        readonly bugs?: string | {
+            readonly url?: string | undefined;
+            readonly email?: string | undefined;
+        } | undefined;
+        readonly authors?: readonly {
+            readonly name: string;
+            readonly url?: string | undefined;
+            readonly email?: string | undefined;
+        }[] | undefined;
+        readonly packages?: readonly {
+            readonly purl: string & import("effect/Brand").Brand<"PackageIdentityPurl">;
+            readonly versionRange?: ({
+                readonly raw: string;
+                readonly scheme: string;
+                readonly constraints: readonly {
+                    readonly comparator: "=" | "!=" | "<" | "<=" | ">" | ">=";
+                    readonly version: string;
+                }[];
+            } & import("effect/Brand").Brand<"VersRange">) | undefined;
+        }[] | undefined;
+        readonly $schema?: string | undefined;
+        readonly instructionEntry?: boolean;
+    };
+}, import("effect/PlatformError").PlatformError | ManifestError | Schema.SchemaError, FileSystem.FileSystem | Path.Path>;
+/** Inspect one complete Knowledge package, including manifest-level profile diagnostics. */
+export declare const inspectKnowledgePackage: (packageRoot: string) => Effect.Effect<{
+    name: string & import("effect/Brand").Brand<"ExtensionName">;
+    sourceRoot: string;
+    manifest: {
+        readonly name: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly type: "knowledge";
+        readonly format: {
+            readonly name: "okf";
+            readonly version: "0.2";
+        };
+        readonly owner: string & import("effect/Brand").Brand<"Handle">;
+        readonly version: string & import("effect/Brand").Brand<"Version">;
+        readonly bundleRoot: "src";
+        readonly description?: string | undefined;
+        readonly license?: string | undefined;
+        readonly metadata?: {
+            readonly [x: string]: Schema.Json;
+        } | undefined;
+        readonly enhances?: readonly string[] | undefined;
+        readonly requires?: readonly string[] | undefined;
+        readonly fallback?: "auto" | "none" | undefined;
+        readonly recommendedPacks?: readonly (string & import("effect/Brand").Brand<"PackSpec">)[] | undefined;
+        readonly standalone?: boolean | undefined;
+        readonly publish?: {
+            readonly visibility?: "public" | "private" | undefined;
+            readonly ignore?: readonly string[] | undefined;
+        } | undefined;
+        readonly keywords?: readonly string[] | undefined;
+        readonly repository?: string | {
+            readonly url: string;
+            readonly type?: string | undefined;
+            readonly directory?: string | undefined;
+        } | undefined;
+        readonly homepage?: string | undefined;
+        readonly bugs?: string | {
+            readonly url?: string | undefined;
+            readonly email?: string | undefined;
+        } | undefined;
+        readonly authors?: readonly {
+            readonly name: string;
+            readonly url?: string | undefined;
+            readonly email?: string | undefined;
+        }[] | undefined;
+        readonly packages?: readonly {
+            readonly purl: string & import("effect/Brand").Brand<"PackageIdentityPurl">;
+            readonly versionRange?: ({
+                readonly raw: string;
+                readonly scheme: string;
+                readonly constraints: readonly {
+                    readonly comparator: "=" | "!=" | "<" | "<=" | ">" | ">=";
+                    readonly version: string;
+                }[];
+            } & import("effect/Brand").Brand<"VersRange">) | undefined;
+        }[] | undefined;
+        readonly $schema?: string | undefined;
+        readonly instructionEntry?: boolean;
+    };
+    inspection: KnowledgeInspection;
+}, unknown, FileSystem.FileSystem | Path.Path>;
+//# sourceMappingURL=package-inspection.d.ts.map

package/dist/src/knowledge/package-inspection.js

@@ -0,0 +1,45 @@
+// @effect-diagnostics anyUnknownInErrorContext:off — package accessors preserve caller-owned foreign read errors until diagnostic translation
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+import { KNOWLEDGE_MANIFEST_FILENAME, KNOWLEDGE_SOURCE_DIR, KnowledgeManifestSchema, } from "@agentxm/extension-model/unstable/knowledge/manifest-schema";
+import { ManifestError } from "../packaging/manifest-policy.js";
+import { inspectKnowledgeBundle, } from "./okf.js";
+const missingManifestDescription = () => ({
+    code: "missing-manifest-description",
+    severity: "warning",
+    relativePath: KNOWLEDGE_MANIFEST_FILENAME,
+    message: `${KNOWLEDGE_MANIFEST_FILENAME} should include a concise bundle description for discovery.`,
+});
+/** Read and decode one Knowledge package manifest without inspecting its bundle body. */
+export const readKnowledgePackageManifest = Effect.fn("Knowledge.readPackageManifest")(function* (packageRoot) {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const manifestPath = path.join(packageRoot, KNOWLEDGE_MANIFEST_FILENAME);
+    const manifestRaw = yield* fs.readFileString(manifestPath);
+    const manifestUnknown = yield* Effect.try({
+        try: () => JSON.parse(manifestRaw),
+        catch: (cause) => new ManifestError({
+            code: "manifest_invalid_json",
+            detail: `Failed to parse ${manifestPath}`,
+            details: cause,
+        }),
+    });
+    const manifest = yield* Schema.decodeUnknownEffect(KnowledgeManifestSchema)(manifestUnknown);
+    const sourceRoot = path.join(packageRoot, KNOWLEDGE_SOURCE_DIR);
+    return { sourceRoot, manifest };
+});
+/** Inspect one complete Knowledge package, including manifest-level profile diagnostics. */
+export const inspectKnowledgePackage = Effect.fn("Knowledge.inspectPackage")(function* (packageRoot) {
+    const { sourceRoot, manifest } = yield* readKnowledgePackageManifest(packageRoot);
+    const inspected = yield* inspectKnowledgeBundle(sourceRoot);
+    const inspection = {
+        ...inspected,
+        diagnostics: manifest.description?.trim().length === 0 || manifest.description === undefined
+            ? [missingManifestDescription(), ...inspected.diagnostics]
+            : inspected.diagnostics,
+    };
+    return { name: manifest.name, sourceRoot, manifest, inspection };
+});
+//# sourceMappingURL=package-inspection.js.map

package/dist/src/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/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/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/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/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/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/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/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/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/lint/catalog/hook.js

@@ -0,0 +1,15 @@
+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,
+];
+//# sourceMappingURL=hook.js.map

package/dist/src/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/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/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/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/lint/catalog/knowledge.d.ts

@@ -0,0 +1,11 @@
+import type { KnowledgeRuleContext } from "../context.js";
+import type { LintRule } from "../rule.js";
+/**
+ * Publish-safe `knowledge/*` catalog: the manifest envelope rules only. The
+ * publish gate validates OKF bundle content through package validation, so
+ * the inspection-backed diagnostic rules do not run there.
+ */
+export declare const publishKnowledgeRules: ReadonlyArray<LintRule<KnowledgeRuleContext>>;
+export declare const knowledgeRules: ReadonlyArray<LintRule<KnowledgeRuleContext>>;
+export { knowledgeDiagnosticRuleDefinitions, knowledgeDiagnosticRules, } from "./knowledge/diagnostics.js";
+//# sourceMappingURL=knowledge.d.ts.map

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

@@ -0,0 +1,15 @@
+import { knowledgeEnvelopeRules } from "./knowledge/envelope.js";
+import { orderedEnvelopeRules } from "./shared/envelope-rules.js";
+import { knowledgeDiagnosticRules } from "./knowledge/diagnostics.js";
+/**
+ * Publish-safe `knowledge/*` catalog: the manifest envelope rules only. The
+ * publish gate validates OKF bundle content through package validation, so
+ * the inspection-backed diagnostic rules do not run there.
+ */
+export const publishKnowledgeRules = orderedEnvelopeRules(knowledgeEnvelopeRules);
+export const knowledgeRules = [
+    ...publishKnowledgeRules,
+    ...knowledgeDiagnosticRules,
+];
+export { knowledgeDiagnosticRuleDefinitions, knowledgeDiagnosticRules, } from "./knowledge/diagnostics.js";
+//# sourceMappingURL=knowledge.js.map

package/dist/src/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/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