@agentxm/client-core 0.16.1 → 0.17.0

package/dist/src/unstable/agent-capabilities/schema.d.ts

@@ -1,6 +1,33 @@
 /**
  * Agent capability catalog schemas.
  *
+ * Sourcing namespaces:
+ *
+ * - `native` is the vendor-authoritative fact layer: whether the agent exposes
+ *   the surface, which standard or convention it follows, where config lives,
+ *   and the source URLs used to verify that claim.
+ * - `axm` is AXM integration state: whether AXM has modeled support, whether a
+ *   writer exists, the writer metadata needed by AXM, and AXM-owned backlog or
+ *   unsupported reasons. These fields are not vendor facts.
+ * - `canonical` is a derived, vendor-neutral vocabulary. Hook event/tool
+ *   mappings store canonical IDs beside native names, but the catalog does not
+ *   store a per-agent canonical capability block.
+ *
+ * Status axes:
+ *
+ * - `AgentLifecycle` describes the coding agent product itself.
+ * - `VendorStatus` describes the vendor or plugin surface named by
+ *   `Availability`.
+ * - `Availability` describes whether the surface is native, plugin-backed, or
+ *   absent.
+ * - AXM support/writer state lives under `axm.status` and `axm.writer`;
+ *   `axm.writer !== null` means AXM has verified write mechanics for that
+ *   capability.
+ *
+ * `permissions` lives beside `capabilities` because it models AXM grant/write
+ * mechanics for an agent's permission system. It is not a publishable leaf
+ * extension type and therefore is not keyed under the extension capability map.
+ *
  * @experimental This API is unstable and may change without notice.
  */
 import * as Schema from "effect/Schema";
@@ -256,7 +283,14 @@ export declare const LastVerifiedDateSchema: Schema.NonEmptyString;
 /** @experimental This API is unstable and may change without notice. */
 export type LastVerifiedDate = Schema.Schema.Type<typeof LastVerifiedDateSchema>;
 /** @experimental This API is unstable and may change without notice. */
