@agentxm/extension-content 0.38.0 → 0.41.0

package/dist/src/packaging/manifest-policy.d.ts

@@ -29,7 +29,7 @@ export declare const extensionTypeForManifestFilename: (fileName: string) => Ext
 export declare const manifestFilenameForType: (type: ExtensionType) => string;
 export declare const ManifestIdentitySchema: Schema.Struct<{
     readonly owner: Schema.brand<Schema.String, "Handle">;
-    readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack")[]>;
+    readonly type: Schema.Literals<readonly ("subagent" | "skill" | "mcp-server" | "rule" | "hook" | "knowledge" | "pack")[]>;
     readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
     readonly version: Schema.brand<Schema.String, "Version">;
 }>;
@@ -333,13 +333,33 @@ export declare const MANIFEST_SCHEMA_BY_TYPE: {
         readonly $schema: Schema.optional<Schema.String>;
     }>;
     subagent: Schema.Struct<{
-        readonly type: Schema.Literal<"subagent">;
-        readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
         readonly enhances: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
         readonly requires: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
-        readonly fallback: Schema.optional<Schema.Literals<readonly ["auto", "none"]>>;
         readonly recommendedPacks: Schema.optional<Schema.$Array<Schema.brand<Schema.NonEmptyString, "PackSpec">>>;
         readonly standalone: Schema.optional<Schema.Boolean>;
+        readonly type: Schema.Literal<"subagent">;
+        readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly core: Schema.optional<Schema.Struct<{
+            readonly instructions: Schema.String;
+            readonly name: Schema.optional<Schema.String>;
+        }>>;
+        readonly implementations: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"customized">;
+            readonly source: Schema.optional<Schema.Never>;
+            readonly configuration: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            readonly instructions: Schema.optional<Schema.Struct<{
+                readonly mode: Schema.Literals<readonly ["append", "replace"]>;
+                readonly source: Schema.String;
+            }>>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"native">;
+            readonly source: Schema.String;
+            readonly configuration: Schema.optional<Schema.Never>;
+            readonly instructions: Schema.optional<Schema.Never>;
+        }>]>>>;
+        readonly fallback: Schema.optional<Schema.Never>;
+        readonly agentOverrides: Schema.optional<Schema.Never>;
+        readonly agents: Schema.optional<Schema.Never>;
         readonly publish: Schema.optional<Schema.Struct<{
             readonly visibility: Schema.optional<Schema.Literals<readonly ["public", "private"]>>;
             readonly ignore: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
@@ -476,44 +496,89 @@ export declare const MANIFEST_SCHEMA_BY_TYPE: {
         readonly $schema: Schema.optional<Schema.String>;
     }>;
     hook: Schema.Struct<{
+        readonly enhances: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+        readonly requires: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+        readonly recommendedPacks: Schema.optional<Schema.$Array<Schema.brand<Schema.NonEmptyString, "PackSpec">>>;
+        readonly standalone: Schema.optional<Schema.Boolean>;
         readonly type: Schema.Literal<"hook">;
         readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
         readonly title: Schema.optional<Schema.NonEmptyString>;
-        readonly runtime: Schema.Literals<readonly ["bash", "node", "python"]>;
-        readonly entrypoint: Schema.NonEmptyString;
-        readonly bindings: Schema.$Array<Schema.Struct<{
-            readonly on: Schema.Literals<readonly ["session.start", "prompt.submit", "turn.end", "tool.pre", "tool.post", "subagent.stop", "compaction.pre"]>;
-            readonly match: Schema.optional<Schema.Struct<{
-                readonly tools: Schema.optional<Schema.NonEmptyArray<Schema.Literals<readonly ["file.read", "file.write", "file.edit", "shell.exec", "web.fetch", "mcp.call"]>>>;
-            }>>;
-            readonly matcherRaw: Schema.optional<Schema.NonEmptyString>;
-            readonly targets: Schema.optional<Schema.$Record<Schema.String, Schema.Struct<{
-                readonly matcherRaw: Schema.optional<Schema.NonEmptyString>;
-            }>>>;
+        readonly implementations: Schema.NonEmptyArray<Schema.Struct<{
+            readonly id: Schema.NonEmptyString;
+            readonly protocol: Schema.Literals<readonly ["adal", "fx", "muse-code", "mimo-code", "coder-agents", "aider-desk", "amp", "antigravity", "antigravity-cli", "augment", "claude-code", "cline", "codearts-agent", "codebuddy", "codemaker", "codestudio", "codex", "command-code", "continue", "cortex", "crush", "cursor", "deepagents", "devin", "dexto", "droid", "firebender", "forgecode", "gemini-cli", "github-copilot-cli", "goose", "grok-cli", "hermes", "ibm-bob", "iflow-cli", "junie", "lingma", "kilo", "kimi-cli", "kiro-cli", "kode", "mcpjam", "minimax-code", "mistral-vibe", "mux", "neovate", "openclaw", "opencode", "openhands", "ona", "pi", "vscode", "pochi", "qoder", "qoder-cn", "qwen-code", "replit", "roo", "rovodev", "tabnine-cli", "trae-cn", "trae", "warp", "windsurf", "zencoder", "zed", "zenflow"]>;
             readonly requires: Schema.optional<Schema.Struct<{
-                readonly decision: Schema.Union<readonly [Schema.Struct<{
-                    readonly kind: Schema.Literal<"observe">;
-                }>, Schema.Struct<{
-                    readonly kind: Schema.Literal<"block">;
+                readonly hostVersion: Schema.optional<Schema.brand<Schema.NonEmptyString, "VersionRange">>;
+                readonly profiles: Schema.optional<Schema.NonEmptyArray<Schema.NonEmptyString>>;
+                readonly platforms: Schema.optional<Schema.NonEmptyArray<Schema.Literals<readonly ["darwin", "linux", "win32"]>>>;
+                readonly scopes: Schema.optional<Schema.NonEmptyArray<Schema.Literals<readonly ["project", "user"]>>>;
+            }>>;
+            readonly bindings: Schema.NonEmptyArray<Schema.Struct<{
+                readonly id: Schema.NonEmptyString;
+                readonly event: Schema.NonEmptyString;
+                readonly matcher: Schema.optional<Schema.NonEmptyString>;
+                readonly handler: Schema.Struct<{
+                    readonly type: Schema.Literal<"command">;
+                    readonly name: Schema.optional<Schema.NonEmptyString>;
+                    readonly runtime: Schema.Literals<readonly ["bash", "node", "python"]>;
+                    readonly entrypoint: Schema.NonEmptyString;
+                    readonly args: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly config: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly env: Schema.NonEmptyString;
+                    }>]>>>;
+                    readonly env: Schema.optional<Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly config: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly env: Schema.NonEmptyString;
+                    }>]>>>;
+                    readonly timeoutMs: Schema.optional<Schema.Int>;
+                }>;
+                readonly requires: Schema.optional<Schema.Struct<{
                     readonly outcomes: Schema.optional<Schema.NonEmptyArray<Schema.Literals<readonly ["allow", "deny", "ask"]>>>;
-                }>, Schema.Struct<{
-                    readonly kind: Schema.Literal<"modify">;
                     readonly operations: Schema.optional<Schema.NonEmptyArray<Schema.Literals<readonly ["modify-input", "inject-context", "modify-output", "synthesize", "redact"]>>>;
-                }>]>;
+                }>>;
             }>>;
         }>>;
