@agentxm/extension-model 0.36.0 → 0.37.0

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

@@ -56,20 +56,31 @@ export declare const ConventionSchema: Schema.Literals<readonly ["universal", "v
 /** @experimental This API is unstable and may change without notice. */
 export type Convention = Schema.Schema.Type<typeof ConventionSchema>;
 /** @experimental This API is unstable and may change without notice. */
-export declare const SkillReadPathStatusSchema: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
-/** @experimental This API is unstable and may change without notice. */
-export type SkillReadPathStatus = Schema.Schema.Type<typeof SkillReadPathStatusSchema>;
-/** @experimental This API is unstable and may change without notice. */
-export declare const SkillReadPathSchema: Schema.Struct<{
-    readonly path: Schema.NonEmptyString;
-    readonly status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
-}>;
-/** @experimental This API is unstable and may change without notice. */
-export type SkillReadPath = Schema.Schema.Type<typeof SkillReadPathSchema>;
-/** @experimental This API is unstable and may change without notice. */
 export declare const ScopeSchema: Schema.Literals<readonly ["user", "project"]>;
 /** @experimental This API is unstable and may change without notice. */
 export type Scope = Schema.Schema.Type<typeof ScopeSchema>;
+export declare const NativeReadLocationSchema: Schema.Struct<{
+    scope: Schema.Literals<readonly ["user", "project"]>;
+    root: Schema.Literals<readonly ["project", "home", "xdg-config"]>;
+    path: Schema.NonEmptyString;
+    configRootRelativePath: Schema.optionalKey<Schema.NonEmptyString>;
+    shape: Schema.Literals<readonly ["directory", "file"]>;
+    role: Schema.Literals<readonly ["primary", "additional"]>;
+    status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
+    applicability: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"always">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"conditional">;
+        readonly condition: Schema.NonEmptyString;
+    }>]>;
+    provenance: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"capability-sources">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"sources">;
+        readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+    }>]>;
+}>;
+export type NativeReadLocation = Schema.Schema.Type<typeof NativeReadLocationSchema>;
 /** @experimental This API is unstable and may change without notice. */
 export declare const SUPPORTED_AXM_SUPPORT: "supported";
 /** @experimental This API is unstable and may change without notice. */
@@ -400,11 +411,27 @@ export type NativeCapabilityBase = Schema.Schema.Type<typeof NativeCapabilityBas
 export declare const SkillsExtensionCapabilitySchema: Schema.Struct<{
     readonly native: Schema.Union<readonly [Schema.Struct<{
         readonly convention: Schema.Literals<readonly ["universal", "vendor"]>;
-        readonly directory: Schema.NonEmptyString;
-        readonly additionalReadPaths: Schema.optionalKey<Schema.withDecodingDefaultKey<Schema.$Array<Schema.Struct<{
-            readonly path: Schema.NonEmptyString;
-            readonly status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
-        }>>, never>>;
+        readonly locations: Schema.$Array<Schema.Struct<{
+            scope: Schema.Literals<readonly ["user", "project"]>;
+            root: Schema.Literals<readonly ["project", "home", "xdg-config"]>;
+            path: Schema.NonEmptyString;
+            configRootRelativePath: Schema.optionalKey<Schema.NonEmptyString>;
+            shape: Schema.Literals<readonly ["directory", "file"]>;
+            role: Schema.Literals<readonly ["primary", "additional"]>;
+            status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
+            applicability: Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"always">;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"conditional">;
+                readonly condition: Schema.NonEmptyString;
+            }>]>;
+            provenance: Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"capability-sources">;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"sources">;
+                readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+            }>]>;
+        }>>;
         readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
         readonly availability: Schema.Union<readonly [Schema.Struct<{
             readonly via: Schema.Literal<"native">;
@@ -554,18 +581,32 @@ export declare const SkillsExtensionCapabilitySchema: Schema.Struct<{
 /** @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. */
-/** @experimental This API is unstable and may change without notice. */
-export declare const SubagentsLayoutSchema: Schema.Literals<readonly ["file", "directory"]>;
-/** @experimental This API is unstable and may change without notice. */
-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 native: Schema.Union<readonly [Schema.Struct<{
         readonly availability: Schema.Struct<{
             readonly via: Schema.Literal<"native">;
         }>;
-        readonly directory: Schema.NonEmptyString;
-        readonly layout: Schema.Literals<readonly ["file", "directory"]>;
+        readonly locations: Schema.$Array<Schema.Struct<{
+            scope: Schema.Literals<readonly ["user", "project"]>;
+            root: Schema.Literals<readonly ["project", "home", "xdg-config"]>;
+            path: Schema.NonEmptyString;
+            configRootRelativePath: Schema.optionalKey<Schema.NonEmptyString>;
+            shape: Schema.Literals<readonly ["directory", "file"]>;
+            role: Schema.Literals<readonly ["primary", "additional"]>;
+            status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
+            applicability: Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"always">;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"conditional">;
+                readonly condition: Schema.NonEmptyString;
+            }>]>;
+            provenance: Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"capability-sources">;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"sources">;
+                readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+            }>]>;
+        }>>;
         readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
             readonly state: Schema.Literal<"active">;
         }>, Schema.Struct<{
@@ -692,133 +733,30 @@ export type RuleInstructionsImportSyntax = Schema.Schema.Type<typeof RuleInstruc
 /** @experimental This API is unstable and may change without notice. */
 export declare const RulesExtensionCapabilitySchema: 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;
-        readonly importSyntax: Schema.NullOr<Schema.Literals<readonly ["at-path"]>>;
-        readonly directory: Schema.optionalKey<Schema.NonEmptyString>;
-        readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
-        readonly convention: Schema.Literals<readonly ["universal", "vendor", "hosted"]>;
-        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", "mcp-server", "subagent", "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", "mcp-server", "subagent", "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", "mcp-server", "subagent", "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 kind: Schema.Literal<"own-file">;
-        readonly files: Schema.Tuple<readonly [Schema.NonEmptyString]>;
-        readonly nestedDiscovery: Schema.Boolean;
-        readonly importSyntax: Schema.NullOr<Schema.Literals<readonly ["at-path"]>>;
-        readonly directory: Schema.optionalKey<Schema.NonEmptyString>;
-        readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
-        readonly convention: Schema.Literals<readonly ["universal", "vendor", "hosted"]>;
-        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", "mcp-server", "subagent", "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", "mcp-server", "subagent", "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", "mcp-server", "subagent", "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 kind: Schema.Literals<readonly ["agents-md", "own-file", "rules-dir"]>;
+        readonly locations: Schema.$Array<Schema.Struct<{
+            scope: Schema.Literals<readonly ["user", "project"]>;
+            root: Schema.Literals<readonly ["project", "home", "xdg-config"]>;
+            path: Schema.NonEmptyString;
+            configRootRelativePath: Schema.optionalKey<Schema.NonEmptyString>;
+            shape: Schema.Literals<readonly ["directory", "file"]>;
+            role: Schema.Literals<readonly ["primary", "additional"]>;
+            status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
+            applicability: Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"always">;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"conditional">;
+                readonly condition: Schema.NonEmptyString;
+            }>]>;
+            provenance: Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"capability-sources">;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"sources">;
+                readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+            }>]>;
         }>>;
