@agentxm/extension-content 0.38.0 → 0.41.0

package/dist/src/index.js

@@ -12,13 +12,13 @@
  */
 export { AGENT_SKILLS_COMPATIBILITY_MAX_LENGTH, AGENT_SKILLS_DESCRIPTION_MAX_LENGTH, AGENT_SKILLS_FRONTMATTER_FIELDS, AGENT_SKILLS_NAME_MAX_LENGTH, AGENT_SKILLS_REFERENCE_VALIDATOR_URL, AGENT_SKILLS_SPECIFICATION_URL, AGENT_SKILLS_STANDARD_REVISION, } from "./content/agent-skills-standard.js";
 export { FRONTMATTER_PARSE_FALLBACK_REASON, FrontmatterParseFailure, parseFrontmatterEffect, parseFrontmatterSync, } from "./content/frontmatter.js";
-export { SkillFrontmatterSchema, parseSkillMd, validateSkillFrontmatter, } from "./content/skill-content.js";
+export { SkillFrontmatterSchema, parseSkillMd, extractSkillMetadata, validateSkillFrontmatter, } from "./content/skill-content.js";
 export {} from "./content/skill-types.js";
-export { SubagentContentError, parseSubagentMd, } from "./content/subagent-content.js";
-export { ArchiveGuardrailError, ZIP_LOCAL_SIGNATURE, checkForbiddenSourceEntries, parseZipCentralDirectory, validateArchive, } from "./packaging/archive-guardrails.js";
+export { SubagentContentError, loadSubagentPackage, nativeSubagentFormat, parseNativeSubagent, readSubagentPackage, selectSubagentImplementation, } from "./content/subagent-content.js";
+export { ArchiveGuardrailError, ZIP_LOCAL_SIGNATURE, checkForbiddenSourceEntries, defaultReadEntry, parseZipCentralDirectory, validateArchive, } from "./packaging/archive-guardrails.js";
 export { FilteredPackageError, validateFilteredPackage, } from "./packaging/filtered-package-validation.js";
 export { IngestLimitError, IngestUnsupportedContentTypeError, REGISTRY_PUBLISH_MAX_ARCHIVE_BYTES, REGISTRY_PUBLISH_MAX_REQUEST_BYTES, enforceArchiveContentType, enforceArchiveSizeLimit, enforceRequestSizeLimit, } from "./packaging/ingest-limits.js";
-export { defaultReadEntry, normalizePublishInput, } from "./packaging/input-normalization.js";
+export { normalizePublishInput, } from "./packaging/input-normalization.js";
 export { MANIFEST_FILENAME_BY_TYPE, MANIFEST_FILENAMES, MANIFEST_SCHEMA_BY_TYPE, ManifestError, ManifestIdentitySchema, manifestFilenameForType, extensionTypeForManifestFilename, manifestSchemaForType, resolveManifest, validateDeclaredManifestAlignment, validateManifestHasNoAgentsField, } from "./packaging/manifest-policy.js";
 export { readExtensionManifest } from "./packaging/manifest-file.js";
 //# sourceMappingURL=index.js.map

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

@@ -9,11 +9,11 @@ export declare const readKnowledgePackageManifest: (packageRoot: string) => Effe
     sourceRoot: string;
     manifest: {
         readonly name: string & import("effect/Brand").Brand<"ExtensionName">;
-        readonly type: "knowledge";
         readonly format: {
             readonly name: "okf";
             readonly version: "0.2";
         };
+        readonly type: "knowledge";
         readonly owner: string & import("effect/Brand").Brand<"Handle">;
         readonly version: string & import("effect/Brand").Brand<"Version">;
         readonly bundleRoot: "src";
@@ -24,12 +24,12 @@ export declare const readKnowledgePackageManifest: (packageRoot: string) => Effe
         } | 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 fallback?: "auto" | "none" | undefined;
         readonly publish?: {
-            readonly visibility?: "public" | "private" | undefined;
             readonly ignore?: readonly string[] | undefined;
+            readonly visibility?: "public" | "private" | undefined;
         } | undefined;
         readonly keywords?: readonly string[] | undefined;
         readonly repository?: string | {
@@ -61,18 +61,18 @@ export declare const readKnowledgePackageManifest: (packageRoot: string) => Effe
         readonly $schema?: string | undefined;
         readonly instructionEntry?: boolean;
     };