-        readonly timeoutMs: Schema.optional<Schema.Int>;
-        readonly capabilities: Schema.optional<Schema.Struct<{
-            readonly network: Schema.optional<Schema.Boolean>;
-            readonly filesystemWrite: Schema.optional<Schema.Boolean>;
-            readonly exec: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
-            readonly env: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
-        }>>;
-        readonly enhances: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
-        readonly requires: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
-        readonly fallback: Schema.optional<Schema.Literals<readonly ["auto", "none"]>>;
-        readonly recommendedPacks: Schema.optional<Schema.$Array<Schema.brand<Schema.NonEmptyString, "PackSpec">>>;
-        readonly standalone: Schema.optional<Schema.Boolean>;
+        readonly configuration: Schema.optional<Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"string">;
+            readonly default: Schema.optional<Schema.String>;
+            readonly secret: Schema.optional<Schema.Boolean>;
+            readonly allowEmpty: Schema.optional<Schema.Boolean>;
+            readonly minLength: Schema.optional<Schema.Int>;
+            readonly maxLength: Schema.optional<Schema.Int>;
+            readonly description: Schema.optional<Schema.NonEmptyString>;
+            readonly required: Schema.optional<Schema.Boolean>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"number">;
+            readonly default: Schema.optional<Schema.Finite>;
+            readonly minimum: Schema.optional<Schema.Finite>;
+            readonly maximum: Schema.optional<Schema.Finite>;
+            readonly description: Schema.optional<Schema.NonEmptyString>;
+            readonly required: Schema.optional<Schema.Boolean>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"boolean">;
+            readonly default: Schema.optional<Schema.Boolean>;
+            readonly description: Schema.optional<Schema.NonEmptyString>;
+            readonly required: Schema.optional<Schema.Boolean>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"enum">;
+            readonly values: Schema.NonEmptyArray<Schema.NonEmptyString>;
+            readonly default: Schema.optional<Schema.NonEmptyString>;
+            readonly description: Schema.optional<Schema.NonEmptyString>;
+            readonly required: Schema.optional<Schema.Boolean>;
+        }>]>>>;
+        readonly assets: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+        readonly fixtures: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.NonEmptyString;
+            readonly implementation: Schema.NonEmptyString;
+            readonly binding: Schema.NonEmptyString;
+            readonly input: Schema.NonEmptyString;
+            readonly expect: Schema.Struct<{
+                readonly exitCode: Schema.Int;
+                readonly stdout: Schema.optional<Schema.NonEmptyString>;
+                readonly stderr: Schema.optional<Schema.NonEmptyString>;
+            }>;
+        }>>>;
         readonly publish: Schema.optional<Schema.Struct<{
             readonly visibility: Schema.optional<Schema.Literals<readonly ["public", "private"]>>;
             readonly ignore: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
@@ -607,6 +672,71 @@ export declare const MANIFEST_SCHEMA_BY_TYPE: {
 };
 export type ExtensionManifest = Schema.Schema.Type<(typeof MANIFEST_SCHEMA_BY_TYPE)[ExtensionType]>;
 export declare const manifestSchemaForType: (type: ExtensionType) => Schema.Struct<{
+    readonly enhances: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    readonly requires: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    readonly recommendedPacks: Schema.optional<Schema.$Array<Schema.brand<Schema.NonEmptyString, "PackSpec">>>;
+    readonly standalone: Schema.optional<Schema.Boolean>;
+    readonly type: Schema.Literal<"subagent">;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly core: Schema.optional<Schema.Struct<{
+        readonly instructions: Schema.String;
+        readonly name: Schema.optional<Schema.String>;
+    }>>;
+    readonly implementations: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"customized">;
+        readonly source: Schema.optional<Schema.Never>;
+        readonly configuration: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly instructions: Schema.optional<Schema.Struct<{
+            readonly mode: Schema.Literals<readonly ["append", "replace"]>;
+            readonly source: Schema.String;
+        }>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"native">;
+        readonly source: Schema.String;
+        readonly configuration: Schema.optional<Schema.Never>;
+        readonly instructions: Schema.optional<Schema.Never>;
+    }>]>>>;
+    readonly fallback: Schema.optional<Schema.Never>;
+    readonly agentOverrides: Schema.optional<Schema.Never>;
+    readonly agents: Schema.optional<Schema.Never>;
+    readonly publish: Schema.optional<Schema.Struct<{
+        readonly visibility: Schema.optional<Schema.Literals<readonly ["public", "private"]>>;
+        readonly ignore: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    }>>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly owner: Schema.brand<Schema.String, "Handle">;
+    readonly version: Schema.brand<Schema.String, "Version">;
+    readonly description: Schema.optional<Schema.String>;
+    readonly keywords: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    readonly repository: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly type: Schema.optional<Schema.NonEmptyString>;
+        readonly url: Schema.NonEmptyString;
+        readonly directory: Schema.optional<Schema.NonEmptyString>;
+    }>]>>;
+    readonly homepage: Schema.optional<Schema.String>;
+    readonly license: Schema.optional<Schema.String>;
+    readonly bugs: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly url: Schema.optional<Schema.NonEmptyString>;
+        readonly email: Schema.optional<Schema.NonEmptyString>;
+    }>]>>;
+    readonly authors: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly email: Schema.optional<Schema.String>;
+        readonly url: Schema.optional<Schema.String>;
+    }>>>;
+    readonly packages: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly purl: Schema.brand<Schema.NonEmptyString, "PackageIdentityPurl">;
+        readonly versionRange: Schema.optional<Schema.brand<Schema.decodeTo<Schema.toType<Schema.Struct<{
+            readonly raw: Schema.NonEmptyString;
+            readonly scheme: Schema.NonEmptyString;
+            readonly constraints: Schema.$Array<Schema.Struct<{
+                readonly comparator: Schema.Literals<readonly ["=", "!=", "<", "<=", ">", ">="]>;
+                readonly version: Schema.NonEmptyString;
+            }>>;
+        }>>, Schema.NonEmptyString, never, never>, "VersRange">>;
+    }>>>;
+    readonly $schema: Schema.optional<Schema.String>;
+}> | Schema.Struct<{
     readonly type: Schema.Literal<"skill">;
     readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
     readonly enhances: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
@@ -901,51 +1031,6 @@ export declare const manifestSchemaForType: (type: ExtensionType) => Schema.Stru
         }>>, Schema.NonEmptyString, never, never>, "VersRange">>;
     }>>>;
     readonly $schema: Schema.optional<Schema.String>;