-        readonly sources: Schema.$Array<Schema.NonEmptyString>;
-        readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
-    }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"rules-dir">;
-        readonly files: Schema.$Array<Schema.NonEmptyString>;
         readonly nestedDiscovery: Schema.Boolean;
         readonly importSyntax: Schema.NullOr<Schema.Literals<readonly ["at-path"]>>;
-        readonly directory: Schema.NonEmptyString;
         readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
         readonly convention: Schema.Literals<readonly ["universal", "vendor", "hosted"]>;
         readonly availability: Schema.Union<readonly [Schema.Struct<{
@@ -916,6 +854,34 @@ export type RulesExtensionCapability = Schema.Schema.Type<typeof RulesExtensionC
 export declare const ConfigFileFormatSchema: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
 /** @experimental This API is unstable and may change without notice. */
 export type ConfigFileFormat = Schema.Schema.Type<typeof ConfigFileFormatSchema>;
+/** One declared native configuration reader, independently of any AXM writer. */
+export declare const NativeConfigReadLocationSchema: Schema.Struct<{
+    readonly shape: Schema.Literal<"file">;
+    readonly id: Schema.NonEmptyString;
+    readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+    readonly keyPath: Schema.optionalKey<Schema.NonEmptyArray<Schema.NonEmptyString>>;
+    readonly attribution: Schema.optionalKey<Schema.Literals<readonly ["shared", "agent"]>>;
+    readonly gitignored: Schema.optionalKey<Schema.Boolean>;
+    readonly scope: Schema.Literals<readonly ["user", "project"]>;
+    readonly root: Schema.Literals<readonly ["project", "home", "xdg-config"]>;
+    readonly path: Schema.NonEmptyString;
+    readonly configRootRelativePath: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly role: Schema.Literals<readonly ["primary", "additional"]>;
+    readonly status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
+    readonly applicability: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"always">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"conditional">;
+        readonly condition: Schema.NonEmptyString;
+    }>]>;
+    readonly provenance: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"capability-sources">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"sources">;
+        readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+    }>]>;
+}>;
+export type NativeConfigReadLocation = Schema.Schema.Type<typeof NativeConfigReadLocationSchema>;
 /** @experimental This API is unstable and may change without notice. */
 export declare const McpServersKeySchema: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
 /** @experimental This API is unstable and may change without notice. */