-}, import("effect/PlatformError").PlatformError | ManifestError | Schema.SchemaError, FileSystem.FileSystem | Path.Path>;
+}, Schema.SchemaError | import("effect/PlatformError").PlatformError | ManifestError, 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 type: "knowledge";
         readonly owner: string & import("effect/Brand").Brand<"Handle">;
         readonly version: string & import("effect/Brand").Brand<"Version">;
         readonly bundleRoot: "src";
@@ -83,12 +83,12 @@ export declare const inspectKnowledgePackage: (packageRoot: string) => Effect.Ef
         } | 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 fallback?: "auto" | "none" | undefined;
         readonly publish?: {
-            readonly visibility?: "public" | "private" | undefined;
             readonly ignore?: readonly string[] | undefined;
+            readonly visibility?: "public" | "private" | undefined;
         } | undefined;
         readonly keywords?: readonly string[] | undefined;
         readonly repository?: string | {

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

@@ -1,13 +1,13 @@
 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 { HookManifestSchema, HOOK_MANIFEST_FILENAME, referencedHookPackageFiles, } from "@agentxm/extension-model/unstable/hooks/manifest-schema";
 import { isManifestJsonParseFailure } from "../shared/manifest-json.js";
-const RULE_ID = "hook/entrypoint-exists";
+const RULE_ID = "hook/referenced-files-exist";
 const decodeHookManifest = Schema.decodeUnknownResult(HookManifestSchema);
 export const entrypointExistsRule = {
     id: RULE_ID,
-    description: "hook.json entrypoint points to a package file.",
+    description: "Every Hook implementation, declared asset, and fixture references a package file.",
     kind: "advisory",
     severity: "error",
     check: (context) => {
@@ -22,18 +22,21 @@ export const entrypointExistsRule = {
         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 },
-                },
-            ]);
+        return Effect.gen(function* () {
+            const findings = [];
+            for (const file of referencedHookPackageFiles(decoded.success)) {
+                if (!(yield* context.files.exists(file))) {
+                    findings.push({
+                        kind: "advisory",
+                        ruleId: RULE_ID,
+                        severity: "error",
+                        message: `hook.json references missing package file '${file}'. Add the file or update its reference.`,
+                        location: { file: HOOK_MANIFEST_FILENAME },
+                    });
+                }
+            }
+            return findings;
+        });
     },
 };
 //# sourceMappingURL=entrypoint-exists.js.map

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

@@ -2,5 +2,18 @@
  * `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>>;
+import * as Effect from "effect/Effect";
+export declare const hookEnvelopeRules: {
+    manifestSchemaValid: {
+        check: (context: HookRuleContext) => Effect.Effect<readonly import("../../rule.ts").AdvisoryFinding[], never, never>;
+        kind: "advisory";
+        id: string;
+        description: string;
+        severity: import("../../rule.ts").Severity;
+    };
+    manifestPresent: import("../../rule.ts").AdvisoryRule<HookRuleContext<import("../../context.js").HookContent>, never>;
+    manifestKeysRecognized: import("../../rule.ts").AdvisoryRule<HookRuleContext<import("../../context.js").HookContent>, never>;
+    standaloneDeclarationValid: import("../../rule.ts").AdvisoryRule<HookRuleContext<import("../../context.js").HookContent>, never>;
+    recommendedPacksValid: import("../../rule.ts").AdvisoryRule<HookRuleContext<import("../../context.js").HookContent>, never>;
+};
 //# sourceMappingURL=envelope.d.ts.map

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

@@ -2,14 +2,37 @@
  * `hook/*` manifest envelope — see `../shared/envelope-rules.ts`.
  */
 import { HookManifestSchema, HOOK_MANIFEST_FILENAME, } from "@agentxm/extension-model/unstable/hooks/manifest-schema";
+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";
+import { isManifestJsonParseFailure } from "../shared/manifest-json.js";
 import { makeManifestEnvelopeRules } from "../shared/envelope-rules.js";