-export declare const CanonicalCapabilityBaseSchema: Schema.Union<readonly [Schema.Struct<{
+export declare const ProvenanceSchema: Schema.Struct<{
+    sources: Schema.$Array<Schema.NonEmptyString>;
+    lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type Provenance = Schema.Schema.Type<typeof ProvenanceSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const NativeCapabilityBaseSchema: Schema.Union<readonly [Schema.Struct<{
     availability: Schema.Union<readonly [Schema.Struct<{
         readonly via: Schema.Literal<"native">;
     }>, Schema.Struct<{
@@ -340,10 +374,10 @@ export declare const CanonicalCapabilityBaseSchema: Schema.Union<readonly [Schem
     sources: Schema.$Array<Schema.NonEmptyString>;
 }>]>;
 /** @experimental This API is unstable and may change without notice. */
-export type CanonicalCapabilityBase = Schema.Schema.Type<typeof CanonicalCapabilityBaseSchema>;
+export type NativeCapabilityBase = Schema.Schema.Type<typeof NativeCapabilityBaseSchema>;
 /** @experimental This API is unstable and may change without notice. */
 export declare const SkillsExtensionCapabilitySchema: Schema.Struct<{
-    readonly canonical: Schema.Union<readonly [Schema.Struct<{
+    readonly native: Schema.Union<readonly [Schema.Struct<{
         readonly directory: Schema.NonEmptyString;
         readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
         readonly convention: Schema.Literals<readonly ["universal", "vendor"]>;
@@ -429,20 +463,18 @@ export declare const SkillsExtensionCapabilitySchema: Schema.Struct<{
         }>>;
         sources: Schema.$Array<Schema.NonEmptyString>;
     }>]>;
-    readonly axm: Schema.Union<readonly [Schema.Struct<{
-        readonly support: Schema.Literals<readonly ["supported", "planned"]>;
-        readonly lastVerified: Schema.NonEmptyString;
-        readonly writer: Schema.Null;
-    }>, Schema.Struct<{
-        readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
-        readonly writer: Schema.Null;
-    }>]>;
+    readonly axm: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+        readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+        readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly writer: Schema.NullOr<Schema.Never>;
+    }>;
 }>;
 /** @experimental This API is unstable and may change without notice. */
 export type SkillsExtensionCapability = Schema.Schema.Type<typeof SkillsExtensionCapabilitySchema>;
 /** @experimental This API is unstable and may change without notice. */
 export declare const CommandsExtensionCapabilitySchema: Schema.Struct<{
-    readonly canonical: Schema.Union<readonly [Schema.Struct<{
+    readonly native: Schema.Union<readonly [Schema.Struct<{
         readonly directory: Schema.NonEmptyString;
         readonly availability: Schema.Union<readonly [Schema.Struct<{
             readonly via: Schema.Literal<"native">;
@@ -526,14 +558,12 @@ export declare const CommandsExtensionCapabilitySchema: Schema.Struct<{
         }>>;
         sources: Schema.$Array<Schema.NonEmptyString>;
     }>]>;
-    readonly axm: Schema.Union<readonly [Schema.Struct<{
-        readonly support: Schema.Literals<readonly ["supported", "planned"]>;
-        readonly lastVerified: Schema.NonEmptyString;
-        readonly writer: Schema.Null;
-    }>, Schema.Struct<{
-        readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
-        readonly writer: Schema.Null;
-    }>]>;
+    readonly axm: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+        readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+        readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly writer: Schema.NullOr<Schema.Never>;
+    }>;
 }>;
 /** @experimental This API is unstable and may change without notice. */
 export type CommandsExtensionCapability = Schema.Schema.Type<typeof CommandsExtensionCapabilitySchema>;
@@ -543,7 +573,7 @@ export declare const SubagentsLayoutSchema: Schema.Literals<readonly ["file", "d
 export type SubagentsLayout = Schema.Schema.Type<typeof SubagentsLayoutSchema>;
 /** @experimental This API is unstable and may change without notice. */
 export declare const SubagentsExtensionCapabilitySchema: Schema.Struct<{
-    readonly canonical: Schema.Union<readonly [Schema.Struct<{
+    readonly native: Schema.Union<readonly [Schema.Struct<{
         readonly availability: Schema.Struct<{
             readonly via: Schema.Literal<"native">;
         }>;
@@ -655,14 +685,12 @@ export declare const SubagentsExtensionCapabilitySchema: Schema.Struct<{
         }>>;
         sources: Schema.$Array<Schema.NonEmptyString>;
     }>]>;
-    readonly axm: Schema.Union<readonly [Schema.Struct<{
-        readonly support: Schema.Literals<readonly ["supported", "planned"]>;
-        readonly lastVerified: Schema.NonEmptyString;
-        readonly writer: Schema.Null;
-    }>, Schema.Struct<{
-        readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
-        readonly writer: Schema.Null;
-    }>]>;
+    readonly axm: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+        readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+        readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly writer: Schema.NullOr<Schema.Never>;
+    }>;
 }>;
 /** @experimental This API is unstable and may change without notice. */
 export type SubagentsExtensionCapability = Schema.Schema.Type<typeof SubagentsExtensionCapabilitySchema>;
@@ -676,7 +704,7 @@ export declare const RuleInstructionsImportSyntaxSchema: Schema.Literals<readonl
 export type RuleInstructionsImportSyntax = Schema.Schema.Type<typeof RuleInstructionsImportSyntaxSchema>;
 /** @experimental This API is unstable and may change without notice. */
 export declare const RulesExtensionCapabilitySchema: Schema.Struct<{
-    readonly canonical: Schema.Union<readonly [Schema.Struct<{
+    readonly native: Schema.Union<readonly [Schema.Struct<{
         readonly kind: Schema.Literal<"agents-md">;
         readonly files: Schema.Tuple<readonly [Schema.Literal<"AGENTS.md">]>;
         readonly nestedDiscovery: Schema.Boolean;
@@ -888,20 +916,18 @@ export declare const RulesExtensionCapabilitySchema: Schema.Struct<{
         }>>;
         sources: Schema.$Array<Schema.NonEmptyString>;
     }>]>;
-    readonly axm: Schema.Union<readonly [Schema.Struct<{
-        readonly support: Schema.Literals<readonly ["supported", "planned"]>;
-        readonly lastVerified: Schema.NonEmptyString;
-        readonly writer: Schema.Null;
-    }>, Schema.Struct<{
-        readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
-        readonly writer: Schema.Null;
-    }>]>;
+    readonly axm: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+        readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+        readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly writer: Schema.NullOr<Schema.Never>;
+    }>;
 }>;
 /** @experimental This API is unstable and may change without notice. */
 export type RulesExtensionCapability = Schema.Schema.Type<typeof RulesExtensionCapabilitySchema>;
 /** @experimental This API is unstable and may change without notice. */
 export declare const FilesExtensionCapabilitySchema: Schema.Struct<{
-    readonly canonical: Schema.Union<readonly [Schema.Struct<{
+    readonly native: Schema.Union<readonly [Schema.Struct<{
         readonly directory: Schema.NonEmptyString;
         readonly files: Schema.$Array<Schema.NonEmptyString>;
         readonly naming: Schema.NullOr<Schema.NonEmptyString>;
@@ -987,14 +1013,12 @@ export declare const FilesExtensionCapabilitySchema: Schema.Struct<{
         }>>;
         sources: Schema.$Array<Schema.NonEmptyString>;
     }>]>;
-    readonly axm: Schema.Union<readonly [Schema.Struct<{
-        readonly support: Schema.Literals<readonly ["supported", "planned"]>;
-        readonly lastVerified: Schema.NonEmptyString;
-        readonly writer: Schema.Null;
-    }>, Schema.Struct<{
-        readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
-        readonly writer: Schema.Null;
-    }>]>;
+    readonly axm: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+        readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+        readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly writer: Schema.NullOr<Schema.Never>;
+    }>;
 }>;
 /** @experimental This API is unstable and may change without notice. */
 export type FilesExtensionCapability = Schema.Schema.Type<typeof FilesExtensionCapabilitySchema>;
@@ -1116,7 +1140,7 @@ export declare const McpEnvExpansionSchema: Schema.Struct<{
 export type McpEnvExpansion = Schema.Schema.Type<typeof McpEnvExpansionSchema>;
 /** @experimental This API is unstable and may change without notice. */
 export declare const McpExtensionCapabilitySchema: Schema.Union<readonly [Schema.Struct<{
-    readonly canonical: Schema.Struct<{
+    readonly native: Schema.Struct<{
         readonly transports: Schema.NonEmptyArray<Schema.Literals<readonly ["stdio", "http", "sse"]>>;
         readonly mcpEnvExpansion: Schema.optionalKey<Schema.Struct<{
             readonly variables: Schema.Literals<readonly ["none", "braced"]>;
@@ -1178,48 +1202,10 @@ export declare const McpExtensionCapabilitySchema: Schema.Union<readonly [Schema
         readonly sources: Schema.$Array<Schema.NonEmptyString>;
         readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
     }>;
-    readonly axm: Schema.Union<readonly [Schema.Struct<{
-        readonly support: Schema.Literals<readonly ["supported", "planned"]>;
-        readonly lastVerified: Schema.NonEmptyString;
-        readonly writer: Schema.NullOr<Schema.Struct<{
-            readonly config: Schema.Struct<{
-                readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
-                readonly nativeEnabled: Schema.Boolean;
-                readonly targets: Schema.$Array<Schema.Struct<{
-                    readonly scope: Schema.Literals<readonly ["user", "project"]>;
-                    readonly path: Schema.NonEmptyString;
-                    readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "starlark", "vscode-settings"]>;
-                }>>;
-                readonly stdio: Schema.NullOr<Schema.Struct<{
-                    readonly typeField: Schema.NullOr<Schema.Struct<{
-                        readonly name: Schema.NonEmptyString;
-                        readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
-                            readonly "streamable-http": Schema.NonEmptyString;
-                            readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
-                        }>]>;
-                    }>>;
-                    readonly command: Schema.Literals<readonly ["split", "array"]>;
-                    readonly envKey: Schema.NullOr<Schema.NonEmptyString>;
-                }>>;
-                readonly remote: Schema.NullOr<Schema.Struct<{
-                    readonly typeField: Schema.NullOr<Schema.Struct<{
-                        readonly name: Schema.NonEmptyString;
-                        readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
-                            readonly "streamable-http": Schema.NonEmptyString;
-                            readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
-                        }>]>;
-                    }>>;
-                    readonly urlKey: Schema.Struct<{
-                        readonly "streamable-http": Schema.NonEmptyString;
-                        readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
-                    }>;
-                    readonly headersKey: Schema.NullOr<Schema.NonEmptyString>;
-                }>>;
-                readonly transform: Schema.NullOr<Schema.NonEmptyString>;
-            }>;
-        }>>;
-    }>, Schema.Struct<{
-        readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+    readonly axm: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+        readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+        readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
         readonly writer: Schema.NullOr<Schema.Struct<{
             readonly config: Schema.Struct<{
                 readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
@@ -1257,9 +1243,9 @@ export declare const McpExtensionCapabilitySchema: Schema.Union<readonly [Schema
                 readonly transform: Schema.NullOr<Schema.NonEmptyString>;
             }>;
         }>>;
-    }>]>;
+    }>;
 }>, Schema.Struct<{
-    readonly canonical: Schema.Struct<{
+    readonly native: Schema.Struct<{
         availability: Schema.Struct<{
             readonly via: Schema.Literal<"none">;
         }>;
@@ -1288,9 +1274,10 @@ export declare const McpExtensionCapabilitySchema: Schema.Union<readonly [Schema
         }>>;
         sources: Schema.$Array<Schema.NonEmptyString>;
     }>;
-    readonly axm: Schema.Union<readonly [Schema.Struct<{
-        readonly support: Schema.Literals<readonly ["supported", "planned"]>;
-        readonly lastVerified: Schema.NonEmptyString;
+    readonly axm: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+        readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+        readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
         readonly writer: Schema.NullOr<Schema.Struct<{
             readonly config: Schema.Struct<{
                 readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
@@ -1328,46 +1315,7 @@ export declare const McpExtensionCapabilitySchema: Schema.Union<readonly [Schema
                 readonly transform: Schema.NullOr<Schema.NonEmptyString>;
             }>;
         }>>;
-    }>, Schema.Struct<{
-        readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
-        readonly writer: Schema.NullOr<Schema.Struct<{
-            readonly config: Schema.Struct<{
-                readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
-                readonly nativeEnabled: Schema.Boolean;
-                readonly targets: Schema.$Array<Schema.Struct<{
-                    readonly scope: Schema.Literals<readonly ["user", "project"]>;
-                    readonly path: Schema.NonEmptyString;
-                    readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "starlark", "vscode-settings"]>;
-                }>>;
-                readonly stdio: Schema.NullOr<Schema.Struct<{
-                    readonly typeField: Schema.NullOr<Schema.Struct<{
-                        readonly name: Schema.NonEmptyString;
-                        readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
-                            readonly "streamable-http": Schema.NonEmptyString;
-                            readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
-                        }>]>;
-                    }>>;
-                    readonly command: Schema.Literals<readonly ["split", "array"]>;
-                    readonly envKey: Schema.NullOr<Schema.NonEmptyString>;
-                }>>;
-                readonly remote: Schema.NullOr<Schema.Struct<{
-                    readonly typeField: Schema.NullOr<Schema.Struct<{
-                        readonly name: Schema.NonEmptyString;
-                        readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
-                            readonly "streamable-http": Schema.NonEmptyString;
-                            readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
-                        }>]>;
-                    }>>;
-                    readonly urlKey: Schema.Struct<{
-                        readonly "streamable-http": Schema.NonEmptyString;
-                        readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
-                    }>;
-                    readonly headersKey: Schema.NullOr<Schema.NonEmptyString>;
-                }>>;
-                readonly transform: Schema.NullOr<Schema.NonEmptyString>;
-            }>;
-        }>>;
-    }>]>;
+    }>;
 }>]>;
 /** @experimental This API is unstable and may change without notice. */
 export type McpExtensionCapability = Schema.Schema.Type<typeof McpExtensionCapabilitySchema>;
@@ -1389,18 +1337,244 @@ export declare const ConfigFileLocationSchema: Schema.Struct<{
 /** @experimental This API is unstable and may change without notice. */
 export type ConfigFileLocation = Schema.Schema.Type<typeof ConfigFileLocationSchema>;
 /** @experimental This API is unstable and may change without notice. */
-export declare const HooksSerializerSchema: Schema.Literals<readonly ["claude-code-settings"]>;
+export declare const CANONICAL_HOOK_EVENT_IDS: readonly ["session.start", "prompt.submit", "turn.end", "tool.pre", "tool.post", "subagent.stop", "compaction.pre"];
+/** @experimental This API is unstable and may change without notice. */
+export declare const CanonicalHookEventIdSchema: Schema.Literals<readonly ["session.start", "prompt.submit", "turn.end", "tool.pre", "tool.post", "subagent.stop", "compaction.pre"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type CanonicalHookEventId = Schema.Schema.Type<typeof CanonicalHookEventIdSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HookEventTierSchema: Schema.Literals<readonly ["core", "extended"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type HookEventTier = Schema.Schema.Type<typeof HookEventTierSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const CanonicalHookEventSchema: Schema.Struct<{
+    readonly id: Schema.Literals<readonly ["session.start", "prompt.submit", "turn.end", "tool.pre", "tool.post", "subagent.stop", "compaction.pre"]>;
+    readonly tier: Schema.Literals<readonly ["core", "extended"]>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type CanonicalHookEvent = Schema.Schema.Type<typeof CanonicalHookEventSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const CANONICAL_HOOK_EVENTS: readonly [{
+    readonly id: "session.start";
+    readonly tier: "core";
+}, {
+    readonly id: "prompt.submit";
+    readonly tier: "core";
+}, {
+    readonly id: "turn.end";
+    readonly tier: "core";
+}, {
+    readonly id: "tool.pre";
+    readonly tier: "core";
+}, {
+    readonly id: "tool.post";
+    readonly tier: "core";
+}, {
+    readonly id: "subagent.stop";
+    readonly tier: "extended";
+}, {
+    readonly id: "compaction.pre";
+    readonly tier: "extended";
+}];
+/** @experimental This API is unstable and may change without notice. */
+export declare const CANONICAL_HOOK_TOOL_IDS: readonly ["file.read", "file.write", "file.edit", "shell.exec", "web.fetch", "mcp.call"];
+/** @experimental This API is unstable and may change without notice. */
+export declare const CanonicalHookToolIdSchema: Schema.Literals<readonly ["file.read", "file.write", "file.edit", "shell.exec", "web.fetch", "mcp.call"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type CanonicalHookToolId = Schema.Schema.Type<typeof CanonicalHookToolIdSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HookToolMappingSchema: Schema.Struct<{
+    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+    readonly lastVerified: Schema.NonEmptyString;
+    readonly nativeName: Schema.NonEmptyString;
+    readonly canonical: Schema.Literals<readonly ["file.read", "file.write", "file.edit", "shell.exec", "web.fetch", "mcp.call"]>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type HookToolMapping = Schema.Schema.Type<typeof HookToolMappingSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HookMechanismFamilySchema: Schema.Literals<readonly ["command-stdin", "raw"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type HookMechanismFamily = Schema.Schema.Type<typeof HookMechanismFamilySchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HookMatcherKindSchema: Schema.Literals<readonly ["regex", "literal-list", "glob", "tool-category", "exact-substring", "none-imperative"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type HookMatcherKind = Schema.Schema.Type<typeof HookMatcherKindSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HookMatcherSchema: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["regex", "literal-list", "glob", "tool-category", "exact-substring", "none-imperative"]>;
+    readonly example: Schema.NullOr<Schema.NonEmptyString>;
+    readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type HookMatcher = Schema.Schema.Type<typeof HookMatcherSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HookBlockOutcomeSchema: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type HookBlockOutcome = Schema.Schema.Type<typeof HookBlockOutcomeSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HookModifyOperationSchema: Schema.Literals<readonly ["modify-input", "inject-context", "modify-output", "synthesize", "redact"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type HookModifyOperation = Schema.Schema.Type<typeof HookModifyOperationSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HookDecisionCapabilitySchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"observe">;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"block">;
+    readonly outcomes: Schema.NonEmptyArray<Schema.Literals<readonly ["allow", "deny", "ask"]>>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"modify">;
+    readonly operations: Schema.NonEmptyArray<Schema.Literals<readonly ["modify-input", "inject-context", "modify-output", "synthesize", "redact"]>>;
+}>]>;
+/** @experimental This API is unstable and may change without notice. */
+export type HookDecisionCapability = Schema.Schema.Type<typeof HookDecisionCapabilitySchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HookEventMappingSchema: Schema.Struct<{
+    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+    readonly lastVerified: Schema.NonEmptyString;
+    readonly nativeName: Schema.NonEmptyString;
+    readonly canonical: Schema.Literals<readonly ["session.start", "prompt.submit", "turn.end", "tool.pre", "tool.post", "subagent.stop", "compaction.pre"]>;
+    readonly matcher: Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["regex", "literal-list", "glob", "tool-category", "exact-substring", "none-imperative"]>;
+        readonly example: Schema.NullOr<Schema.NonEmptyString>;
+        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+    }>;
+    readonly decision: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"observe">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"block">;
+        readonly outcomes: Schema.NonEmptyArray<Schema.Literals<readonly ["allow", "deny", "ask"]>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"modify">;
+        readonly operations: Schema.NonEmptyArray<Schema.Literals<readonly ["modify-input", "inject-context", "modify-output", "synthesize", "redact"]>>;
+    }>]>>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type HookEventMapping = Schema.Schema.Type<typeof HookEventMappingSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HooksSerializerSchema: Schema.Literals<readonly ["command-stdin"]>;
 /** @experimental This API is unstable and may change without notice. */
 export type HooksSerializer = Schema.Schema.Type<typeof HooksSerializerSchema>;
 /** @experimental This API is unstable and may change without notice. */
+export declare const HookMatcherSerializationSchema: Schema.Literals<readonly ["bare", "slash-delimited", "glob"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type HookMatcherSerialization = Schema.Schema.Type<typeof HookMatcherSerializationSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HookTimeoutSerializationSchema: Schema.Literals<readonly ["seconds", "milliseconds"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type HookTimeoutSerialization = Schema.Schema.Type<typeof HookTimeoutSerializationSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HookCommandNameSerializationSchema: Schema.Literals<readonly ["omit", "manifest"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type HookCommandNameSerialization = Schema.Schema.Type<typeof HookCommandNameSerializationSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HooksWriterSchema: Schema.Struct<{
+    readonly serializer: Schema.Literals<readonly ["command-stdin"]>;
+    readonly configFiles: Schema.NonEmptyArray<Schema.Struct<{
+        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+        readonly path: Schema.NonEmptyString;
+        readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "starlark", "vscode-settings"]>;
+        readonly gitignored: Schema.Boolean;
+    }>>;
+    readonly settingsKey: Schema.NonEmptyString;
+    readonly eventMap: Schema.Literal<"native.events">;
+    readonly matcherKind: Schema.Literals<readonly ["regex", "literal-list", "glob", "tool-category", "exact-substring", "none-imperative"]>;
+    readonly matcherSerialization: Schema.Literals<readonly ["bare", "slash-delimited", "glob"]>;
+    readonly timeoutSerialization: Schema.Literals<readonly ["seconds", "milliseconds"]>;
+    readonly commandNameSerialization: Schema.Literals<readonly ["omit", "manifest"]>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type HooksWriter = Schema.Schema.Type<typeof HooksWriterSchema>;
+/** @experimental This API is unstable and may change without notice. */
 export declare const HooksExtensionCapabilitySchema: Schema.Struct<{
-    readonly canonical: Schema.Union<readonly [Schema.Struct<{
+    readonly native: Schema.Union<readonly [Schema.Struct<{
+        readonly mechanism: Schema.NonEmptyArray<Schema.Literals<readonly ["command-stdin", "raw"]>>;
         readonly configFiles: Schema.$Array<Schema.Struct<{
             readonly scope: Schema.Literals<readonly ["user", "project"]>;
             readonly path: Schema.NonEmptyString;
             readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "starlark", "vscode-settings"]>;
             readonly gitignored: Schema.Boolean;
         }>>;
+        readonly events: Schema.NonEmptyArray<Schema.Struct<{
+            readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+            readonly lastVerified: Schema.NonEmptyString;
+            readonly nativeName: Schema.NonEmptyString;
+            readonly canonical: Schema.Literals<readonly ["session.start", "prompt.submit", "turn.end", "tool.pre", "tool.post", "subagent.stop", "compaction.pre"]>;
+            readonly matcher: Schema.Struct<{
+                readonly kind: Schema.Literals<readonly ["regex", "literal-list", "glob", "tool-category", "exact-substring", "none-imperative"]>;
+                readonly example: Schema.NullOr<Schema.NonEmptyString>;
+                readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+            }>;
+            readonly decision: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"observe">;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"block">;
+                readonly outcomes: Schema.NonEmptyArray<Schema.Literals<readonly ["allow", "deny", "ask"]>>;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"modify">;
+                readonly operations: Schema.NonEmptyArray<Schema.Literals<readonly ["modify-input", "inject-context", "modify-output", "synthesize", "redact"]>>;
+            }>]>>;
+        }>>;
+        readonly tools: Schema.$Array<Schema.Struct<{
+            readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+            readonly lastVerified: Schema.NonEmptyString;
+            readonly nativeName: Schema.NonEmptyString;
+            readonly canonical: Schema.Literals<readonly ["file.read", "file.write", "file.edit", "shell.exec", "web.fetch", "mcp.call"]>;
+        }>>;
+        readonly availability: Schema.Union<readonly [Schema.Struct<{
+            readonly via: Schema.Literal<"native">;
+        }>, Schema.Struct<{
+            readonly via: Schema.Literal<"plugin">;
+            readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+            readonly plugin: Schema.Struct<{
+                readonly name: Schema.NonEmptyString;
+                readonly homepage: Schema.NonEmptyString;
+                readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                readonly distribution: Schema.Struct<{
+                    readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                    readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                }>;
+                readonly detection: Schema.NullOr<Schema.Struct<{
+                    readonly paths: Schema.$Array<Schema.Struct<{
+                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                        readonly path: Schema.NonEmptyString;
+                        readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                    }>>;
+                    readonly configKeys: Schema.$Array<Schema.Struct<{
+                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                        readonly file: Schema.NonEmptyString;
+                        readonly key: Schema.NonEmptyString;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+            readonly state: Schema.Literal<"active">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "command", "mcp-server", "subagent", "files", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"maintenance">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "command", "mcp-server", "subagent", "files", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"deprecated">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "command", "mcp-server", "subagent", "files", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"removed">;
+        }>]>;
+        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+        readonly docs: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+        readonly sources: Schema.$Array<Schema.NonEmptyString>;
+        readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+    }>, Schema.Struct<{
+        readonly modeling: Schema.Literal<"native-unmodeled">;
         readonly availability: Schema.Union<readonly [Schema.Struct<{
             readonly via: Schema.Literal<"native">;
         }>, Schema.Struct<{
@@ -1483,18 +1657,26 @@ export declare const HooksExtensionCapabilitySchema: Schema.Struct<{
         }>>;
         sources: Schema.$Array<Schema.NonEmptyString>;
     }>]>;
-    readonly axm: Schema.Union<readonly [Schema.Struct<{
-        readonly support: Schema.Literals<readonly ["supported", "planned"]>;
-        readonly lastVerified: Schema.NonEmptyString;
-        readonly writer: Schema.NullOr<Schema.Struct<{
-            readonly serializer: Schema.Literals<readonly ["claude-code-settings"]>;
-        }>>;
-    }>, Schema.Struct<{
-        readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+    readonly axm: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+        readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+        readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
         readonly writer: Schema.NullOr<Schema.Struct<{
-            readonly serializer: Schema.Literals<readonly ["claude-code-settings"]>;
+            readonly serializer: Schema.Literals<readonly ["command-stdin"]>;
+            readonly configFiles: Schema.NonEmptyArray<Schema.Struct<{
+                readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                readonly path: Schema.NonEmptyString;
+                readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "starlark", "vscode-settings"]>;
+                readonly gitignored: Schema.Boolean;
+            }>>;
+            readonly settingsKey: Schema.NonEmptyString;
+            readonly eventMap: Schema.Literal<"native.events">;
+            readonly matcherKind: Schema.Literals<readonly ["regex", "literal-list", "glob", "tool-category", "exact-substring", "none-imperative"]>;
+            readonly matcherSerialization: Schema.Literals<readonly ["bare", "slash-delimited", "glob"]>;
+            readonly timeoutSerialization: Schema.Literals<readonly ["seconds", "milliseconds"]>;
+            readonly commandNameSerialization: Schema.Literals<readonly ["omit", "manifest"]>;
         }>>;
-    }>]>;
+    }>;
 }>;
 /** @experimental This API is unstable and may change without notice. */
 export type HooksExtensionCapability = Schema.Schema.Type<typeof HooksExtensionCapabilitySchema>;
@@ -1532,7 +1714,7 @@ export declare const PermissionGrantSchema: Schema.Struct<{
 export type PermissionGrant = Schema.Schema.Type<typeof PermissionGrantSchema>;
 /** @experimental This API is unstable and may change without notice. */
 export declare const PermissionsExtensionCapabilitySchema: Schema.Struct<{
-    readonly canonical: Schema.Union<readonly [Schema.Struct<{
+    readonly native: Schema.Union<readonly [Schema.Struct<{
         readonly mechanism: Schema.NonEmptyArray<Schema.Literals<readonly ["config-file", "cli-flag", "ui-only"]>>;
         readonly configFiles: Schema.$Array<Schema.Struct<{
             readonly scope: Schema.Literals<readonly ["user", "project"]>;
@@ -1637,18 +1819,10 @@ export declare const PermissionsExtensionCapabilitySchema: Schema.Struct<{
         }>>;
         sources: Schema.$Array<Schema.NonEmptyString>;
     }>]>;
-    readonly axm: Schema.Union<readonly [Schema.Struct<{
-        readonly support: Schema.Literals<readonly ["supported", "planned"]>;
-        readonly lastVerified: Schema.NonEmptyString;
-        readonly writer: Schema.NullOr<Schema.Struct<{
-            readonly grants: Schema.$Record<Schema.String, Schema.Struct<{
-                readonly target: Schema.NonEmptyString;
-                readonly patch: Schema.NullOr<Schema.Unknown>;
-                readonly template: Schema.NullOr<Schema.NonEmptyString>;
-            }>>;
-        }>>;
-    }>, Schema.Struct<{
-        readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+    readonly axm: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+        readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+        readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
         readonly writer: Schema.NullOr<Schema.Struct<{
             readonly grants: Schema.$Record<Schema.String, Schema.Struct<{
                 readonly target: Schema.NonEmptyString;
@@ -1656,14 +1830,14 @@ export declare const PermissionsExtensionCapabilitySchema: Schema.Struct<{
                 readonly template: Schema.NullOr<Schema.NonEmptyString>;
             }>>;
         }>>;
-    }>]>;
+    }>;
 }>;
 /** @experimental This API is unstable and may change without notice. */
 export type PermissionsExtensionCapability = Schema.Schema.Type<typeof PermissionsExtensionCapabilitySchema>;
 /** @experimental This API is unstable and may change without notice. */
 export declare const AgentCapabilitiesSchema: Schema.Struct<{
     skill: Schema.Struct<{
-        readonly canonical: Schema.Union<readonly [Schema.Struct<{
+        readonly native: Schema.Union<readonly [Schema.Struct<{
             readonly directory: Schema.NonEmptyString;
             readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
             readonly convention: Schema.Literals<readonly ["universal", "vendor"]>;
@@ -1749,17 +1923,15 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
             }>>;
             sources: Schema.$Array<Schema.NonEmptyString>;
         }>]>;
-        readonly axm: Schema.Union<readonly [Schema.Struct<{
-            readonly support: Schema.Literals<readonly ["supported", "planned"]>;
-            readonly lastVerified: Schema.NonEmptyString;
-            readonly writer: Schema.Null;
-        }>, Schema.Struct<{
-            readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
-            readonly writer: Schema.Null;
-        }>]>;
+        readonly axm: Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+            readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+            readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+            readonly writer: Schema.NullOr<Schema.Never>;
+        }>;
     }>;
     command: Schema.Struct<{
-        readonly canonical: Schema.Union<readonly [Schema.Struct<{
+        readonly native: Schema.Union<readonly [Schema.Struct<{
             readonly directory: Schema.NonEmptyString;
             readonly availability: Schema.Union<readonly [Schema.Struct<{
                 readonly via: Schema.Literal<"native">;
@@ -1843,17 +2015,15 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
             }>>;
             sources: Schema.$Array<Schema.NonEmptyString>;
         }>]>;
-        readonly axm: Schema.Union<readonly [Schema.Struct<{
-            readonly support: Schema.Literals<readonly ["supported", "planned"]>;
-            readonly lastVerified: Schema.NonEmptyString;
-            readonly writer: Schema.Null;
-        }>, Schema.Struct<{
-            readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
-            readonly writer: Schema.Null;
-        }>]>;
+        readonly axm: Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+            readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+            readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+            readonly writer: Schema.NullOr<Schema.Never>;
+        }>;
     }>;
     "mcp-server": Schema.Union<readonly [Schema.Struct<{
-        readonly canonical: Schema.Struct<{
+        readonly native: Schema.Struct<{
             readonly transports: Schema.NonEmptyArray<Schema.Literals<readonly ["stdio", "http", "sse"]>>;
             readonly mcpEnvExpansion: Schema.optionalKey<Schema.Struct<{
                 readonly variables: Schema.Literals<readonly ["none", "braced"]>;
@@ -1915,9 +2085,10 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
             readonly sources: Schema.$Array<Schema.NonEmptyString>;
             readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
         }>;
-        readonly axm: Schema.Union<readonly [Schema.Struct<{
-            readonly support: Schema.Literals<readonly ["supported", "planned"]>;
-            readonly lastVerified: Schema.NonEmptyString;
+        readonly axm: Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+            readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+            readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
             readonly writer: Schema.NullOr<Schema.Struct<{
                 readonly config: Schema.Struct<{
                     readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
@@ -1955,48 +2126,9 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
                     readonly transform: Schema.NullOr<Schema.NonEmptyString>;
                 }>;
             }>>;
-        }>, Schema.Struct<{
-            readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
-            readonly writer: Schema.NullOr<Schema.Struct<{
-                readonly config: Schema.Struct<{
-                    readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
-                    readonly nativeEnabled: Schema.Boolean;
-                    readonly targets: Schema.$Array<Schema.Struct<{
-                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
-                        readonly path: Schema.NonEmptyString;
-                        readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "starlark", "vscode-settings"]>;
-                    }>>;
-                    readonly stdio: Schema.NullOr<Schema.Struct<{
-                        readonly typeField: Schema.NullOr<Schema.Struct<{
-                            readonly name: Schema.NonEmptyString;
-                            readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
-                                readonly "streamable-http": Schema.NonEmptyString;
-                                readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
-                            }>]>;
-                        }>>;
-                        readonly command: Schema.Literals<readonly ["split", "array"]>;
-                        readonly envKey: Schema.NullOr<Schema.NonEmptyString>;
-                    }>>;
-                    readonly remote: Schema.NullOr<Schema.Struct<{
-                        readonly typeField: Schema.NullOr<Schema.Struct<{
-                            readonly name: Schema.NonEmptyString;
-                            readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
-                                readonly "streamable-http": Schema.NonEmptyString;
-                                readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
-                            }>]>;
-                        }>>;
-                        readonly urlKey: Schema.Struct<{
-                            readonly "streamable-http": Schema.NonEmptyString;
-                            readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
-                        }>;
-                        readonly headersKey: Schema.NullOr<Schema.NonEmptyString>;
-                    }>>;
-                    readonly transform: Schema.NullOr<Schema.NonEmptyString>;
-                }>;
-            }>>;
-        }>]>;
+        }>;
     }>, Schema.Struct<{
-        readonly canonical: Schema.Struct<{
+        readonly native: Schema.Struct<{
             availability: Schema.Struct<{
                 readonly via: Schema.Literal<"none">;
             }>;
@@ -2025,48 +2157,10 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
             }>>;
             sources: Schema.$Array<Schema.NonEmptyString>;
         }>;
-        readonly axm: Schema.Union<readonly [Schema.Struct<{
-            readonly support: Schema.Literals<readonly ["supported", "planned"]>;
-            readonly lastVerified: Schema.NonEmptyString;
-            readonly writer: Schema.NullOr<Schema.Struct<{
-                readonly config: Schema.Struct<{
-                    readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
-                    readonly nativeEnabled: Schema.Boolean;
-                    readonly targets: Schema.$Array<Schema.Struct<{
-                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
-                        readonly path: Schema.NonEmptyString;
-                        readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "starlark", "vscode-settings"]>;
-                    }>>;
-                    readonly stdio: Schema.NullOr<Schema.Struct<{
-                        readonly typeField: Schema.NullOr<Schema.Struct<{
-                            readonly name: Schema.NonEmptyString;
-                            readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
-                                readonly "streamable-http": Schema.NonEmptyString;
-                                readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
-                            }>]>;
-                        }>>;
-                        readonly command: Schema.Literals<readonly ["split", "array"]>;
-                        readonly envKey: Schema.NullOr<Schema.NonEmptyString>;
-                    }>>;
-                    readonly remote: Schema.NullOr<Schema.Struct<{
-                        readonly typeField: Schema.NullOr<Schema.Struct<{
-                            readonly name: Schema.NonEmptyString;
-                            readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
-                                readonly "streamable-http": Schema.NonEmptyString;
-                                readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
-                            }>]>;
-                        }>>;
-                        readonly urlKey: Schema.Struct<{
-                            readonly "streamable-http": Schema.NonEmptyString;
-                            readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
-                        }>;
-                        readonly headersKey: Schema.NullOr<Schema.NonEmptyString>;
-                    }>>;
-                    readonly transform: Schema.NullOr<Schema.NonEmptyString>;
-                }>;
-            }>>;
-        }>, Schema.Struct<{
-            readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+        readonly axm: Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+            readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+            readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
             readonly writer: Schema.NullOr<Schema.Struct<{
                 readonly config: Schema.Struct<{
                     readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
@@ -2104,10 +2198,10 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
                     readonly transform: Schema.NullOr<Schema.NonEmptyString>;
                 }>;
             }>>;
-        }>]>;
+        }>;
     }>]>;
     subagent: Schema.Struct<{
-        readonly canonical: Schema.Union<readonly [Schema.Struct<{
+        readonly native: Schema.Union<readonly [Schema.Struct<{
             readonly availability: Schema.Struct<{
                 readonly via: Schema.Literal<"native">;
             }>;
@@ -2219,17 +2313,15 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
             }>>;
             sources: Schema.$Array<Schema.NonEmptyString>;
         }>]>;
-        readonly axm: Schema.Union<readonly [Schema.Struct<{
-            readonly support: Schema.Literals<readonly ["supported", "planned"]>;
-            readonly lastVerified: Schema.NonEmptyString;
-            readonly writer: Schema.Null;
-        }>, Schema.Struct<{
-            readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
-            readonly writer: Schema.Null;
-        }>]>;
+        readonly axm: Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+            readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+            readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+            readonly writer: Schema.NullOr<Schema.Never>;
+        }>;
     }>;
     files: Schema.Struct<{
-        readonly canonical: Schema.Union<readonly [Schema.Struct<{
+        readonly native: Schema.Union<readonly [Schema.Struct<{
             readonly directory: Schema.NonEmptyString;
             readonly files: Schema.$Array<Schema.NonEmptyString>;
             readonly naming: Schema.NullOr<Schema.NonEmptyString>;
@@ -2315,17 +2407,15 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
             }>>;
             sources: Schema.$Array<Schema.NonEmptyString>;
         }>]>;
-        readonly axm: Schema.Union<readonly [Schema.Struct<{
-            readonly support: Schema.Literals<readonly ["supported", "planned"]>;
-            readonly lastVerified: Schema.NonEmptyString;
-            readonly writer: Schema.Null;
-        }>, Schema.Struct<{
-            readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
-            readonly writer: Schema.Null;
-        }>]>;
+        readonly axm: Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+            readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+            readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+            readonly writer: Schema.NullOr<Schema.Never>;
+        }>;
     }>;
     rule: Schema.Struct<{
-        readonly canonical: Schema.Union<readonly [Schema.Struct<{
+        readonly native: Schema.Union<readonly [Schema.Struct<{
             readonly kind: Schema.Literal<"agents-md">;
             readonly files: Schema.Tuple<readonly [Schema.Literal<"AGENTS.md">]>;
             readonly nestedDiscovery: Schema.Boolean;
@@ -2537,23 +2627,103 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
             }>>;
             sources: Schema.$Array<Schema.NonEmptyString>;
         }>]>;
-        readonly axm: Schema.Union<readonly [Schema.Struct<{
-            readonly support: Schema.Literals<readonly ["supported", "planned"]>;
-            readonly lastVerified: Schema.NonEmptyString;
-            readonly writer: Schema.Null;
-        }>, Schema.Struct<{
-            readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
-            readonly writer: Schema.Null;
-        }>]>;
+        readonly axm: Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+            readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+            readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+            readonly writer: Schema.NullOr<Schema.Never>;
+        }>;
     }>;
     hook: Schema.Struct<{
-        readonly canonical: Schema.Union<readonly [Schema.Struct<{
+        readonly native: Schema.Union<readonly [Schema.Struct<{
+            readonly mechanism: Schema.NonEmptyArray<Schema.Literals<readonly ["command-stdin", "raw"]>>;
             readonly configFiles: Schema.$Array<Schema.Struct<{
                 readonly scope: Schema.Literals<readonly ["user", "project"]>;
                 readonly path: Schema.NonEmptyString;
                 readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "starlark", "vscode-settings"]>;
                 readonly gitignored: Schema.Boolean;
             }>>;
+            readonly events: Schema.NonEmptyArray<Schema.Struct<{
+                readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                readonly lastVerified: Schema.NonEmptyString;
+                readonly nativeName: Schema.NonEmptyString;
+                readonly canonical: Schema.Literals<readonly ["session.start", "prompt.submit", "turn.end", "tool.pre", "tool.post", "subagent.stop", "compaction.pre"]>;
+                readonly matcher: Schema.Struct<{
+                    readonly kind: Schema.Literals<readonly ["regex", "literal-list", "glob", "tool-category", "exact-substring", "none-imperative"]>;
+                    readonly example: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+                }>;
+                readonly decision: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"observe">;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"block">;
+                    readonly outcomes: Schema.NonEmptyArray<Schema.Literals<readonly ["allow", "deny", "ask"]>>;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"modify">;
+                    readonly operations: Schema.NonEmptyArray<Schema.Literals<readonly ["modify-input", "inject-context", "modify-output", "synthesize", "redact"]>>;
+                }>]>>;
+            }>>;
+            readonly tools: Schema.$Array<Schema.Struct<{
+                readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                readonly lastVerified: Schema.NonEmptyString;
+                readonly nativeName: Schema.NonEmptyString;
+                readonly canonical: Schema.Literals<readonly ["file.read", "file.write", "file.edit", "shell.exec", "web.fetch", "mcp.call"]>;
+            }>>;
+            readonly availability: Schema.Union<readonly [Schema.Struct<{
+                readonly via: Schema.Literal<"native">;
+            }>, Schema.Struct<{
+                readonly via: Schema.Literal<"plugin">;
+                readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+                readonly plugin: Schema.Struct<{
+                    readonly name: Schema.NonEmptyString;
+                    readonly homepage: Schema.NonEmptyString;
+                    readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly distribution: Schema.Struct<{
+                        readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                        readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                    }>;
+                    readonly detection: Schema.NullOr<Schema.Struct<{
+                        readonly paths: Schema.$Array<Schema.Struct<{
+                            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                            readonly path: Schema.NonEmptyString;
+                            readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                        }>>;
+                        readonly configKeys: Schema.$Array<Schema.Struct<{
+                            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                            readonly file: Schema.NonEmptyString;
+                            readonly key: Schema.NonEmptyString;
+                        }>>;
+                    }>>;
+                }>;
+            }>]>;
+            readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                readonly state: Schema.Literal<"active">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "command", "mcp-server", "subagent", "files", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"maintenance">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "command", "mcp-server", "subagent", "files", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"deprecated">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "command", "mcp-server", "subagent", "files", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"removed">;
+            }>]>;
+            readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+            readonly docs: Schema.$Array<Schema.Struct<{
+                readonly label: Schema.NonEmptyString;
+                readonly url: Schema.NonEmptyString;
+            }>>;
+            readonly sources: Schema.$Array<Schema.NonEmptyString>;
+            readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+        }>, Schema.Struct<{
+            readonly modeling: Schema.Literal<"native-unmodeled">;
             readonly availability: Schema.Union<readonly [Schema.Struct<{
                 readonly via: Schema.Literal<"native">;
             }>, Schema.Struct<{
@@ -2636,18 +2806,26 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
             }>>;
             sources: Schema.$Array<Schema.NonEmptyString>;
         }>]>;
-        readonly axm: Schema.Union<readonly [Schema.Struct<{
-            readonly support: Schema.Literals<readonly ["supported", "planned"]>;
-            readonly lastVerified: Schema.NonEmptyString;
+        readonly axm: Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+            readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+            readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
             readonly writer: Schema.NullOr<Schema.Struct<{
-                readonly serializer: Schema.Literals<readonly ["claude-code-settings"]>;
-            }>>;
-        }>, Schema.Struct<{
-            readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
-            readonly writer: Schema.NullOr<Schema.Struct<{
-                readonly serializer: Schema.Literals<readonly ["claude-code-settings"]>;
+                readonly serializer: Schema.Literals<readonly ["command-stdin"]>;
+                readonly configFiles: Schema.NonEmptyArray<Schema.Struct<{
+                    readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                    readonly path: Schema.NonEmptyString;
+                    readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "starlark", "vscode-settings"]>;
+                    readonly gitignored: Schema.Boolean;
+                }>>;
+                readonly settingsKey: Schema.NonEmptyString;
+                readonly eventMap: Schema.Literal<"native.events">;
+                readonly matcherKind: Schema.Literals<readonly ["regex", "literal-list", "glob", "tool-category", "exact-substring", "none-imperative"]>;
+                readonly matcherSerialization: Schema.Literals<readonly ["bare", "slash-delimited", "glob"]>;
+                readonly timeoutSerialization: Schema.Literals<readonly ["seconds", "milliseconds"]>;
+                readonly commandNameSerialization: Schema.Literals<readonly ["omit", "manifest"]>;
             }>>;
-        }>]>;
+        }>;
     }>;
 }>;
 /** @experimental This API is unstable and may change without notice. */
@@ -2655,7 +2833,7 @@ export type AgentCapabilities = Schema.Schema.Type<typeof AgentCapabilitiesSchem
 /** @experimental This API is unstable and may change without notice. */
 export type AgentExtensionCapability = AgentCapabilities[LeafExtensionType];
 /** @experimental This API is unstable and may change without notice. */
-export type CanonicalCapability = AgentExtensionCapability["canonical"];
+export type NativeCapability = AgentExtensionCapability["native"];
 /** @experimental This API is unstable and may change without notice. */
 export type AxmCapabilityState = AgentExtensionCapability["axm"];
 /** @experimental This API is unstable and may change without notice. */
@@ -2744,7 +2922,7 @@ export declare const AgentSchema: Schema.Struct<{
     }>>;
     readonly capabilities: Schema.Struct<{
         skill: Schema.Struct<{
-            readonly canonical: Schema.Union<readonly [Schema.Struct<{
+            readonly native: Schema.Union<readonly [Schema.Struct<{
                 readonly directory: Schema.NonEmptyString;
                 readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
                 readonly convention: Schema.Literals<readonly ["universal", "vendor"]>;
@@ -2830,17 +3008,15 @@ export declare const AgentSchema: Schema.Struct<{
                 }>>;
                 sources: Schema.$Array<Schema.NonEmptyString>;
             }>]>;
-            readonly axm: Schema.Union<readonly [Schema.Struct<{
-                readonly support: Schema.Literals<readonly ["supported", "planned"]>;
-                readonly lastVerified: Schema.NonEmptyString;
-                readonly writer: Schema.Null;
-            }>, Schema.Struct<{
-                readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
-                readonly writer: Schema.Null;
-            }>]>;
+            readonly axm: Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+                readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+                readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+                readonly writer: Schema.NullOr<Schema.Never>;
+            }>;
         }>;
         command: Schema.Struct<{
-            readonly canonical: Schema.Union<readonly [Schema.Struct<{
+            readonly native: Schema.Union<readonly [Schema.Struct<{
                 readonly directory: Schema.NonEmptyString;
                 readonly availability: Schema.Union<readonly [Schema.Struct<{
                     readonly via: Schema.Literal<"native">;
@@ -2924,17 +3100,15 @@ export declare const AgentSchema: Schema.Struct<{
                 }>>;
                 sources: Schema.$Array<Schema.NonEmptyString>;
             }>]>;
-            readonly axm: Schema.Union<readonly [Schema.Struct<{
-                readonly support: Schema.Literals<readonly ["supported", "planned"]>;
-                readonly lastVerified: Schema.NonEmptyString;
-                readonly writer: Schema.Null;
-            }>, Schema.Struct<{
-                readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
-                readonly writer: Schema.Null;
-            }>]>;
+            readonly axm: Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+                readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+                readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+                readonly writer: Schema.NullOr<Schema.Never>;
+            }>;
         }>;
         "mcp-server": Schema.Union<readonly [Schema.Struct<{
-            readonly canonical: Schema.Struct<{
+            readonly native: Schema.Struct<{
                 readonly transports: Schema.NonEmptyArray<Schema.Literals<readonly ["stdio", "http", "sse"]>>;
                 readonly mcpEnvExpansion: Schema.optionalKey<Schema.Struct<{
                     readonly variables: Schema.Literals<readonly ["none", "braced"]>;
@@ -2996,9 +3170,10 @@ export declare const AgentSchema: Schema.Struct<{
                 readonly sources: Schema.$Array<Schema.NonEmptyString>;
                 readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
             }>;
-            readonly axm: Schema.Union<readonly [Schema.Struct<{
-                readonly support: Schema.Literals<readonly ["supported", "planned"]>;
-                readonly lastVerified: Schema.NonEmptyString;
+            readonly axm: Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+                readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+                readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
                 readonly writer: Schema.NullOr<Schema.Struct<{
                     readonly config: Schema.Struct<{
                         readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
@@ -3036,48 +3211,9 @@ export declare const AgentSchema: Schema.Struct<{
                         readonly transform: Schema.NullOr<Schema.NonEmptyString>;
                     }>;
                 }>>;
-            }>, Schema.Struct<{
-                readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
-                readonly writer: Schema.NullOr<Schema.Struct<{
-                    readonly config: Schema.Struct<{
-                        readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
-                        readonly nativeEnabled: Schema.Boolean;
-                        readonly targets: Schema.$Array<Schema.Struct<{
-                            readonly scope: Schema.Literals<readonly ["user", "project"]>;
-                            readonly path: Schema.NonEmptyString;
-                            readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "starlark", "vscode-settings"]>;
-                        }>>;
-                        readonly stdio: Schema.NullOr<Schema.Struct<{
-                            readonly typeField: Schema.NullOr<Schema.Struct<{
-                                readonly name: Schema.NonEmptyString;
-                                readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
-                                    readonly "streamable-http": Schema.NonEmptyString;
-                                    readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
-                                }>]>;
-                            }>>;
-                            readonly command: Schema.Literals<readonly ["split", "array"]>;
-                            readonly envKey: Schema.NullOr<Schema.NonEmptyString>;
-                        }>>;
-                        readonly remote: Schema.NullOr<Schema.Struct<{
-                            readonly typeField: Schema.NullOr<Schema.Struct<{
-                                readonly name: Schema.NonEmptyString;
-                                readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
-                                    readonly "streamable-http": Schema.NonEmptyString;
-                                    readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
-                                }>]>;
-                            }>>;
-                            readonly urlKey: Schema.Struct<{
-                                readonly "streamable-http": Schema.NonEmptyString;
-                                readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
-                            }>;
-                            readonly headersKey: Schema.NullOr<Schema.NonEmptyString>;
-                        }>>;
-                        readonly transform: Schema.NullOr<Schema.NonEmptyString>;
-                    }>;
-                }>>;
-            }>]>;
+            }>;
         }>, Schema.Struct<{
-            readonly canonical: Schema.Struct<{
+            readonly native: Schema.Struct<{
                 availability: Schema.Struct<{
                     readonly via: Schema.Literal<"none">;
                 }>;
@@ -3106,9 +3242,10 @@ export declare const AgentSchema: Schema.Struct<{
                 }>>;
                 sources: Schema.$Array<Schema.NonEmptyString>;
             }>;
-            readonly axm: Schema.Union<readonly [Schema.Struct<{
-                readonly support: Schema.Literals<readonly ["supported", "planned"]>;
-                readonly lastVerified: Schema.NonEmptyString;
+            readonly axm: Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+                readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+                readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
                 readonly writer: Schema.NullOr<Schema.Struct<{
                     readonly config: Schema.Struct<{
                         readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
@@ -3146,49 +3283,10 @@ export declare const AgentSchema: Schema.Struct<{
                         readonly transform: Schema.NullOr<Schema.NonEmptyString>;
                     }>;
                 }>>;
-            }>, Schema.Struct<{
-                readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
-                readonly writer: Schema.NullOr<Schema.Struct<{
-                    readonly config: Schema.Struct<{
-                        readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
-                        readonly nativeEnabled: Schema.Boolean;
-                        readonly targets: Schema.$Array<Schema.Struct<{
-                            readonly scope: Schema.Literals<readonly ["user", "project"]>;
-                            readonly path: Schema.NonEmptyString;
-                            readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "starlark", "vscode-settings"]>;
-                        }>>;
-                        readonly stdio: Schema.NullOr<Schema.Struct<{
-                            readonly typeField: Schema.NullOr<Schema.Struct<{
-                                readonly name: Schema.NonEmptyString;
-                                readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
-                                    readonly "streamable-http": Schema.NonEmptyString;
-                                    readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
-                                }>]>;
-                            }>>;
-                            readonly command: Schema.Literals<readonly ["split", "array"]>;
-                            readonly envKey: Schema.NullOr<Schema.NonEmptyString>;
-                        }>>;
-                        readonly remote: Schema.NullOr<Schema.Struct<{
-                            readonly typeField: Schema.NullOr<Schema.Struct<{
-                                readonly name: Schema.NonEmptyString;
-                                readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
-                                    readonly "streamable-http": Schema.NonEmptyString;
-                                    readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
-                                }>]>;
-                            }>>;
-                            readonly urlKey: Schema.Struct<{
-                                readonly "streamable-http": Schema.NonEmptyString;
-                                readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
-                            }>;
-                            readonly headersKey: Schema.NullOr<Schema.NonEmptyString>;
-                        }>>;
-                        readonly transform: Schema.NullOr<Schema.NonEmptyString>;
-                    }>;
-                }>>;
-            }>]>;
+            }>;
         }>]>;
         subagent: Schema.Struct<{
-            readonly canonical: Schema.Union<readonly [Schema.Struct<{
+            readonly native: Schema.Union<readonly [Schema.Struct<{
                 readonly availability: Schema.Struct<{
                     readonly via: Schema.Literal<"native">;
                 }>;
@@ -3300,17 +3398,15 @@ export declare const AgentSchema: Schema.Struct<{
                 }>>;
                 sources: Schema.$Array<Schema.NonEmptyString>;
             }>]>;
-            readonly axm: Schema.Union<readonly [Schema.Struct<{
-                readonly support: Schema.Literals<readonly ["supported", "planned"]>;
-                readonly lastVerified: Schema.NonEmptyString;
-                readonly writer: Schema.Null;
-            }>, Schema.Struct<{
-                readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
-                readonly writer: Schema.Null;
-            }>]>;
+            readonly axm: Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+                readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+                readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+                readonly writer: Schema.NullOr<Schema.Never>;
+            }>;
         }>;
         files: Schema.Struct<{
-            readonly canonical: Schema.Union<readonly [Schema.Struct<{
+            readonly native: Schema.Union<readonly [Schema.Struct<{
                 readonly directory: Schema.NonEmptyString;
                 readonly files: Schema.$Array<Schema.NonEmptyString>;
                 readonly naming: Schema.NullOr<Schema.NonEmptyString>;
@@ -3396,17 +3492,15 @@ export declare const AgentSchema: Schema.Struct<{
                 }>>;
                 sources: Schema.$Array<Schema.NonEmptyString>;
             }>]>;
-            readonly axm: Schema.Union<readonly [Schema.Struct<{
-                readonly support: Schema.Literals<readonly ["supported", "planned"]>;
-                readonly lastVerified: Schema.NonEmptyString;
-                readonly writer: Schema.Null;
-            }>, Schema.Struct<{
-                readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
-                readonly writer: Schema.Null;
-            }>]>;
+            readonly axm: Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+                readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+                readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+                readonly writer: Schema.NullOr<Schema.Never>;
+            }>;
         }>;
         rule: Schema.Struct<{
-            readonly canonical: Schema.Union<readonly [Schema.Struct<{
+            readonly native: Schema.Union<readonly [Schema.Struct<{
                 readonly kind: Schema.Literal<"agents-md">;
                 readonly files: Schema.Tuple<readonly [Schema.Literal<"AGENTS.md">]>;
                 readonly nestedDiscovery: Schema.Boolean;
@@ -3618,23 +3712,103 @@ export declare const AgentSchema: Schema.Struct<{
                 }>>;
                 sources: Schema.$Array<Schema.NonEmptyString>;
             }>]>;
-            readonly axm: Schema.Union<readonly [Schema.Struct<{
-                readonly support: Schema.Literals<readonly ["supported", "planned"]>;
-                readonly lastVerified: Schema.NonEmptyString;
-                readonly writer: Schema.Null;
-            }>, Schema.Struct<{
-                readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
-                readonly writer: Schema.Null;
-            }>]>;
+            readonly axm: Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+                readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+                readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+                readonly writer: Schema.NullOr<Schema.Never>;
+            }>;
         }>;
         hook: Schema.Struct<{
-            readonly canonical: Schema.Union<readonly [Schema.Struct<{
+            readonly native: Schema.Union<readonly [Schema.Struct<{
+                readonly mechanism: Schema.NonEmptyArray<Schema.Literals<readonly ["command-stdin", "raw"]>>;
                 readonly configFiles: Schema.$Array<Schema.Struct<{
                     readonly scope: Schema.Literals<readonly ["user", "project"]>;
                     readonly path: Schema.NonEmptyString;
                     readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "starlark", "vscode-settings"]>;
                     readonly gitignored: Schema.Boolean;
                 }>>;
+                readonly events: Schema.NonEmptyArray<Schema.Struct<{
+                    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                    readonly lastVerified: Schema.NonEmptyString;
+                    readonly nativeName: Schema.NonEmptyString;
+                    readonly canonical: Schema.Literals<readonly ["session.start", "prompt.submit", "turn.end", "tool.pre", "tool.post", "subagent.stop", "compaction.pre"]>;
+                    readonly matcher: Schema.Struct<{
+                        readonly kind: Schema.Literals<readonly ["regex", "literal-list", "glob", "tool-category", "exact-substring", "none-imperative"]>;
+                        readonly example: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+                    }>;
+                    readonly decision: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                        readonly kind: Schema.Literal<"observe">;
+                    }>, Schema.Struct<{
+                        readonly kind: Schema.Literal<"block">;
+                        readonly outcomes: Schema.NonEmptyArray<Schema.Literals<readonly ["allow", "deny", "ask"]>>;
+                    }>, Schema.Struct<{
+                        readonly kind: Schema.Literal<"modify">;
+                        readonly operations: Schema.NonEmptyArray<Schema.Literals<readonly ["modify-input", "inject-context", "modify-output", "synthesize", "redact"]>>;
+                    }>]>>;
+                }>>;
+                readonly tools: Schema.$Array<Schema.Struct<{
+                    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                    readonly lastVerified: Schema.NonEmptyString;
+                    readonly nativeName: Schema.NonEmptyString;
+                    readonly canonical: Schema.Literals<readonly ["file.read", "file.write", "file.edit", "shell.exec", "web.fetch", "mcp.call"]>;
+                }>>;
+                readonly availability: Schema.Union<readonly [Schema.Struct<{
+                    readonly via: Schema.Literal<"native">;
+                }>, Schema.Struct<{
+                    readonly via: Schema.Literal<"plugin">;
+                    readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+                    readonly plugin: Schema.Struct<{
+                        readonly name: Schema.NonEmptyString;
+                        readonly homepage: Schema.NonEmptyString;
+                        readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly distribution: Schema.Struct<{
+                            readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                            readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                            readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                        }>;
+                        readonly detection: Schema.NullOr<Schema.Struct<{
+                            readonly paths: Schema.$Array<Schema.Struct<{
+                                readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                                readonly path: Schema.NonEmptyString;
+                                readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                            }>>;
+                            readonly configKeys: Schema.$Array<Schema.Struct<{
+                                readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                                readonly file: Schema.NonEmptyString;
+                                readonly key: Schema.NonEmptyString;
+                            }>>;
+                        }>>;
+                    }>;
+                }>]>;
+                readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                    readonly state: Schema.Literal<"active">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "command", "mcp-server", "subagent", "files", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"maintenance">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "command", "mcp-server", "subagent", "files", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"deprecated">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "command", "mcp-server", "subagent", "files", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"removed">;
+                }>]>;
+                readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+                readonly docs: Schema.$Array<Schema.Struct<{
+                    readonly label: Schema.NonEmptyString;
+                    readonly url: Schema.NonEmptyString;
+                }>>;
+                readonly sources: Schema.$Array<Schema.NonEmptyString>;
+                readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+            }>, Schema.Struct<{
+                readonly modeling: Schema.Literal<"native-unmodeled">;
                 readonly availability: Schema.Union<readonly [Schema.Struct<{
                     readonly via: Schema.Literal<"native">;
                 }>, Schema.Struct<{
@@ -3717,22 +3891,30 @@ export declare const AgentSchema: Schema.Struct<{
                 }>>;
                 sources: Schema.$Array<Schema.NonEmptyString>;
             }>]>;
-            readonly axm: Schema.Union<readonly [Schema.Struct<{
-                readonly support: Schema.Literals<readonly ["supported", "planned"]>;
-                readonly lastVerified: Schema.NonEmptyString;
+            readonly axm: Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+                readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+                readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
                 readonly writer: Schema.NullOr<Schema.Struct<{
-                    readonly serializer: Schema.Literals<readonly ["claude-code-settings"]>;
-                }>>;
-            }>, Schema.Struct<{
-                readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
-                readonly writer: Schema.NullOr<Schema.Struct<{
-                    readonly serializer: Schema.Literals<readonly ["claude-code-settings"]>;
+                    readonly serializer: Schema.Literals<readonly ["command-stdin"]>;
+                    readonly configFiles: Schema.NonEmptyArray<Schema.Struct<{
+                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                        readonly path: Schema.NonEmptyString;
+                        readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "starlark", "vscode-settings"]>;
+                        readonly gitignored: Schema.Boolean;
+                    }>>;
+                    readonly settingsKey: Schema.NonEmptyString;
+                    readonly eventMap: Schema.Literal<"native.events">;
+                    readonly matcherKind: Schema.Literals<readonly ["regex", "literal-list", "glob", "tool-category", "exact-substring", "none-imperative"]>;
+                    readonly matcherSerialization: Schema.Literals<readonly ["bare", "slash-delimited", "glob"]>;
+                    readonly timeoutSerialization: Schema.Literals<readonly ["seconds", "milliseconds"]>;
+                    readonly commandNameSerialization: Schema.Literals<readonly ["omit", "manifest"]>;
                 }>>;
-            }>]>;
+            }>;
         }>;
     }>;
     readonly permissions: Schema.Struct<{
-        readonly canonical: Schema.Union<readonly [Schema.Struct<{
+        readonly native: Schema.Union<readonly [Schema.Struct<{
             readonly mechanism: Schema.NonEmptyArray<Schema.Literals<readonly ["config-file", "cli-flag", "ui-only"]>>;
             readonly configFiles: Schema.$Array<Schema.Struct<{
                 readonly scope: Schema.Literals<readonly ["user", "project"]>;
@@ -3837,9 +4019,10 @@ export declare const AgentSchema: Schema.Struct<{
             }>>;
             sources: Schema.$Array<Schema.NonEmptyString>;
         }>]>;
-        readonly axm: Schema.Union<readonly [Schema.Struct<{
-            readonly support: Schema.Literals<readonly ["supported", "planned"]>;
-            readonly lastVerified: Schema.NonEmptyString;
+        readonly axm: Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+            readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+            readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
             readonly writer: Schema.NullOr<Schema.Struct<{
                 readonly grants: Schema.$Record<Schema.String, Schema.Struct<{
                     readonly target: Schema.NonEmptyString;
@@ -3847,16 +4030,7 @@ export declare const AgentSchema: Schema.Struct<{
                     readonly template: Schema.NullOr<Schema.NonEmptyString>;
                 }>>;
             }>>;
-        }>, Schema.Struct<{
-            readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
-            readonly writer: Schema.NullOr<Schema.Struct<{
-                readonly grants: Schema.$Record<Schema.String, Schema.Struct<{
-                    readonly target: Schema.NonEmptyString;
-                    readonly patch: Schema.NullOr<Schema.Unknown>;
-                    readonly template: Schema.NullOr<Schema.NonEmptyString>;
-                }>>;
-            }>>;
-        }>]>;
+        }>;
     }>;
 }>;
 /** @experimental This API is unstable and may change without notice. */