-}> | Schema.Struct<{
-    readonly type: Schema.Literal<"subagent">;
-    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
-    readonly enhances: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
-    readonly requires: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
-    readonly fallback: Schema.optional<Schema.Literals<readonly ["auto", "none"]>>;
-    readonly recommendedPacks: Schema.optional<Schema.$Array<Schema.brand<Schema.NonEmptyString, "PackSpec">>>;
-    readonly standalone: Schema.optional<Schema.Boolean>;
-    readonly publish: Schema.optional<Schema.Struct<{
-        readonly visibility: Schema.optional<Schema.Literals<readonly ["public", "private"]>>;
-        readonly ignore: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
-    }>>;
-    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-    readonly owner: Schema.brand<Schema.String, "Handle">;
-    readonly version: Schema.brand<Schema.String, "Version">;
-    readonly description: Schema.optional<Schema.String>;
-    readonly keywords: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
-    readonly repository: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Struct<{
-        readonly type: Schema.optional<Schema.NonEmptyString>;
-        readonly url: Schema.NonEmptyString;
-        readonly directory: Schema.optional<Schema.NonEmptyString>;
-    }>]>>;
-    readonly homepage: Schema.optional<Schema.String>;
-    readonly license: Schema.optional<Schema.String>;
-    readonly bugs: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Struct<{
-        readonly url: Schema.optional<Schema.NonEmptyString>;
-        readonly email: Schema.optional<Schema.NonEmptyString>;
-    }>]>>;
-    readonly authors: Schema.optional<Schema.$Array<Schema.Struct<{
-        readonly name: Schema.String;
-        readonly email: Schema.optional<Schema.String>;
-        readonly url: Schema.optional<Schema.String>;
-    }>>>;
-    readonly packages: Schema.optional<Schema.$Array<Schema.Struct<{
-        readonly purl: Schema.brand<Schema.NonEmptyString, "PackageIdentityPurl">;
-        readonly versionRange: Schema.optional<Schema.brand<Schema.decodeTo<Schema.toType<Schema.Struct<{
-            readonly raw: Schema.NonEmptyString;
-            readonly scheme: Schema.NonEmptyString;
-            readonly constraints: Schema.$Array<Schema.Struct<{
-                readonly comparator: Schema.Literals<readonly ["=", "!=", "<", "<=", ">", ">="]>;
-                readonly version: Schema.NonEmptyString;
-            }>>;
-        }>>, Schema.NonEmptyString, never, never>, "VersRange">>;
-    }>>>;
-    readonly $schema: Schema.optional<Schema.String>;
 }> | Schema.Struct<{
     readonly type: Schema.Literal<"pack">;
     readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
@@ -1042,44 +1127,89 @@ export declare const manifestSchemaForType: (type: ExtensionType) => Schema.Stru
     }>>>;
     readonly $schema: Schema.optional<Schema.String>;
 }> | Schema.Struct<{
+    readonly enhances: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    readonly requires: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    readonly recommendedPacks: Schema.optional<Schema.$Array<Schema.brand<Schema.NonEmptyString, "PackSpec">>>;
+    readonly standalone: Schema.optional<Schema.Boolean>;
     readonly type: Schema.Literal<"hook">;
     readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
     readonly title: Schema.optional<Schema.NonEmptyString>;
-    readonly runtime: Schema.Literals<readonly ["bash", "node", "python"]>;
-    readonly entrypoint: Schema.NonEmptyString;
-    readonly bindings: Schema.$Array<Schema.Struct<{
-        readonly on: Schema.Literals<readonly ["session.start", "prompt.submit", "turn.end", "tool.pre", "tool.post", "subagent.stop", "compaction.pre"]>;
-        readonly match: Schema.optional<Schema.Struct<{
-            readonly tools: Schema.optional<Schema.NonEmptyArray<Schema.Literals<readonly ["file.read", "file.write", "file.edit", "shell.exec", "web.fetch", "mcp.call"]>>>;
-        }>>;
-        readonly matcherRaw: Schema.optional<Schema.NonEmptyString>;
-        readonly targets: Schema.optional<Schema.$Record<Schema.String, Schema.Struct<{
-            readonly matcherRaw: Schema.optional<Schema.NonEmptyString>;
-        }>>>;
+    readonly implementations: Schema.NonEmptyArray<Schema.Struct<{
+        readonly id: Schema.NonEmptyString;
+        readonly protocol: Schema.Literals<readonly ["adal", "fx", "muse-code", "mimo-code", "coder-agents", "aider-desk", "amp", "antigravity", "antigravity-cli", "augment", "claude-code", "cline", "codearts-agent", "codebuddy", "codemaker", "codestudio", "codex", "command-code", "continue", "cortex", "crush", "cursor", "deepagents", "devin", "dexto", "droid", "firebender", "forgecode", "gemini-cli", "github-copilot-cli", "goose", "grok-cli", "hermes", "ibm-bob", "iflow-cli", "junie", "lingma", "kilo", "kimi-cli", "kiro-cli", "kode", "mcpjam", "minimax-code", "mistral-vibe", "mux", "neovate", "openclaw", "opencode", "openhands", "ona", "pi", "vscode", "pochi", "qoder", "qoder-cn", "qwen-code", "replit", "roo", "rovodev", "tabnine-cli", "trae-cn", "trae", "warp", "windsurf", "zencoder", "zed", "zenflow"]>;
         readonly requires: Schema.optional<Schema.Struct<{
-            readonly decision: Schema.Union<readonly [Schema.Struct<{
-                readonly kind: Schema.Literal<"observe">;
-            }>, Schema.Struct<{
-                readonly kind: Schema.Literal<"block">;
+            readonly hostVersion: Schema.optional<Schema.brand<Schema.NonEmptyString, "VersionRange">>;
+            readonly profiles: Schema.optional<Schema.NonEmptyArray<Schema.NonEmptyString>>;
+            readonly platforms: Schema.optional<Schema.NonEmptyArray<Schema.Literals<readonly ["darwin", "linux", "win32"]>>>;
+            readonly scopes: Schema.optional<Schema.NonEmptyArray<Schema.Literals<readonly ["project", "user"]>>>;
+        }>>;
+        readonly bindings: Schema.NonEmptyArray<Schema.Struct<{
+            readonly id: Schema.NonEmptyString;
+            readonly event: Schema.NonEmptyString;
+            readonly matcher: Schema.optional<Schema.NonEmptyString>;
+            readonly handler: Schema.Struct<{
+                readonly type: Schema.Literal<"command">;
+                readonly name: Schema.optional<Schema.NonEmptyString>;
+                readonly runtime: Schema.Literals<readonly ["bash", "node", "python"]>;
+                readonly entrypoint: Schema.NonEmptyString;
+                readonly args: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly config: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly env: Schema.NonEmptyString;
+                }>]>>>;
+                readonly env: Schema.optional<Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly config: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly env: Schema.NonEmptyString;
+                }>]>>>;
+                readonly timeoutMs: Schema.optional<Schema.Int>;
+            }>;
+            readonly requires: Schema.optional<Schema.Struct<{
                 readonly outcomes: Schema.optional<Schema.NonEmptyArray<Schema.Literals<readonly ["allow", "deny", "ask"]>>>;
-            }>, Schema.Struct<{
-                readonly kind: Schema.Literal<"modify">;
                 readonly operations: Schema.optional<Schema.NonEmptyArray<Schema.Literals<readonly ["modify-input", "inject-context", "modify-output", "synthesize", "redact"]>>>;
-            }>]>;
+            }>>;
         }>>;
     }>>;