@@ -926,6 +892,8 @@ export declare const McpTargetAttributionSchema: Schema.Literals<readonly ["shar
 export type McpTargetAttribution = Schema.Schema.Type<typeof McpTargetAttributionSchema>;
 /** @experimental This API is unstable and may change without notice. */
 export declare const McpConfigTargetSchema: Schema.Struct<{
+    /** Explicit captured native root for a resolved runtime destination. */
+    readonly nativeRoot: Schema.optionalKey<Schema.NonEmptyString>;
     readonly scope: Schema.Literals<readonly ["user", "project"]>;
     readonly path: Schema.NonEmptyString;
     readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
@@ -1026,6 +994,7 @@ export declare const McpUrlKeyMapSchema: Schema.Struct<{
 export type McpUrlKeyMap = Schema.Schema.Type<typeof McpUrlKeyMapSchema>;
 /** @experimental This API is unstable and may change without notice. */
 export declare const McpRemoteDialectSchema: Schema.Struct<{
+    readonly implicitTransport: Schema.optionalKey<Schema.Literal<"http-or-sse">>;
     readonly typeField: Schema.Struct<{
         readonly required: Schema.NullOr<Schema.Struct<{
             readonly name: Schema.NonEmptyString;
@@ -1053,8 +1022,7 @@ export declare const McpRemoteDialectSchema: Schema.Struct<{
 /** @experimental This API is unstable and may change without notice. */
 export type McpRemoteDialect = Schema.Schema.Type<typeof McpRemoteDialectSchema>;
 /** @experimental This API is unstable and may change without notice. */
-export declare const McpConfigSchema: Schema.Struct<{
-    readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
+export declare const McpEntryDialectSchema: Schema.Struct<{
     readonly activationField: Schema.Struct<{
         readonly required: Schema.NullOr<Schema.Struct<{
             readonly name: Schema.NonEmptyString;
@@ -1067,12 +1035,6 @@ export declare const McpConfigSchema: Schema.Struct<{
             readonly disabled: 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", "yaml", "starlark", "vscode-settings"]>;
-        readonly attribution: Schema.Literals<readonly ["shared", "agent"]>;
-    }>>;
     readonly stdio: Schema.NullOr<Schema.Struct<{
         readonly typeField: Schema.Struct<{
             readonly required: Schema.NullOr<Schema.Struct<{
@@ -1096,6 +1058,7 @@ export declare const McpConfigSchema: Schema.Struct<{
         readonly envVarsKey: Schema.optional<Schema.NonEmptyString>;
     }>>;
     readonly remote: Schema.NullOr<Schema.Struct<{
+        readonly implicitTransport: Schema.optionalKey<Schema.Literal<"http-or-sse">>;
         readonly typeField: Schema.Struct<{
             readonly required: Schema.NullOr<Schema.Struct<{
                 readonly name: Schema.NonEmptyString;
@@ -1122,6 +1085,12 @@ export declare const McpConfigSchema: Schema.Struct<{
     }>>;
 }>;
 /** @experimental This API is unstable and may change without notice. */
+export type McpEntryDialect = Schema.Schema.Type<typeof McpEntryDialectSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const McpConfigSchema: Schema.Struct<{
+    readonly locationIds: Schema.NonEmptyArray<Schema.NonEmptyString>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
 export type McpConfig = Schema.Schema.Type<typeof McpConfigSchema>;
 /** @experimental This API is unstable and may change without notice. */
 export declare const McpEnvExpansionSchema: Schema.Struct<{
@@ -1134,6 +1103,94 @@ export type McpEnvExpansion = Schema.Schema.Type<typeof McpEnvExpansionSchema>;
 export declare const McpExtensionCapabilitySchema: Schema.Union<readonly [Schema.Struct<{
     readonly native: Schema.Struct<{
         readonly transports: Schema.NonEmptyArray<Schema.Literals<readonly ["stdio", "http", "sse"]>>;
+        readonly entryDialect: Schema.NullOr<Schema.Struct<{
+            readonly activationField: Schema.Struct<{
+                readonly required: Schema.NullOr<Schema.Struct<{
+                    readonly name: Schema.NonEmptyString;
+                    readonly enabled: Schema.Boolean;
+                    readonly disabled: Schema.Boolean;
+                }>>;
+                readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+                    readonly name: Schema.NonEmptyString;
+                    readonly enabled: Schema.Boolean;
+                    readonly disabled: Schema.Boolean;
+                }>>>;
+            }>;
+            readonly stdio: Schema.NullOr<Schema.Struct<{
+                readonly typeField: Schema.Struct<{
+                    readonly required: 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 accepted: Schema.NonEmptyArray<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>;
+                /** Native allowlist for forwarding same-name environment variables. */
+                readonly envVarsKey: Schema.optional<Schema.NonEmptyString>;
+            }>>;
+            readonly remote: Schema.NullOr<Schema.Struct<{
+                readonly implicitTransport: Schema.optionalKey<Schema.Literal<"http-or-sse">>;
+                readonly typeField: Schema.Struct<{
+                    readonly required: 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 accepted: Schema.NonEmptyArray<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 bearerTokenEnvKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
+                readonly envHeadersKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
+            }>>;
+        }>>;
+        readonly locations: Schema.$Array<Schema.Struct<{
+            readonly shape: Schema.Literal<"file">;
+            readonly id: Schema.NonEmptyString;
+            readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+            readonly keyPath: Schema.optionalKey<Schema.NonEmptyArray<Schema.NonEmptyString>>;
+            readonly attribution: Schema.optionalKey<Schema.Literals<readonly ["shared", "agent"]>>;
+            readonly gitignored: Schema.optionalKey<Schema.Boolean>;
+            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+            readonly root: Schema.Literals<readonly ["project", "home", "xdg-config"]>;
+            readonly path: Schema.NonEmptyString;
+            readonly configRootRelativePath: Schema.optionalKey<Schema.NonEmptyString>;
+            readonly role: Schema.Literals<readonly ["primary", "additional"]>;
+            readonly status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
+            readonly applicability: Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"always">;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"conditional">;
+                readonly condition: Schema.NonEmptyString;
+            }>]>;
+            readonly provenance: Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"capability-sources">;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"sources">;
+                readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+            }>]>;
+        }>>;
         readonly mcpEnvExpansion: Schema.optionalKey<Schema.Struct<{
             readonly variables: Schema.Literals<readonly ["none", "braced"]>;
             readonly defaults: Schema.Boolean;
@@ -1200,72 +1257,7 @@ export declare const McpExtensionCapabilitySchema: Schema.Union<readonly [Schema
         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"]>;
-                readonly activationField: Schema.Struct<{
-                    readonly required: Schema.NullOr<Schema.Struct<{
-                        readonly name: Schema.NonEmptyString;
-                        readonly enabled: Schema.Boolean;
-                        readonly disabled: Schema.Boolean;
-                    }>>;
-                    readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
-                        readonly name: Schema.NonEmptyString;
-                        readonly enabled: Schema.Boolean;
-                        readonly disabled: 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", "yaml", "starlark", "vscode-settings"]>;
-                    readonly attribution: Schema.Literals<readonly ["shared", "agent"]>;
-                }>>;
-                readonly stdio: Schema.NullOr<Schema.Struct<{
-                    readonly typeField: Schema.Struct<{
-                        readonly required: 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 accepted: Schema.NonEmptyArray<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>;
-                    /** Native allowlist for forwarding same-name environment variables. */
-                    readonly envVarsKey: Schema.optional<Schema.NonEmptyString>;
-                }>>;
-                readonly remote: Schema.NullOr<Schema.Struct<{
-                    readonly typeField: Schema.Struct<{
-                        readonly required: 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 accepted: Schema.NonEmptyArray<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 bearerTokenEnvKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
-                    readonly envHeadersKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
-                }>>;
+                readonly locationIds: Schema.NonEmptyArray<Schema.NonEmptyString>;
             }>;
         }>>;
     }>;
@@ -1305,72 +1297,7 @@ export declare const McpExtensionCapabilitySchema: Schema.Union<readonly [Schema
         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"]>;
-                readonly activationField: Schema.Struct<{
-                    readonly required: Schema.NullOr<Schema.Struct<{
-                        readonly name: Schema.NonEmptyString;
-                        readonly enabled: Schema.Boolean;
-                        readonly disabled: Schema.Boolean;
-                    }>>;
-                    readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
-                        readonly name: Schema.NonEmptyString;
-                        readonly enabled: Schema.Boolean;
-                        readonly disabled: 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", "yaml", "starlark", "vscode-settings"]>;
-                    readonly attribution: Schema.Literals<readonly ["shared", "agent"]>;
-                }>>;
-                readonly stdio: Schema.NullOr<Schema.Struct<{
-                    readonly typeField: Schema.Struct<{
-                        readonly required: 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 accepted: Schema.NonEmptyArray<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>;
-                    /** Native allowlist for forwarding same-name environment variables. */
-                    readonly envVarsKey: Schema.optional<Schema.NonEmptyString>;
-                }>>;
-                readonly remote: Schema.NullOr<Schema.Struct<{
-                    readonly typeField: Schema.Struct<{
-                        readonly required: 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 accepted: Schema.NonEmptyArray<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 bearerTokenEnvKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
-                    readonly envHeadersKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
-                }>>;
+                readonly locationIds: Schema.NonEmptyArray<Schema.NonEmptyString>;
             }>;
         }>>;
     }>;
@@ -1386,15 +1313,6 @@ export declare const PermissionGrammarStyleSchema: Schema.Literals<readonly ["to
 /** @experimental This API is unstable and may change without notice. */
 export type PermissionGrammarStyle = Schema.Schema.Type<typeof PermissionGrammarStyleSchema>;
 /** @experimental This API is unstable and may change without notice. */
-export declare const ConfigFileLocationSchema: Schema.Struct<{
-    readonly scope: Schema.Literals<readonly ["user", "project"]>;
-    readonly path: Schema.NonEmptyString;
-    readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
-    readonly gitignored: Schema.Boolean;
-}>;
-/** @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 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"]>;
@@ -1525,32 +1443,58 @@ export declare const HookCommandNameSerializationSchema: Schema.Literals<readonl
 /** @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<{
+export declare const HookEntryDialectSchema: 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", "yaml", "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 HookEntryDialect = Schema.Schema.Type<typeof HookEntryDialectSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HooksWriterSchema: Schema.Struct<{
+    readonly locationIds: Schema.NonEmptyArray<Schema.NonEmptyString>;
+    readonly eventMap: Schema.Literal<"native.events">;
+}>;
+/** @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 native: Schema.Union<readonly [Schema.Struct<{
         readonly mechanism: Schema.NonEmptyArray<Schema.Literals<readonly ["command-stdin", "raw"]>>;
-        readonly configFiles: Schema.$Array<Schema.Struct<{
+        readonly entryDialect: Schema.NullOr<Schema.Struct<{
+            readonly serializer: Schema.Literals<readonly ["command-stdin"]>;
+            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 locations: Schema.$Array<Schema.Struct<{
+            readonly shape: Schema.Literal<"file">;
+            readonly id: Schema.NonEmptyString;
+            readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+            readonly keyPath: Schema.optionalKey<Schema.NonEmptyArray<Schema.NonEmptyString>>;
+            readonly attribution: Schema.optionalKey<Schema.Literals<readonly ["shared", "agent"]>>;
+            readonly gitignored: Schema.optionalKey<Schema.Boolean>;
             readonly scope: Schema.Literals<readonly ["user", "project"]>;
+            readonly root: Schema.Literals<readonly ["project", "home", "xdg-config"]>;
             readonly path: Schema.NonEmptyString;
-            readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
-            readonly gitignored: Schema.Boolean;
+            readonly configRootRelativePath: Schema.optionalKey<Schema.NonEmptyString>;
+            readonly role: Schema.Literals<readonly ["primary", "additional"]>;
+            readonly status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
+            readonly applicability: Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"always">;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"conditional">;
+                readonly condition: Schema.NonEmptyString;
+            }>]>;
+            readonly provenance: Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"capability-sources">;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"sources">;
+                readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+            }>]>;
         }>>;
         readonly events: Schema.NonEmptyArray<Schema.Struct<{
             readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
@@ -1633,6 +1577,39 @@ export declare const HooksExtensionCapabilitySchema: Schema.Struct<{
         readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
     }>, Schema.Struct<{
         readonly modeling: Schema.Literal<"native-unmodeled">;
+        readonly entryDialect: Schema.NullOr<Schema.Struct<{
+            readonly serializer: Schema.Literals<readonly ["command-stdin"]>;
+            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 locations: Schema.$Array<Schema.Struct<{
+            readonly shape: Schema.Literal<"file">;
+            readonly id: Schema.NonEmptyString;
+            readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+            readonly keyPath: Schema.optionalKey<Schema.NonEmptyArray<Schema.NonEmptyString>>;
+            readonly attribution: Schema.optionalKey<Schema.Literals<readonly ["shared", "agent"]>>;
+            readonly gitignored: Schema.optionalKey<Schema.Boolean>;
+            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+            readonly root: Schema.Literals<readonly ["project", "home", "xdg-config"]>;
+            readonly path: Schema.NonEmptyString;
+            readonly configRootRelativePath: Schema.optionalKey<Schema.NonEmptyString>;
+            readonly role: Schema.Literals<readonly ["primary", "additional"]>;
+            readonly status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
+            readonly applicability: Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"always">;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"conditional">;
+                readonly condition: Schema.NonEmptyString;
+            }>]>;
+            readonly provenance: Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"capability-sources">;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"sources">;
+                readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+            }>]>;
+        }>>;
         readonly availability: Schema.Union<readonly [Schema.Struct<{
             readonly via: Schema.Literal<"native">;
         }>, Schema.Struct<{
@@ -1720,19 +1697,8 @@ export declare const HooksExtensionCapabilitySchema: Schema.Struct<{
         readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
         readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
         readonly writer: Schema.NullOr<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", "yaml", "starlark", "vscode-settings"]>;
-                readonly gitignored: Schema.Boolean;
-            }>>;
-            readonly settingsKey: Schema.NonEmptyString;
+            readonly locationIds: Schema.NonEmptyArray<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"]>;
         }>>;
     }>;
 }>;
@@ -1764,7 +1730,14 @@ export declare const PermissionCliFlagSchema: Schema.Struct<{
 export type PermissionCliFlag = Schema.Schema.Type<typeof PermissionCliFlagSchema>;
 /** @experimental This API is unstable and may change without notice. */
 export declare const PermissionGrantSchema: Schema.Struct<{
-    readonly target: Schema.NonEmptyString;
+    readonly destination: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"location">;
+        readonly locationId: Schema.NonEmptyString;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"invocation">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"settings-ui">;
+    }>]>;
     readonly patch: Schema.NullOr<Schema.Unknown>;
     readonly template: Schema.NullOr<Schema.NonEmptyString>;
 }>;
@@ -1774,11 +1747,31 @@ export type PermissionGrant = Schema.Schema.Type<typeof PermissionGrantSchema>;
 export declare const PermissionsExtensionCapabilitySchema: 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 locations: Schema.$Array<Schema.Struct<{
+            readonly shape: Schema.Literal<"file">;
+            readonly id: Schema.NonEmptyString;
+            readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+            readonly keyPath: Schema.optionalKey<Schema.NonEmptyArray<Schema.NonEmptyString>>;
+            readonly attribution: Schema.optionalKey<Schema.Literals<readonly ["shared", "agent"]>>;
+            readonly gitignored: Schema.optionalKey<Schema.Boolean>;
             readonly scope: Schema.Literals<readonly ["user", "project"]>;
+            readonly root: Schema.Literals<readonly ["project", "home", "xdg-config"]>;
             readonly path: Schema.NonEmptyString;
-            readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
-            readonly gitignored: Schema.Boolean;
+            readonly configRootRelativePath: Schema.optionalKey<Schema.NonEmptyString>;
+            readonly role: Schema.Literals<readonly ["primary", "additional"]>;
+            readonly status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
+            readonly applicability: Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"always">;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"conditional">;
+                readonly condition: Schema.NonEmptyString;
+            }>]>;
+            readonly provenance: Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"capability-sources">;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"sources">;
+                readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+            }>]>;
         }>>;
         readonly grammar: Schema.NullOr<Schema.Struct<{
             readonly style: Schema.Literals<readonly ["tool-call", "prefix", "regex", "glob", "starlark-rule"]>;
@@ -1883,7 +1876,14 @@ export declare const PermissionsExtensionCapabilitySchema: Schema.Struct<{
         readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
         readonly writer: Schema.NullOr<Schema.Struct<{
             readonly grants: Schema.$Record<Schema.String, Schema.Struct<{
-                readonly target: Schema.NonEmptyString;
+                readonly destination: Schema.Union<readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"location">;
+                    readonly locationId: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"invocation">;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"settings-ui">;
+                }>]>;
                 readonly patch: Schema.NullOr<Schema.Unknown>;
                 readonly template: Schema.NullOr<Schema.NonEmptyString>;
             }>>;
@@ -1897,11 +1897,27 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
     skill: Schema.Struct<{
         readonly native: Schema.Union<readonly [Schema.Struct<{
             readonly convention: Schema.Literals<readonly ["universal", "vendor"]>;
-            readonly directory: Schema.NonEmptyString;
-            readonly additionalReadPaths: Schema.optionalKey<Schema.withDecodingDefaultKey<Schema.$Array<Schema.Struct<{
-                readonly path: Schema.NonEmptyString;
-                readonly status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
-            }>>, never>>;
+            readonly locations: Schema.$Array<Schema.Struct<{
+                scope: Schema.Literals<readonly ["user", "project"]>;
+                root: Schema.Literals<readonly ["project", "home", "xdg-config"]>;
+                path: Schema.NonEmptyString;
+                configRootRelativePath: Schema.optionalKey<Schema.NonEmptyString>;
+                shape: Schema.Literals<readonly ["directory", "file"]>;
+                role: Schema.Literals<readonly ["primary", "additional"]>;
+                status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
+                applicability: Schema.Union<readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"always">;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"conditional">;
+                    readonly condition: Schema.NonEmptyString;
+                }>]>;
+                provenance: Schema.Union<readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"capability-sources">;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"sources">;
+                    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                }>]>;
+            }>>;
             readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
             readonly availability: Schema.Union<readonly [Schema.Struct<{
                 readonly via: Schema.Literal<"native">;
@@ -2051,6 +2067,94 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
     "mcp-server": Schema.Union<readonly [Schema.Struct<{
         readonly native: Schema.Struct<{
             readonly transports: Schema.NonEmptyArray<Schema.Literals<readonly ["stdio", "http", "sse"]>>;
+            readonly entryDialect: Schema.NullOr<Schema.Struct<{
+                readonly activationField: Schema.Struct<{
+                    readonly required: Schema.NullOr<Schema.Struct<{
+                        readonly name: Schema.NonEmptyString;
+                        readonly enabled: Schema.Boolean;
+                        readonly disabled: Schema.Boolean;
+                    }>>;
+                    readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+                        readonly name: Schema.NonEmptyString;
+                        readonly enabled: Schema.Boolean;
+                        readonly disabled: Schema.Boolean;
+                    }>>>;
+                }>;
+                readonly stdio: Schema.NullOr<Schema.Struct<{
+                    readonly typeField: Schema.Struct<{
+                        readonly required: 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 accepted: Schema.NonEmptyArray<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>;
+                    /** Native allowlist for forwarding same-name environment variables. */
+                    readonly envVarsKey: Schema.optional<Schema.NonEmptyString>;
+                }>>;
+                readonly remote: Schema.NullOr<Schema.Struct<{
+                    readonly implicitTransport: Schema.optionalKey<Schema.Literal<"http-or-sse">>;
+                    readonly typeField: Schema.Struct<{
+                        readonly required: 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 accepted: Schema.NonEmptyArray<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 bearerTokenEnvKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
+                    readonly envHeadersKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
+                }>>;
+            }>>;
+            readonly locations: Schema.$Array<Schema.Struct<{
+                readonly shape: Schema.Literal<"file">;
+                readonly id: Schema.NonEmptyString;
+                readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+                readonly keyPath: Schema.optionalKey<Schema.NonEmptyArray<Schema.NonEmptyString>>;
+                readonly attribution: Schema.optionalKey<Schema.Literals<readonly ["shared", "agent"]>>;
+                readonly gitignored: Schema.optionalKey<Schema.Boolean>;
+                readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                readonly root: Schema.Literals<readonly ["project", "home", "xdg-config"]>;
+                readonly path: Schema.NonEmptyString;
+                readonly configRootRelativePath: Schema.optionalKey<Schema.NonEmptyString>;
+                readonly role: Schema.Literals<readonly ["primary", "additional"]>;
+                readonly status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
+                readonly applicability: Schema.Union<readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"always">;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"conditional">;
+                    readonly condition: Schema.NonEmptyString;
+                }>]>;
+                readonly provenance: Schema.Union<readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"capability-sources">;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"sources">;
+                    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                }>]>;
+            }>>;
             readonly mcpEnvExpansion: Schema.optionalKey<Schema.Struct<{
                 readonly variables: Schema.Literals<readonly ["none", "braced"]>;
                 readonly defaults: Schema.Boolean;
@@ -2117,72 +2221,7 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
             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"]>;
-                    readonly activationField: Schema.Struct<{
-                        readonly required: Schema.NullOr<Schema.Struct<{
-                            readonly name: Schema.NonEmptyString;
-                            readonly enabled: Schema.Boolean;
-                            readonly disabled: Schema.Boolean;
-                        }>>;
-                        readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
-                            readonly name: Schema.NonEmptyString;
-                            readonly enabled: Schema.Boolean;
-                            readonly disabled: 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", "yaml", "starlark", "vscode-settings"]>;
-                        readonly attribution: Schema.Literals<readonly ["shared", "agent"]>;
-                    }>>;
-                    readonly stdio: Schema.NullOr<Schema.Struct<{
-                        readonly typeField: Schema.Struct<{
-                            readonly required: 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 accepted: Schema.NonEmptyArray<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>;
-                        /** Native allowlist for forwarding same-name environment variables. */
-                        readonly envVarsKey: Schema.optional<Schema.NonEmptyString>;
-                    }>>;
-                    readonly remote: Schema.NullOr<Schema.Struct<{
-                        readonly typeField: Schema.Struct<{
-                            readonly required: 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 accepted: Schema.NonEmptyArray<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 bearerTokenEnvKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
-                        readonly envHeadersKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
-                    }>>;
+                    readonly locationIds: Schema.NonEmptyArray<Schema.NonEmptyString>;
                 }>;
             }>>;
         }>;
@@ -2222,72 +2261,7 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
             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"]>;
-                    readonly activationField: Schema.Struct<{
-                        readonly required: Schema.NullOr<Schema.Struct<{
-                            readonly name: Schema.NonEmptyString;
-                            readonly enabled: Schema.Boolean;
-                            readonly disabled: Schema.Boolean;
-                        }>>;
-                        readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
-                            readonly name: Schema.NonEmptyString;
-                            readonly enabled: Schema.Boolean;
-                            readonly disabled: 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", "yaml", "starlark", "vscode-settings"]>;
-                        readonly attribution: Schema.Literals<readonly ["shared", "agent"]>;
-                    }>>;
-                    readonly stdio: Schema.NullOr<Schema.Struct<{
-                        readonly typeField: Schema.Struct<{
-                            readonly required: 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 accepted: Schema.NonEmptyArray<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>;
-                        /** Native allowlist for forwarding same-name environment variables. */
-                        readonly envVarsKey: Schema.optional<Schema.NonEmptyString>;
-                    }>>;
-                    readonly remote: Schema.NullOr<Schema.Struct<{
-                        readonly typeField: Schema.Struct<{
-                            readonly required: 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 accepted: Schema.NonEmptyArray<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 bearerTokenEnvKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
-                        readonly envHeadersKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
-                    }>>;
+                    readonly locationIds: Schema.NonEmptyArray<Schema.NonEmptyString>;
                 }>;
             }>>;
         }>;
@@ -2297,8 +2271,27 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
             readonly availability: Schema.Struct<{
                 readonly via: Schema.Literal<"native">;
             }>;
-            readonly directory: Schema.NonEmptyString;
-            readonly layout: Schema.Literals<readonly ["file", "directory"]>;
+            readonly locations: Schema.$Array<Schema.Struct<{
+                scope: Schema.Literals<readonly ["user", "project"]>;
+                root: Schema.Literals<readonly ["project", "home", "xdg-config"]>;
+                path: Schema.NonEmptyString;
+                configRootRelativePath: Schema.optionalKey<Schema.NonEmptyString>;
+                shape: Schema.Literals<readonly ["directory", "file"]>;
+                role: Schema.Literals<readonly ["primary", "additional"]>;
+                status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
+                applicability: Schema.Union<readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"always">;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"conditional">;
+                    readonly condition: Schema.NonEmptyString;
+                }>]>;
+                provenance: Schema.Union<readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"capability-sources">;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"sources">;
+                    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                }>]>;
+            }>>;
             readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
                 readonly state: Schema.Literal<"active">;
             }>, Schema.Struct<{
@@ -2415,11 +2408,38 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
     hook: 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 entryDialect: Schema.NullOr<Schema.Struct<{
+                readonly serializer: Schema.Literals<readonly ["command-stdin"]>;
+                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 locations: Schema.$Array<Schema.Struct<{
+                readonly shape: Schema.Literal<"file">;
+                readonly id: Schema.NonEmptyString;
+                readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+                readonly keyPath: Schema.optionalKey<Schema.NonEmptyArray<Schema.NonEmptyString>>;
+                readonly attribution: Schema.optionalKey<Schema.Literals<readonly ["shared", "agent"]>>;
+                readonly gitignored: Schema.optionalKey<Schema.Boolean>;
                 readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                readonly root: Schema.Literals<readonly ["project", "home", "xdg-config"]>;
                 readonly path: Schema.NonEmptyString;
-                readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
-                readonly gitignored: Schema.Boolean;
+                readonly configRootRelativePath: Schema.optionalKey<Schema.NonEmptyString>;
+                readonly role: Schema.Literals<readonly ["primary", "additional"]>;
+                readonly status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
+                readonly applicability: Schema.Union<readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"always">;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"conditional">;
+                    readonly condition: Schema.NonEmptyString;
+                }>]>;
+                readonly provenance: Schema.Union<readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"capability-sources">;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"sources">;
+                    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                }>]>;
             }>>;
             readonly events: Schema.NonEmptyArray<Schema.Struct<{
                 readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
@@ -2502,6 +2522,39 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
             readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
         }>, Schema.Struct<{
             readonly modeling: Schema.Literal<"native-unmodeled">;
+            readonly entryDialect: Schema.NullOr<Schema.Struct<{
+                readonly serializer: Schema.Literals<readonly ["command-stdin"]>;
+                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 locations: Schema.$Array<Schema.Struct<{
+                readonly shape: Schema.Literal<"file">;
+                readonly id: Schema.NonEmptyString;
+                readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+                readonly keyPath: Schema.optionalKey<Schema.NonEmptyArray<Schema.NonEmptyString>>;
+                readonly attribution: Schema.optionalKey<Schema.Literals<readonly ["shared", "agent"]>>;
+                readonly gitignored: Schema.optionalKey<Schema.Boolean>;
+                readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                readonly root: Schema.Literals<readonly ["project", "home", "xdg-config"]>;
+                readonly path: Schema.NonEmptyString;
+                readonly configRootRelativePath: Schema.optionalKey<Schema.NonEmptyString>;
+                readonly role: Schema.Literals<readonly ["primary", "additional"]>;
+                readonly status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
+                readonly applicability: Schema.Union<readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"always">;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"conditional">;
+                    readonly condition: Schema.NonEmptyString;
+                }>]>;
+                readonly provenance: Schema.Union<readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"capability-sources">;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"sources">;
+                    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                }>]>;
+            }>>;
             readonly availability: Schema.Union<readonly [Schema.Struct<{
                 readonly via: Schema.Literal<"native">;
             }>, Schema.Struct<{
@@ -2589,19 +2642,8 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
             readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
             readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
             readonly writer: Schema.NullOr<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", "yaml", "starlark", "vscode-settings"]>;
-                    readonly gitignored: Schema.Boolean;
-                }>>;
-                readonly settingsKey: Schema.NonEmptyString;
+                readonly locationIds: Schema.NonEmptyArray<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"]>;
             }>>;
         }>;
     }>;
@@ -2742,11 +2784,27 @@ export declare const AgentSchema: Schema.Struct<{
         skill: Schema.Struct<{
             readonly native: Schema.Union<readonly [Schema.Struct<{
                 readonly convention: Schema.Literals<readonly ["universal", "vendor"]>;
-                readonly directory: Schema.NonEmptyString;
-                readonly additionalReadPaths: Schema.optionalKey<Schema.withDecodingDefaultKey<Schema.$Array<Schema.Struct<{
-                    readonly path: Schema.NonEmptyString;
-                    readonly status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
-                }>>, never>>;
+                readonly locations: Schema.$Array<Schema.Struct<{
+                    scope: Schema.Literals<readonly ["user", "project"]>;
+                    root: Schema.Literals<readonly ["project", "home", "xdg-config"]>;
+                    path: Schema.NonEmptyString;
+                    configRootRelativePath: Schema.optionalKey<Schema.NonEmptyString>;
+                    shape: Schema.Literals<readonly ["directory", "file"]>;
+                    role: Schema.Literals<readonly ["primary", "additional"]>;
+                    status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
+                    applicability: Schema.Union<readonly [Schema.Struct<{
+                        readonly kind: Schema.Literal<"always">;
+                    }>, Schema.Struct<{
+                        readonly kind: Schema.Literal<"conditional">;
+                        readonly condition: Schema.NonEmptyString;
+                    }>]>;
+                    provenance: Schema.Union<readonly [Schema.Struct<{
+                        readonly kind: Schema.Literal<"capability-sources">;
+                    }>, Schema.Struct<{
+                        readonly kind: Schema.Literal<"sources">;
+                        readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                    }>]>;
+                }>>;
                 readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
                 readonly availability: Schema.Union<readonly [Schema.Struct<{
                     readonly via: Schema.Literal<"native">;
@@ -2896,6 +2954,94 @@ export declare const AgentSchema: Schema.Struct<{
         "mcp-server": Schema.Union<readonly [Schema.Struct<{
             readonly native: Schema.Struct<{
                 readonly transports: Schema.NonEmptyArray<Schema.Literals<readonly ["stdio", "http", "sse"]>>;
+                readonly entryDialect: Schema.NullOr<Schema.Struct<{
+                    readonly activationField: Schema.Struct<{
+                        readonly required: Schema.NullOr<Schema.Struct<{
+                            readonly name: Schema.NonEmptyString;
+                            readonly enabled: Schema.Boolean;
+                            readonly disabled: Schema.Boolean;
+                        }>>;
+                        readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+                            readonly name: Schema.NonEmptyString;
+                            readonly enabled: Schema.Boolean;
+                            readonly disabled: Schema.Boolean;
+                        }>>>;
+                    }>;
+                    readonly stdio: Schema.NullOr<Schema.Struct<{
+                        readonly typeField: Schema.Struct<{
+                            readonly required: 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 accepted: Schema.NonEmptyArray<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>;
+                        /** Native allowlist for forwarding same-name environment variables. */
+                        readonly envVarsKey: Schema.optional<Schema.NonEmptyString>;
+                    }>>;
+                    readonly remote: Schema.NullOr<Schema.Struct<{
+                        readonly implicitTransport: Schema.optionalKey<Schema.Literal<"http-or-sse">>;
+                        readonly typeField: Schema.Struct<{
+                            readonly required: 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 accepted: Schema.NonEmptyArray<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 bearerTokenEnvKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
+                        readonly envHeadersKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
+                    }>>;
+                }>>;
+                readonly locations: Schema.$Array<Schema.Struct<{
+                    readonly shape: Schema.Literal<"file">;
+                    readonly id: Schema.NonEmptyString;
+                    readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+                    readonly keyPath: Schema.optionalKey<Schema.NonEmptyArray<Schema.NonEmptyString>>;
+                    readonly attribution: Schema.optionalKey<Schema.Literals<readonly ["shared", "agent"]>>;
+                    readonly gitignored: Schema.optionalKey<Schema.Boolean>;
+                    readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                    readonly root: Schema.Literals<readonly ["project", "home", "xdg-config"]>;
+                    readonly path: Schema.NonEmptyString;
+                    readonly configRootRelativePath: Schema.optionalKey<Schema.NonEmptyString>;
+                    readonly role: Schema.Literals<readonly ["primary", "additional"]>;
+                    readonly status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
+                    readonly applicability: Schema.Union<readonly [Schema.Struct<{
+                        readonly kind: Schema.Literal<"always">;
+                    }>, Schema.Struct<{
+                        readonly kind: Schema.Literal<"conditional">;
+                        readonly condition: Schema.NonEmptyString;
+                    }>]>;
+                    readonly provenance: Schema.Union<readonly [Schema.Struct<{
+                        readonly kind: Schema.Literal<"capability-sources">;
+                    }>, Schema.Struct<{
+                        readonly kind: Schema.Literal<"sources">;
+                        readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                    }>]>;
+                }>>;
                 readonly mcpEnvExpansion: Schema.optionalKey<Schema.Struct<{
                     readonly variables: Schema.Literals<readonly ["none", "braced"]>;
                     readonly defaults: Schema.Boolean;
@@ -2962,72 +3108,7 @@ export declare const AgentSchema: Schema.Struct<{
                 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"]>;
-                        readonly activationField: Schema.Struct<{
-                            readonly required: Schema.NullOr<Schema.Struct<{
-                                readonly name: Schema.NonEmptyString;
-                                readonly enabled: Schema.Boolean;
-                                readonly disabled: Schema.Boolean;
-                            }>>;
-                            readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
-                                readonly name: Schema.NonEmptyString;
-                                readonly enabled: Schema.Boolean;
-                                readonly disabled: 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", "yaml", "starlark", "vscode-settings"]>;
-                            readonly attribution: Schema.Literals<readonly ["shared", "agent"]>;
-                        }>>;
-                        readonly stdio: Schema.NullOr<Schema.Struct<{
-                            readonly typeField: Schema.Struct<{
-                                readonly required: 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 accepted: Schema.NonEmptyArray<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>;
-                            /** Native allowlist for forwarding same-name environment variables. */
-                            readonly envVarsKey: Schema.optional<Schema.NonEmptyString>;
-                        }>>;
-                        readonly remote: Schema.NullOr<Schema.Struct<{
-                            readonly typeField: Schema.Struct<{
-                                readonly required: 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 accepted: Schema.NonEmptyArray<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 bearerTokenEnvKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
-                            readonly envHeadersKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
-                        }>>;
+                        readonly locationIds: Schema.NonEmptyArray<Schema.NonEmptyString>;
                     }>;
                 }>>;
             }>;
@@ -3067,72 +3148,7 @@ export declare const AgentSchema: Schema.Struct<{
                 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"]>;
-                        readonly activationField: Schema.Struct<{
-                            readonly required: Schema.NullOr<Schema.Struct<{
-                                readonly name: Schema.NonEmptyString;
-                                readonly enabled: Schema.Boolean;
-                                readonly disabled: Schema.Boolean;
-                            }>>;
-                            readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
-                                readonly name: Schema.NonEmptyString;
-                                readonly enabled: Schema.Boolean;
-                                readonly disabled: 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", "yaml", "starlark", "vscode-settings"]>;
-                            readonly attribution: Schema.Literals<readonly ["shared", "agent"]>;
-                        }>>;
-                        readonly stdio: Schema.NullOr<Schema.Struct<{
-                            readonly typeField: Schema.Struct<{
-                                readonly required: 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 accepted: Schema.NonEmptyArray<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>;
-                            /** Native allowlist for forwarding same-name environment variables. */
-                            readonly envVarsKey: Schema.optional<Schema.NonEmptyString>;
-                        }>>;
-                        readonly remote: Schema.NullOr<Schema.Struct<{
-                            readonly typeField: Schema.Struct<{
-                                readonly required: 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 accepted: Schema.NonEmptyArray<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 bearerTokenEnvKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
-                            readonly envHeadersKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
-                        }>>;
+                        readonly locationIds: Schema.NonEmptyArray<Schema.NonEmptyString>;
                     }>;
                 }>>;
             }>;
@@ -3142,8 +3158,27 @@ export declare const AgentSchema: Schema.Struct<{
                 readonly availability: Schema.Struct<{
                     readonly via: Schema.Literal<"native">;
                 }>;
-                readonly directory: Schema.NonEmptyString;
-                readonly layout: Schema.Literals<readonly ["file", "directory"]>;
+                readonly locations: Schema.$Array<Schema.Struct<{
+                    scope: Schema.Literals<readonly ["user", "project"]>;
+                    root: Schema.Literals<readonly ["project", "home", "xdg-config"]>;
+                    path: Schema.NonEmptyString;
+                    configRootRelativePath: Schema.optionalKey<Schema.NonEmptyString>;
+                    shape: Schema.Literals<readonly ["directory", "file"]>;
+                    role: Schema.Literals<readonly ["primary", "additional"]>;
+                    status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
+                    applicability: Schema.Union<readonly [Schema.Struct<{
+                        readonly kind: Schema.Literal<"always">;
+                    }>, Schema.Struct<{
+                        readonly kind: Schema.Literal<"conditional">;
+                        readonly condition: Schema.NonEmptyString;
+                    }>]>;
+                    provenance: Schema.Union<readonly [Schema.Struct<{
+                        readonly kind: Schema.Literal<"capability-sources">;
+                    }>, Schema.Struct<{
+                        readonly kind: Schema.Literal<"sources">;
+                        readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                    }>]>;
+                }>>;
                 readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
                     readonly state: Schema.Literal<"active">;
                 }>, Schema.Struct<{
@@ -3260,11 +3295,38 @@ export declare const AgentSchema: Schema.Struct<{
         hook: 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 entryDialect: Schema.NullOr<Schema.Struct<{
+                    readonly serializer: Schema.Literals<readonly ["command-stdin"]>;
+                    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 locations: Schema.$Array<Schema.Struct<{
+                    readonly shape: Schema.Literal<"file">;
+                    readonly id: Schema.NonEmptyString;
+                    readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+                    readonly keyPath: Schema.optionalKey<Schema.NonEmptyArray<Schema.NonEmptyString>>;
+                    readonly attribution: Schema.optionalKey<Schema.Literals<readonly ["shared", "agent"]>>;
+                    readonly gitignored: Schema.optionalKey<Schema.Boolean>;
                     readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                    readonly root: Schema.Literals<readonly ["project", "home", "xdg-config"]>;
                     readonly path: Schema.NonEmptyString;
-                    readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
-                    readonly gitignored: Schema.Boolean;
+                    readonly configRootRelativePath: Schema.optionalKey<Schema.NonEmptyString>;
+                    readonly role: Schema.Literals<readonly ["primary", "additional"]>;
+                    readonly status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
+                    readonly applicability: Schema.Union<readonly [Schema.Struct<{
+                        readonly kind: Schema.Literal<"always">;
+                    }>, Schema.Struct<{
+                        readonly kind: Schema.Literal<"conditional">;
+                        readonly condition: Schema.NonEmptyString;
+                    }>]>;
+                    readonly provenance: Schema.Union<readonly [Schema.Struct<{
+                        readonly kind: Schema.Literal<"capability-sources">;
+                    }>, Schema.Struct<{
+                        readonly kind: Schema.Literal<"sources">;
+                        readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                    }>]>;
                 }>>;
                 readonly events: Schema.NonEmptyArray<Schema.Struct<{
                     readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
@@ -3347,6 +3409,39 @@ export declare const AgentSchema: Schema.Struct<{
                 readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
             }>, Schema.Struct<{
                 readonly modeling: Schema.Literal<"native-unmodeled">;
+                readonly entryDialect: Schema.NullOr<Schema.Struct<{
+                    readonly serializer: Schema.Literals<readonly ["command-stdin"]>;
+                    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 locations: Schema.$Array<Schema.Struct<{
+                    readonly shape: Schema.Literal<"file">;
+                    readonly id: Schema.NonEmptyString;
+                    readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+                    readonly keyPath: Schema.optionalKey<Schema.NonEmptyArray<Schema.NonEmptyString>>;
+                    readonly attribution: Schema.optionalKey<Schema.Literals<readonly ["shared", "agent"]>>;
+                    readonly gitignored: Schema.optionalKey<Schema.Boolean>;
+                    readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                    readonly root: Schema.Literals<readonly ["project", "home", "xdg-config"]>;
+                    readonly path: Schema.NonEmptyString;
+                    readonly configRootRelativePath: Schema.optionalKey<Schema.NonEmptyString>;
+                    readonly role: Schema.Literals<readonly ["primary", "additional"]>;
+                    readonly status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
+                    readonly applicability: Schema.Union<readonly [Schema.Struct<{
+                        readonly kind: Schema.Literal<"always">;
+                    }>, Schema.Struct<{
+                        readonly kind: Schema.Literal<"conditional">;
+                        readonly condition: Schema.NonEmptyString;
+                    }>]>;
+                    readonly provenance: Schema.Union<readonly [Schema.Struct<{
+                        readonly kind: Schema.Literal<"capability-sources">;
+                    }>, Schema.Struct<{
+                        readonly kind: Schema.Literal<"sources">;
+                        readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                    }>]>;
+                }>>;
                 readonly availability: Schema.Union<readonly [Schema.Struct<{
                     readonly via: Schema.Literal<"native">;
                 }>, Schema.Struct<{
@@ -3434,152 +3529,38 @@ export declare const AgentSchema: Schema.Struct<{
                 readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
                 readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
                 readonly writer: Schema.NullOr<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", "yaml", "starlark", "vscode-settings"]>;
-                        readonly gitignored: Schema.Boolean;
-                    }>>;
-                    readonly settingsKey: Schema.NonEmptyString;
+                    readonly locationIds: Schema.NonEmptyArray<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 instructions: 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;
-            readonly importSyntax: Schema.NullOr<Schema.Literals<readonly ["at-path"]>>;
-            readonly directory: Schema.optionalKey<Schema.NonEmptyString>;
-            readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
-            readonly convention: Schema.Literals<readonly ["universal", "vendor", "hosted"]>;
-            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", "mcp-server", "subagent", "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", "mcp-server", "subagent", "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", "mcp-server", "subagent", "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 kind: Schema.Literal<"own-file">;
-            readonly files: Schema.Tuple<readonly [Schema.NonEmptyString]>;
-            readonly nestedDiscovery: Schema.Boolean;
-            readonly importSyntax: Schema.NullOr<Schema.Literals<readonly ["at-path"]>>;
-            readonly directory: Schema.optionalKey<Schema.NonEmptyString>;
-            readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
-            readonly convention: Schema.Literals<readonly ["universal", "vendor", "hosted"]>;
-            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", "mcp-server", "subagent", "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", "mcp-server", "subagent", "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", "mcp-server", "subagent", "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 kind: Schema.Literals<readonly ["agents-md", "own-file", "rules-dir"]>;
+            readonly locations: Schema.$Array<Schema.Struct<{
+                scope: Schema.Literals<readonly ["user", "project"]>;
+                root: Schema.Literals<readonly ["project", "home", "xdg-config"]>;
+                path: Schema.NonEmptyString;
+                configRootRelativePath: Schema.optionalKey<Schema.NonEmptyString>;
+                shape: Schema.Literals<readonly ["directory", "file"]>;
+                role: Schema.Literals<readonly ["primary", "additional"]>;
+                status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
+                applicability: Schema.Union<readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"always">;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"conditional">;
+                    readonly condition: Schema.NonEmptyString;
+                }>]>;
+                provenance: Schema.Union<readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"capability-sources">;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"sources">;
+                    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                }>]>;
             }>>;
-            readonly sources: Schema.$Array<Schema.NonEmptyString>;
-            readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
-        }>, Schema.Struct<{
-            readonly kind: Schema.Literal<"rules-dir">;
-            readonly files: Schema.$Array<Schema.NonEmptyString>;
             readonly nestedDiscovery: Schema.Boolean;
             readonly importSyntax: Schema.NullOr<Schema.Literals<readonly ["at-path"]>>;
-            readonly directory: Schema.NonEmptyString;
             readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
             readonly convention: Schema.Literals<readonly ["universal", "vendor", "hosted"]>;
             readonly availability: Schema.Union<readonly [Schema.Struct<{
@@ -3674,11 +3655,31 @@ export declare const AgentSchema: Schema.Struct<{
     readonly permissions: 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 locations: Schema.$Array<Schema.Struct<{
+                readonly shape: Schema.Literal<"file">;
+                readonly id: Schema.NonEmptyString;
+                readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+                readonly keyPath: Schema.optionalKey<Schema.NonEmptyArray<Schema.NonEmptyString>>;
+                readonly attribution: Schema.optionalKey<Schema.Literals<readonly ["shared", "agent"]>>;
+                readonly gitignored: Schema.optionalKey<Schema.Boolean>;
                 readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                readonly root: Schema.Literals<readonly ["project", "home", "xdg-config"]>;
                 readonly path: Schema.NonEmptyString;
-                readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
-                readonly gitignored: Schema.Boolean;
+                readonly configRootRelativePath: Schema.optionalKey<Schema.NonEmptyString>;
+                readonly role: Schema.Literals<readonly ["primary", "additional"]>;
+                readonly status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
+                readonly applicability: Schema.Union<readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"always">;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"conditional">;
+                    readonly condition: Schema.NonEmptyString;
+                }>]>;
+                readonly provenance: Schema.Union<readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"capability-sources">;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"sources">;
+                    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                }>]>;
             }>>;
             readonly grammar: Schema.NullOr<Schema.Struct<{
                 readonly style: Schema.Literals<readonly ["tool-call", "prefix", "regex", "glob", "starlark-rule"]>;
@@ -3783,7 +3784,14 @@ export declare const AgentSchema: Schema.Struct<{
             readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
             readonly writer: Schema.NullOr<Schema.Struct<{
                 readonly grants: Schema.$Record<Schema.String, Schema.Struct<{
-                    readonly target: Schema.NonEmptyString;
+                    readonly destination: Schema.Union<readonly [Schema.Struct<{
+                        readonly kind: Schema.Literal<"location">;
+                        readonly locationId: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly kind: Schema.Literal<"invocation">;
+                    }>, Schema.Struct<{
+                        readonly kind: Schema.Literal<"settings-ui">;
+                    }>]>;
                     readonly patch: Schema.NullOr<Schema.Unknown>;
                     readonly template: Schema.NullOr<Schema.NonEmptyString>;
                 }>>;