-export const hookEnvelopeRules = makeManifestEnvelopeRules({
+const envelope = 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`).",
+    presentMissingMessage: "hook.json is missing. Create hook.json with the required manifest fields (`owner`, `type`, `name`, `version`, `implementations`).",
     schemaDescription: "hook.json defines a valid hook manifest.",
 });
+export const hookEnvelopeRules = {
+    ...envelope,
+    manifestSchemaValid: {
+        ...envelope.manifestSchemaValid,
+        check: (context) => {
+            const input = context.subject.hookJson;
+            if (input === undefined || isManifestJsonParseFailure(input))
+                return envelope.manifestSchemaValid.check(context);
+            const decoded = Schema.decodeUnknownResult(HookManifestSchema)(input, {
+                onExcessProperty: "error",
+                errors: "all",
+            });
+            return Effect.succeed(Result.isSuccess(decoded)
+                ? []
+                : issuesToFindings("hook/manifest-schema-valid", "error", HOOK_MANIFEST_FILENAME, decoded.failure.issue));
+        },
+    },
+};
 //# sourceMappingURL=envelope.js.map

package/dist/src/lint/catalog/hook/native-bindings-supported.d.ts

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

package/dist/src/lint/catalog/hook/native-bindings-supported.js

@@ -0,0 +1,39 @@
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { AGENTS_BY_ID, installable } from "@agentxm/extension-model/unstable/agent-capabilities";
+import { HookManifestSchema, HOOK_MANIFEST_FILENAME, } from "@agentxm/extension-model/unstable/hooks/manifest-schema";
+import { isManifestJsonParseFailure } from "../shared/manifest-json.js";
+const RULE_ID = "hook/native-bindings-supported";
+export const nativeBindingsSupportedRule = {
+    id: RULE_ID,
+    description: "Native Hook events preserve every required outcome and modification operation.",
+    kind: "advisory",
+    severity: "error",
+    check: (context) => {
+        if (context.subject.hookJson === undefined ||
+            isManifestJsonParseFailure(context.subject.hookJson))
+            return Effect.succeed([]);
+        const decoded = Schema.decodeUnknownResult(HookManifestSchema)(context.subject.hookJson, {
+            onExcessProperty: "error",
+        });
+        if (Result.isFailure(decoded))
+            return Effect.succeed([]);
+        const findings = [];
+        for (const implementation of decoded.success.implementations) {
+            for (const binding of implementation.bindings) {
+                const verdict = installable(AGENTS_BY_ID[implementation.protocol], binding);
+                if (!verdict.installable)
+                    findings.push({
+                        kind: "advisory",
+                        ruleId: RULE_ID,
+                        severity: "error",
+                        message: `Implementation '${implementation.id}', binding '${binding.id}': ${verdict.reason}`,
+                        location: { file: HOOK_MANIFEST_FILENAME },
+                    });
+            }
+        }
+        return Effect.succeed(findings);
+    },
+};
+//# sourceMappingURL=native-bindings-supported.js.map

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

@@ -1,13 +1,11 @@
 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";
+import { nativeBindingsSupportedRule } from "./hook/native-bindings-supported.js";
 export const hookRules = [
     hookEnvelopeRules.manifestPresent,
     hookEnvelopeRules.manifestSchemaValid,
     hookEnvelopeRules.manifestKeysRecognized,
-    decisionPortabilityRule,
-    matcherRawPortabilityRule,
+    nativeBindingsSupportedRule,
     entrypointExistsRule,
     hookEnvelopeRules.standaloneDeclarationValid,
     hookEnvelopeRules.recommendedPacksValid,

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

@@ -39,6 +39,7 @@ import type { SkillFileAccessor, SkillRuleContext } from "../../context.js";
  * @experimental This API is unstable and may change without notice.
  */
 export interface InstalledSkillInfo {
+    readonly validationPurpose?: "authoring" | "management";
     readonly isNative: boolean;
     readonly skillJson: unknown;
     readonly expectedName?: string;

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

@@ -44,6 +44,9 @@
  */
 export const buildSkillRuleContexts = (input) => input.installedSkills.map((info) => ({
     subject: {
+        ...(info.validationPurpose === undefined
+            ? {}
+            : { validationPurpose: info.validationPurpose }),
         isNative: info.isNative,
         skillJson: info.skillJson,
         ...(info.expectedName === undefined ? {} : { expectedName: info.expectedName }),

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

@@ -28,7 +28,7 @@
 import type { LintRule } from "../rule.js";
 import type { SkillRuleContext } from "../context.js";
 /**
- * Ordered v1 `skill/*` rule catalog. Declaration order is the evaluation
+ * Ordered `skill/*` rule catalog. Declaration order is the evaluation
  * order within a single `evaluateContexts` call (deterministic ordering is
  * test-observable; see `evaluate.ts`).
  *

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

@@ -25,6 +25,7 @@
  * @experimental This API is unstable and may change without notice.
  * @packageDocumentation
  */
+import * as Effect from "effect/Effect";
 import { skillMdPresentRule } from "./skill/skill-md-present.js";
 import { manifestPresentRule } from "./skill/manifest-present.js";
 import { frontmatterParseableRule } from "./skill/frontmatter-parseable.js";
@@ -34,7 +35,16 @@ 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
+ * Authoring rules do not run as routine health checks for acquired content.
+ * Skill presence remains a management obligation; accepted identity, integrity,
+ * ownership and projection checks are supplied by the workspace catalog.
+ */
+const authoringOnly = (rule) => ({
+    ...rule,
+    check: (context) => context.subject.validationPurpose === "management" ? Effect.succeed([]) : rule.check(context),
+});
+/**
+ * Ordered `skill/*` rule catalog. Declaration order is the evaluation
  * order within a single `evaluateContexts` call (deterministic ordering is
  * test-observable; see `evaluate.ts`).
  *
@@ -42,12 +52,14 @@ import { standaloneDeclarationValidRule } from "./skill/standalone-declaration-v
  */
 export const skillRules = [
     skillMdPresentRule,
-    manifestPresentRule,
-    frontmatterParseableRule,
-    frontmatterStandardValidRule,
-    manifestSchemaValidRule,
-    manifestKeysRecognizedRule,
-    standaloneDeclarationValidRule,
-    recommendedPacksValidRule,
+    ...[
+        manifestPresentRule,
+        frontmatterParseableRule,
+        frontmatterStandardValidRule,
+        manifestSchemaValidRule,
+        manifestKeysRecognizedRule,
+        standaloneDeclarationValidRule,
+        recommendedPacksValidRule,
+    ].map(authoringOnly),
 ];
 //# sourceMappingURL=skill.js.map

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

@@ -9,7 +9,7 @@ export const subagentEnvelopeRules = makeManifestEnvelopeRules({
     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`).",
+    presentMissingMessage: "subagent.json is missing. Create the identity fields and either a described portable core or explicit native implementations.",
     schemaDescription: "subagent.json defines a valid subagent manifest.",
 });
 //# sourceMappingURL=envelope.js.map

package/dist/src/lint/catalog-metadata.js

@@ -158,18 +158,12 @@ export const lintCatalogRuleMetadata = defineLintCatalog([
         views: bothViews,
     },
     {
-        id: "hook/decision-portability",
-        defaultSeverity: "warning",
-        group: "hook",
-        views: bothViews,
-    },
-    {
-        id: "hook/matcher-raw-portability",
-        defaultSeverity: "warning",
+        id: "hook/native-bindings-supported",
+        defaultSeverity: "error",
         group: "hook",
         views: bothViews,
     },
-    { id: "hook/entrypoint-exists", defaultSeverity: "error", group: "hook", views: bothViews },
+    { id: "hook/referenced-files-exist", defaultSeverity: "error", group: "hook", views: bothViews },
     {
         id: "hook/standalone-declaration-valid",
         defaultSeverity: "warning",

package/dist/src/lint/context.d.ts

@@ -139,6 +139,8 @@ export interface SkillRuleContext<S = SkillContent> {
  * @experimental This API is unstable and may change without notice.
  */
 export interface SkillContent {
+    /** Authored checks are opt-in for acquired content; normal health checks use management. */
+    readonly validationPurpose?: "authoring" | "management";
     readonly isNative: boolean;
     readonly skillJson: unknown;
     /** Agent-facing skill directory name used for the standard name-match check. */

package/dist/src/packaging/archive-guardrails.d.ts

@@ -23,6 +23,7 @@ export interface ArchiveGuardrailLimits {
     readonly maxCompressionRatio?: number;
 }
 export declare const parseZipCentralDirectory: (buf: Uint8Array) => Effect.Effect<readonly ZipEntry[], ArchiveGuardrailError>;
+export declare const defaultReadEntry: (archiveBytes: Uint8Array, entry: ZipEntry) => Effect.Effect<Uint8Array, ArchiveGuardrailError>;
 /**
  * Reject archives carrying build or secret leftovers: any `node_modules` or
  * `.git` path segment, and `.env` / `.env.*` files. Kept out of