-    readonly timeoutMs: Schema.optional<Schema.Int>;
-    readonly capabilities: Schema.optional<Schema.Struct<{
-        readonly network: Schema.optional<Schema.Boolean>;
-        readonly filesystemWrite: Schema.optional<Schema.Boolean>;
-        readonly exec: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
-        readonly env: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
-    }>>;
-    readonly enhances: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
-    readonly requires: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
-    readonly fallback: Schema.optional<Schema.Literals<readonly ["auto", "none"]>>;
-    readonly recommendedPacks: Schema.optional<Schema.$Array<Schema.brand<Schema.NonEmptyString, "PackSpec">>>;
-    readonly standalone: Schema.optional<Schema.Boolean>;
+    readonly configuration: Schema.optional<Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"string">;
+        readonly default: Schema.optional<Schema.String>;
+        readonly secret: Schema.optional<Schema.Boolean>;
+        readonly allowEmpty: Schema.optional<Schema.Boolean>;
+        readonly minLength: Schema.optional<Schema.Int>;
+        readonly maxLength: Schema.optional<Schema.Int>;
+        readonly description: Schema.optional<Schema.NonEmptyString>;
+        readonly required: Schema.optional<Schema.Boolean>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"number">;
+        readonly default: Schema.optional<Schema.Finite>;
+        readonly minimum: Schema.optional<Schema.Finite>;
+        readonly maximum: Schema.optional<Schema.Finite>;
+        readonly description: Schema.optional<Schema.NonEmptyString>;
+        readonly required: Schema.optional<Schema.Boolean>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"boolean">;
+        readonly default: Schema.optional<Schema.Boolean>;
+        readonly description: Schema.optional<Schema.NonEmptyString>;
+        readonly required: Schema.optional<Schema.Boolean>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"enum">;
+        readonly values: Schema.NonEmptyArray<Schema.NonEmptyString>;
+        readonly default: Schema.optional<Schema.NonEmptyString>;
+        readonly description: Schema.optional<Schema.NonEmptyString>;
+        readonly required: Schema.optional<Schema.Boolean>;
+    }>]>>>;
+    readonly assets: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    readonly fixtures: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.NonEmptyString;
+        readonly implementation: Schema.NonEmptyString;
+        readonly binding: Schema.NonEmptyString;
+        readonly input: Schema.NonEmptyString;
+        readonly expect: Schema.Struct<{
+            readonly exitCode: Schema.Int;
+            readonly stdout: Schema.optional<Schema.NonEmptyString>;
+            readonly stderr: Schema.optional<Schema.NonEmptyString>;
+        }>;
+    }>>>;
     readonly publish: Schema.optional<Schema.Struct<{
         readonly visibility: Schema.optional<Schema.Literals<readonly ["public", "private"]>>;
         readonly ignore: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;

package/dist/src/packaging/manifest-policy.js

@@ -153,7 +153,7 @@ export const resolveManifest = (input) => Effect.gen(function* () {
     })));
     yield* Effect.fromResult(validateManifestHasNoAgentsField(manifestEntry.fileName, parsed));
     const schema = manifestSchemaForType(input.type);
-    yield* Schema.decodeUnknownEffect(schema)(parsed).pipe(Effect.mapError((error) => {
+    yield* Schema.decodeUnknownEffect(schema)(parsed, input.type === "hook" ? { onExcessProperty: "error" } : undefined).pipe(Effect.mapError((error) => {
         const companionPackageError = classifyCompanionPackageManifestError(parsed);
         return new ManifestError({
             code: companionPackageError?.code ?? "manifest_schema_invalid",

package/package.json

@@ -4,21 +4,23 @@
     "url": "https://github.com/agentxm/axm/issues"
   },
   "dependencies": {
-    "@agentxm/extension-model": "^0.38.0",
-    "effect": "4.0.0-rc.117",
+    "@agentxm/extension-model": "^0.41.0",
+    "effect": "4.0.1",
+    "smol-toml": "^1.9.0",
     "yaml": "^2.9.1"
   },
   "description": "AXM extension content behavior: skill and subagent content parsing, Knowledge bundle inspection and search, the lint rule catalog, and archive and manifest validation shared by the axm CLI and the AgentXM Registry. Unstable and unsupported — use the axm.sh CLI.",
   "devDependencies": {
-    "@effect/platform-node": "4.0.0-rc.117",
-    "@effect/vitest": "4.0.0-rc.117",
+    "@agentxm/specification-metadata": "^0.41.0",
+    "@effect/platform-node": "4.0.1",
+    "@effect/vitest": "4.0.1",
     "@fast-check/vitest": "^0.5.0",
     "@typescript/native": "npm:typescript@^7.0.2",
     "typescript": "npm:@typescript/typescript6@^6.0.2",
-    "vitest": "^5.0.1"
+    "vitest": "^5.0.3"
   },
   "engines": {
-    "node": ">=24.19.0"
+    "node": ">=24.21.0"
   },
   "exports": {
     ".": {
@@ -58,5 +60,5 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "0.38.0"
+  "version": "0.41.0"
 }

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

@@ -1,4 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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/matcher-raw-portability.d.ts

@@ -1,4 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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