@agentxm/workspace-state 0.28.4-bootstrap.0

package/dist/src/lockfile/schema.d.ts

@@ -0,0 +1,3062 @@
+/**
+ * Lockfile schema definition.
+ *
+ * The lockfile (axm-lock.yaml) records accepted immutable resolutions for
+ * externally sourced extensions.
+ *
+ * Lockfile v6 is authority, not receipt history. It contains no authored,
+ * bundled, inline, projection, completion-time, or command-history state.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+export declare const LOCKFILE_VERSION = 6;
+/**
+ * Lock entry for a single installed skill.
+ * Discriminated union by the `type` field.
+ *
+ * Every external source carries immutable accepted-resolution identity:
+ * registry version/integrity/publisher binding, Git commit/tree/content identity,
+ * or local-path content identity.
+ *
+ * Source-specific fields are at the top level based on source type.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const SkillLockEntrySchema: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"github">;
+    readonly sourceType: Schema.Literal<"github">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"skill">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literals<readonly ["agentxm", "agent-skill"]>;
+    readonly packageOwner: Schema.optional<Schema.brand<Schema.String, "Handle">>;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"gitlab">;
+    readonly sourceType: Schema.Literal<"gitlab">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"skill">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literals<readonly ["agentxm", "agent-skill"]>;
+    readonly packageOwner: Schema.optional<Schema.brand<Schema.String, "Handle">>;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"bitbucket">;
+    readonly sourceType: Schema.Literal<"bitbucket">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"skill">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literals<readonly ["agentxm", "agent-skill"]>;
+    readonly packageOwner: Schema.optional<Schema.brand<Schema.String, "Handle">>;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"azurerepos">;
+    readonly sourceType: Schema.Literal<"azurerepos">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"skill">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literals<readonly ["agentxm", "agent-skill"]>;
+    readonly packageOwner: Schema.optional<Schema.brand<Schema.String, "Handle">>;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly organization: Schema.NonEmptyString;
+    readonly project: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"git">;
+    readonly sourceType: Schema.Literal<"git">;
+    readonly sourceName: Schema.Literal<"git">;
+    readonly extensionType: Schema.Literal<"skill">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literals<readonly ["agentxm", "agent-skill"]>;
+    readonly packageOwner: Schema.optional<Schema.brand<Schema.String, "Handle">>;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly url: Schema.String;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"local">;
+    readonly sourceType: Schema.Literal<"local">;
+    readonly sourceName: Schema.Literal<"local">;
+    readonly extensionType: Schema.Literal<"skill">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literals<readonly ["agentxm", "agent-skill"]>;
+    readonly packageOwner: Schema.optional<Schema.brand<Schema.String, "Handle">>;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly path: Schema.String;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"registry">;
+    readonly sourceType: Schema.Literal<"registry">;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"skill">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly owner: Schema.brand<Schema.String, "Handle">;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+    readonly integrity: Schema.String;
+    readonly sourceName: Schema.String;
+    readonly publisherBindingId: Schema.NonEmptyString;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>]>;
+/**
+ * Inferred type for SkillLockEntry schema.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type SkillLockEntry = Schema.Schema.Type<typeof SkillLockEntrySchema>;
+/**
+ * Map of skill names to their lock entries.
+ * Skill names are simple identifiers (not FQN patterns).
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const SkillsLockMapSchema: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"github">;
+    readonly sourceType: Schema.Literal<"github">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"skill">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literals<readonly ["agentxm", "agent-skill"]>;
+    readonly packageOwner: Schema.optional<Schema.brand<Schema.String, "Handle">>;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"gitlab">;
+    readonly sourceType: Schema.Literal<"gitlab">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"skill">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literals<readonly ["agentxm", "agent-skill"]>;
+    readonly packageOwner: Schema.optional<Schema.brand<Schema.String, "Handle">>;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"bitbucket">;
+    readonly sourceType: Schema.Literal<"bitbucket">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"skill">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literals<readonly ["agentxm", "agent-skill"]>;
+    readonly packageOwner: Schema.optional<Schema.brand<Schema.String, "Handle">>;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"azurerepos">;
+    readonly sourceType: Schema.Literal<"azurerepos">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"skill">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literals<readonly ["agentxm", "agent-skill"]>;
+    readonly packageOwner: Schema.optional<Schema.brand<Schema.String, "Handle">>;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly organization: Schema.NonEmptyString;
+    readonly project: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"git">;
+    readonly sourceType: Schema.Literal<"git">;
+    readonly sourceName: Schema.Literal<"git">;
+    readonly extensionType: Schema.Literal<"skill">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literals<readonly ["agentxm", "agent-skill"]>;
+    readonly packageOwner: Schema.optional<Schema.brand<Schema.String, "Handle">>;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly url: Schema.String;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"local">;
+    readonly sourceType: Schema.Literal<"local">;
+    readonly sourceName: Schema.Literal<"local">;
+    readonly extensionType: Schema.Literal<"skill">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literals<readonly ["agentxm", "agent-skill"]>;
+    readonly packageOwner: Schema.optional<Schema.brand<Schema.String, "Handle">>;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly path: Schema.String;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"registry">;
+    readonly sourceType: Schema.Literal<"registry">;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"skill">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly owner: Schema.brand<Schema.String, "Handle">;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+    readonly integrity: Schema.String;
+    readonly sourceName: Schema.String;
+    readonly publisherBindingId: Schema.NonEmptyString;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>]>>;
+/**
+ * Inferred type for SkillsLockMap schema.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type SkillsLockMap = Schema.Schema.Type<typeof SkillsLockMapSchema>;
+/**
+ * Common fields for subagent lock entries.
+ */
+/**
+ * Lock entry for a single installed subagent.
+ * Discriminated union by the `type` field.
+ *
+ * External source entries carry immutable accepted-resolution identity.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const SubagentLockEntrySchema: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"github">;
+    readonly sourceType: Schema.Literal<"github">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"subagent">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"gitlab">;
+    readonly sourceType: Schema.Literal<"gitlab">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"subagent">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"bitbucket">;
+    readonly sourceType: Schema.Literal<"bitbucket">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"subagent">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"azurerepos">;
+    readonly sourceType: Schema.Literal<"azurerepos">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"subagent">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly organization: Schema.NonEmptyString;
+    readonly project: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"git">;
+    readonly sourceType: Schema.Literal<"git">;
+    readonly sourceName: Schema.Literal<"git">;
+    readonly extensionType: Schema.Literal<"subagent">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly url: Schema.String;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"local">;
+    readonly sourceType: Schema.Literal<"local">;
+    readonly sourceName: Schema.Literal<"local">;
+    readonly extensionType: Schema.Literal<"subagent">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly path: Schema.String;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"registry">;
+    readonly sourceType: Schema.Literal<"registry">;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"subagent">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly owner: Schema.brand<Schema.String, "Handle">;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+    readonly integrity: Schema.String;
+    readonly sourceName: Schema.String;
+    readonly publisherBindingId: Schema.NonEmptyString;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>]>;
+/**
+ * Inferred type for SubagentLockEntry schema.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type SubagentLockEntry = Schema.Schema.Type<typeof SubagentLockEntrySchema>;
+/**
+ * Map of subagent names to their lock entries.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const SubagentsLockMapSchema: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"github">;
+    readonly sourceType: Schema.Literal<"github">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"subagent">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"gitlab">;
+    readonly sourceType: Schema.Literal<"gitlab">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"subagent">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"bitbucket">;
+    readonly sourceType: Schema.Literal<"bitbucket">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"subagent">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"azurerepos">;
+    readonly sourceType: Schema.Literal<"azurerepos">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"subagent">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly organization: Schema.NonEmptyString;
+    readonly project: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"git">;
+    readonly sourceType: Schema.Literal<"git">;
+    readonly sourceName: Schema.Literal<"git">;
+    readonly extensionType: Schema.Literal<"subagent">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly url: Schema.String;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"local">;
+    readonly sourceType: Schema.Literal<"local">;
+    readonly sourceName: Schema.Literal<"local">;
+    readonly extensionType: Schema.Literal<"subagent">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly path: Schema.String;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"registry">;
+    readonly sourceType: Schema.Literal<"registry">;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"subagent">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly owner: Schema.brand<Schema.String, "Handle">;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+    readonly integrity: Schema.String;
+    readonly sourceName: Schema.String;
+    readonly publisherBindingId: Schema.NonEmptyString;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>]>>;
+/**
+ * Inferred type for SubagentsLockMap schema.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type SubagentsLockMap = Schema.Schema.Type<typeof SubagentsLockMapSchema>;
+/**
+ * Lock entry for a single installed MCP server.
+ * Discriminated union by the `type` field.
+ *
+ * Same structure as SkillLockEntry but without the `agents` field.
+ *
+ * External source entries carry immutable accepted-resolution identity. Inline
+ * servers are authored settings and therefore have no lock row.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const McpServerLockEntrySchema: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"github">;
+    readonly sourceType: Schema.Literal<"github">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"mcp-server">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"gitlab">;
+    readonly sourceType: Schema.Literal<"gitlab">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"mcp-server">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"bitbucket">;
+    readonly sourceType: Schema.Literal<"bitbucket">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"mcp-server">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"azurerepos">;
+    readonly sourceType: Schema.Literal<"azurerepos">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"mcp-server">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly organization: Schema.NonEmptyString;
+    readonly project: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"git">;
+    readonly sourceType: Schema.Literal<"git">;
+    readonly sourceName: Schema.Literal<"git">;
+    readonly extensionType: Schema.Literal<"mcp-server">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly url: Schema.String;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"local">;
+    readonly sourceType: Schema.Literal<"local">;
+    readonly sourceName: Schema.Literal<"local">;
+    readonly extensionType: Schema.Literal<"mcp-server">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly path: Schema.String;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"registry">;
+    readonly sourceType: Schema.Literal<"registry">;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"mcp-server">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly owner: Schema.brand<Schema.String, "Handle">;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+    readonly integrity: Schema.String;
+    readonly sourceName: Schema.String;
+    readonly publisherBindingId: Schema.NonEmptyString;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>]>;
+/**
+ * Inferred type for McpServerLockEntry schema.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type McpServerLockEntry = Schema.Schema.Type<typeof McpServerLockEntrySchema>;
+/**
+ * Map of MCP server names to their lock entries.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const McpServersLockMapSchema: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"github">;
+    readonly sourceType: Schema.Literal<"github">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"mcp-server">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"gitlab">;
+    readonly sourceType: Schema.Literal<"gitlab">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"mcp-server">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"bitbucket">;
+    readonly sourceType: Schema.Literal<"bitbucket">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"mcp-server">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"azurerepos">;
+    readonly sourceType: Schema.Literal<"azurerepos">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"mcp-server">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly organization: Schema.NonEmptyString;
+    readonly project: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"git">;
+    readonly sourceType: Schema.Literal<"git">;
+    readonly sourceName: Schema.Literal<"git">;
+    readonly extensionType: Schema.Literal<"mcp-server">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly url: Schema.String;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"local">;
+    readonly sourceType: Schema.Literal<"local">;
+    readonly sourceName: Schema.Literal<"local">;
+    readonly extensionType: Schema.Literal<"mcp-server">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly path: Schema.String;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"registry">;
+    readonly sourceType: Schema.Literal<"registry">;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"mcp-server">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly owner: Schema.brand<Schema.String, "Handle">;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+    readonly integrity: Schema.String;
+    readonly sourceName: Schema.String;
+    readonly publisherBindingId: Schema.NonEmptyString;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>]>>;
+/**
+ * Inferred type for McpServersLockMap schema.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type McpServersLockMap = Schema.Schema.Type<typeof McpServersLockMapSchema>;
+/**
+ * Materialized file target recorded for rule and hook lifecycle decisions.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+/**
+ * Lock entry for a single installed rule.
+ *
+ * External source entries carry immutable accepted-resolution identity.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const RuleLockEntrySchema: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"github">;
+    readonly sourceType: Schema.Literal<"github">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"rule">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"gitlab">;
+    readonly sourceType: Schema.Literal<"gitlab">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"rule">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"bitbucket">;
+    readonly sourceType: Schema.Literal<"bitbucket">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"rule">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"azurerepos">;
+    readonly sourceType: Schema.Literal<"azurerepos">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"rule">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly organization: Schema.NonEmptyString;
+    readonly project: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"git">;
+    readonly sourceType: Schema.Literal<"git">;
+    readonly sourceName: Schema.Literal<"git">;
+    readonly extensionType: Schema.Literal<"rule">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly url: Schema.String;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"local">;
+    readonly sourceType: Schema.Literal<"local">;
+    readonly sourceName: Schema.Literal<"local">;
+    readonly extensionType: Schema.Literal<"rule">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly path: Schema.String;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"registry">;
+    readonly sourceType: Schema.Literal<"registry">;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"rule">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly owner: Schema.brand<Schema.String, "Handle">;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+    readonly integrity: Schema.String;
+    readonly sourceName: Schema.String;
+    readonly publisherBindingId: Schema.NonEmptyString;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>]>;
+/** @experimental */
+export type RuleLockEntry = Schema.Schema.Type<typeof RuleLockEntrySchema>;
+/**
+ * Map of rule names to their lock entries.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const RulesLockMapSchema: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"github">;
+    readonly sourceType: Schema.Literal<"github">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"rule">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"gitlab">;
+    readonly sourceType: Schema.Literal<"gitlab">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"rule">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"bitbucket">;
+    readonly sourceType: Schema.Literal<"bitbucket">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"rule">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"azurerepos">;
+    readonly sourceType: Schema.Literal<"azurerepos">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"rule">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly organization: Schema.NonEmptyString;
+    readonly project: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"git">;
+    readonly sourceType: Schema.Literal<"git">;
+    readonly sourceName: Schema.Literal<"git">;
+    readonly extensionType: Schema.Literal<"rule">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly url: Schema.String;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"local">;
+    readonly sourceType: Schema.Literal<"local">;
+    readonly sourceName: Schema.Literal<"local">;
+    readonly extensionType: Schema.Literal<"rule">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly path: Schema.String;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"registry">;
+    readonly sourceType: Schema.Literal<"registry">;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"rule">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly owner: Schema.brand<Schema.String, "Handle">;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+    readonly integrity: Schema.String;
+    readonly sourceName: Schema.String;
+    readonly publisherBindingId: Schema.NonEmptyString;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>]>>;
+/** @experimental */
+export type RulesLockMap = Schema.Schema.Type<typeof RulesLockMapSchema>;
+/**
+ * Lock entry for a single installed hook.
+ *
+ * External source entries carry immutable accepted-resolution identity.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const HookLockEntrySchema: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"github">;
+    readonly sourceType: Schema.Literal<"github">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"hook">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"gitlab">;
+    readonly sourceType: Schema.Literal<"gitlab">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"hook">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"bitbucket">;
+    readonly sourceType: Schema.Literal<"bitbucket">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"hook">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"azurerepos">;
+    readonly sourceType: Schema.Literal<"azurerepos">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"hook">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly organization: Schema.NonEmptyString;
+    readonly project: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"git">;
+    readonly sourceType: Schema.Literal<"git">;
+    readonly sourceName: Schema.Literal<"git">;
+    readonly extensionType: Schema.Literal<"hook">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly url: Schema.String;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"local">;
+    readonly sourceType: Schema.Literal<"local">;
+    readonly sourceName: Schema.Literal<"local">;
+    readonly extensionType: Schema.Literal<"hook">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly path: Schema.String;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"registry">;
+    readonly sourceType: Schema.Literal<"registry">;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"hook">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly owner: Schema.brand<Schema.String, "Handle">;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+    readonly integrity: Schema.String;
+    readonly sourceName: Schema.String;
+    readonly publisherBindingId: Schema.NonEmptyString;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>]>;
+/** @experimental */
+export type HookLockEntry = Schema.Schema.Type<typeof HookLockEntrySchema>;
+/**
+ * Map of hook names to their lock entries.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const HooksLockMapSchema: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"github">;
+    readonly sourceType: Schema.Literal<"github">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"hook">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"gitlab">;
+    readonly sourceType: Schema.Literal<"gitlab">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"hook">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"bitbucket">;
+    readonly sourceType: Schema.Literal<"bitbucket">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"hook">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"azurerepos">;
+    readonly sourceType: Schema.Literal<"azurerepos">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"hook">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly organization: Schema.NonEmptyString;
+    readonly project: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"git">;
+    readonly sourceType: Schema.Literal<"git">;
+    readonly sourceName: Schema.Literal<"git">;
+    readonly extensionType: Schema.Literal<"hook">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly url: Schema.String;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"local">;
+    readonly sourceType: Schema.Literal<"local">;
+    readonly sourceName: Schema.Literal<"local">;
+    readonly extensionType: Schema.Literal<"hook">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly path: Schema.String;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"registry">;
+    readonly sourceType: Schema.Literal<"registry">;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"hook">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly owner: Schema.brand<Schema.String, "Handle">;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+    readonly integrity: Schema.String;
+    readonly sourceName: Schema.String;
+    readonly publisherBindingId: Schema.NonEmptyString;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>]>>;
+/** @experimental */
+export type HooksLockMap = Schema.Schema.Type<typeof HooksLockMapSchema>;
+/**
+ * Lock entry for a single installed knowledge bundle.
+ *
+ * External source entries carry immutable accepted-resolution identity.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const KnowledgeLockEntrySchema: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"github">;
+    readonly sourceType: Schema.Literal<"github">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"knowledge">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"gitlab">;
+    readonly sourceType: Schema.Literal<"gitlab">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"knowledge">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"bitbucket">;
+    readonly sourceType: Schema.Literal<"bitbucket">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"knowledge">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"azurerepos">;
+    readonly sourceType: Schema.Literal<"azurerepos">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"knowledge">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly organization: Schema.NonEmptyString;
+    readonly project: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"git">;
+    readonly sourceType: Schema.Literal<"git">;
+    readonly sourceName: Schema.Literal<"git">;
+    readonly extensionType: Schema.Literal<"knowledge">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly url: Schema.String;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"local">;
+    readonly sourceType: Schema.Literal<"local">;
+    readonly sourceName: Schema.Literal<"local">;
+    readonly extensionType: Schema.Literal<"knowledge">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly path: Schema.String;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"registry">;
+    readonly sourceType: Schema.Literal<"registry">;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"knowledge">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly owner: Schema.brand<Schema.String, "Handle">;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+    readonly integrity: Schema.String;
+    readonly sourceName: Schema.String;
+    readonly publisherBindingId: Schema.NonEmptyString;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>]>;
+export type KnowledgeLockEntry = Schema.Schema.Type<typeof KnowledgeLockEntrySchema>;
+export declare const KnowledgeLockMapSchema: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"github">;
+    readonly sourceType: Schema.Literal<"github">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"knowledge">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"gitlab">;
+    readonly sourceType: Schema.Literal<"gitlab">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"knowledge">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"bitbucket">;
+    readonly sourceType: Schema.Literal<"bitbucket">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"knowledge">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"azurerepos">;
+    readonly sourceType: Schema.Literal<"azurerepos">;
+    readonly sourceName: Schema.String;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"knowledge">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly organization: Schema.NonEmptyString;
+    readonly project: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"git">;
+    readonly sourceType: Schema.Literal<"git">;
+    readonly sourceName: Schema.Literal<"git">;
+    readonly extensionType: Schema.Literal<"knowledge">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly url: Schema.String;
+    readonly ref: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly resolvedCommit: Schema.NonEmptyString;
+    readonly resolvedTree: Schema.NonEmptyString;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"local">;
+    readonly sourceType: Schema.Literal<"local">;
+    readonly sourceName: Schema.Literal<"local">;
+    readonly extensionType: Schema.Literal<"knowledge">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+    readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly path: Schema.String;
+    readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"registry">;
+    readonly sourceType: Schema.Literal<"registry">;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"knowledge">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly owner: Schema.brand<Schema.String, "Handle">;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+    readonly integrity: Schema.String;
+    readonly sourceName: Schema.String;
+    readonly publisherBindingId: Schema.NonEmptyString;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>]>>;
+export type KnowledgeLockMap = Schema.Schema.Type<typeof KnowledgeLockMapSchema>;
+/**
+ * Registry pack lock entry - pack from a registry.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const RegistryPackLockEntrySchema: Schema.Struct<{
+    readonly type: Schema.Literal<"registry">;
+    readonly sourceType: Schema.Literal<"registry">;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"pack">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly owner: Schema.brand<Schema.String, "Handle">;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+    readonly integrity: Schema.String;
+    readonly manifestContentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly sourceName: Schema.String;
+    readonly publisherBindingId: Schema.NonEmptyString;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>;
+/**
+ * Inferred type for RegistryPackLockEntry schema.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type RegistryPackLockEntry = Schema.Schema.Type<typeof RegistryPackLockEntrySchema>;
+/**
+ * Constructor args for a registry pack lock entry.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type RegistryPackLockEntryArgs = Omit<RegistryPackLockEntry, "type">;
+/**
+ * Build a registry pack lock entry from typed args.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const makeRegistryPackLockEntry: (args: RegistryPackLockEntryArgs) => RegistryPackLockEntry;
+/**
+ * Lock entry for a single installed pack.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const PackLockEntrySchema: Schema.Struct<{
+    readonly type: Schema.Literal<"registry">;
+    readonly sourceType: Schema.Literal<"registry">;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"pack">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly owner: Schema.brand<Schema.String, "Handle">;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+    readonly integrity: Schema.String;
+    readonly manifestContentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly sourceName: Schema.String;
+    readonly publisherBindingId: Schema.NonEmptyString;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>;
+/**
+ * Inferred type for PackLockEntry schema.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type PackLockEntry = Schema.Schema.Type<typeof PackLockEntrySchema>;
+/**
+ * Map of pack names to their lock entries.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const PacksLockMapSchema: Schema.$Record<Schema.String, Schema.Struct<{
+    readonly type: Schema.Literal<"registry">;
+    readonly sourceType: Schema.Literal<"registry">;
+    readonly endpoint: Schema.URLFromString;
+    readonly extensionType: Schema.Literal<"pack">;
+    readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly packageFormat: Schema.Literal<"agentxm">;
+    readonly owner: Schema.brand<Schema.String, "Handle">;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+    readonly integrity: Schema.String;
+    readonly manifestContentIdentity: Schema.brand<Schema.String, "SourceHash">;
+    readonly sourceName: Schema.String;
+    readonly publisherBindingId: Schema.NonEmptyString;
+    readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+}>>;
+/**
+ * Inferred type for PacksLockMap schema.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type PacksLockMap = Schema.Schema.Type<typeof PacksLockMapSchema>;
+/**
+ * Every catalog extension type's lock-entry schema, keyed by type.
+ *
+ * Total by construction: a new extension type fails compile here until its lock
+ * entry exists. The parity conformance suite decodes a synthetic entry through
+ * each schema to check obligations that must hold for every type.
+ *
+ * Packs are excluded — a pack lock entry records resolved members rather than a
+ * single installed source, so it is not shape-comparable with the others.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const LOCK_ENTRY_SCHEMA_BY_TYPE: {
+    readonly skill: Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"github">;
+        readonly sourceType: Schema.Literal<"github">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"skill">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literals<readonly ["agentxm", "agent-skill"]>;
+        readonly packageOwner: Schema.optional<Schema.brand<Schema.String, "Handle">>;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"gitlab">;
+        readonly sourceType: Schema.Literal<"gitlab">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"skill">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literals<readonly ["agentxm", "agent-skill"]>;
+        readonly packageOwner: Schema.optional<Schema.brand<Schema.String, "Handle">>;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"bitbucket">;
+        readonly sourceType: Schema.Literal<"bitbucket">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"skill">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literals<readonly ["agentxm", "agent-skill"]>;
+        readonly packageOwner: Schema.optional<Schema.brand<Schema.String, "Handle">>;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"azurerepos">;
+        readonly sourceType: Schema.Literal<"azurerepos">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"skill">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literals<readonly ["agentxm", "agent-skill"]>;
+        readonly packageOwner: Schema.optional<Schema.brand<Schema.String, "Handle">>;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly organization: Schema.NonEmptyString;
+        readonly project: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"git">;
+        readonly sourceType: Schema.Literal<"git">;
+        readonly sourceName: Schema.Literal<"git">;
+        readonly extensionType: Schema.Literal<"skill">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literals<readonly ["agentxm", "agent-skill"]>;
+        readonly packageOwner: Schema.optional<Schema.brand<Schema.String, "Handle">>;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly url: Schema.String;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"local">;
+        readonly sourceType: Schema.Literal<"local">;
+        readonly sourceName: Schema.Literal<"local">;
+        readonly extensionType: Schema.Literal<"skill">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literals<readonly ["agentxm", "agent-skill"]>;
+        readonly packageOwner: Schema.optional<Schema.brand<Schema.String, "Handle">>;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly path: Schema.String;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"registry">;
+        readonly sourceType: Schema.Literal<"registry">;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"skill">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly owner: Schema.brand<Schema.String, "Handle">;
+        readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+        readonly integrity: Schema.String;
+        readonly sourceName: Schema.String;
+        readonly publisherBindingId: Schema.NonEmptyString;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>]>;
+    readonly "mcp-server": Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"github">;
+        readonly sourceType: Schema.Literal<"github">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"mcp-server">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"gitlab">;
+        readonly sourceType: Schema.Literal<"gitlab">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"mcp-server">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"bitbucket">;
+        readonly sourceType: Schema.Literal<"bitbucket">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"mcp-server">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"azurerepos">;
+        readonly sourceType: Schema.Literal<"azurerepos">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"mcp-server">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly organization: Schema.NonEmptyString;
+        readonly project: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"git">;
+        readonly sourceType: Schema.Literal<"git">;
+        readonly sourceName: Schema.Literal<"git">;
+        readonly extensionType: Schema.Literal<"mcp-server">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly url: Schema.String;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"local">;
+        readonly sourceType: Schema.Literal<"local">;
+        readonly sourceName: Schema.Literal<"local">;
+        readonly extensionType: Schema.Literal<"mcp-server">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly path: Schema.String;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"registry">;
+        readonly sourceType: Schema.Literal<"registry">;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"mcp-server">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly owner: Schema.brand<Schema.String, "Handle">;
+        readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+        readonly integrity: Schema.String;
+        readonly sourceName: Schema.String;
+        readonly publisherBindingId: Schema.NonEmptyString;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>]>;
+    readonly subagent: Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"github">;
+        readonly sourceType: Schema.Literal<"github">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"subagent">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"gitlab">;
+        readonly sourceType: Schema.Literal<"gitlab">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"subagent">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"bitbucket">;
+        readonly sourceType: Schema.Literal<"bitbucket">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"subagent">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"azurerepos">;
+        readonly sourceType: Schema.Literal<"azurerepos">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"subagent">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly organization: Schema.NonEmptyString;
+        readonly project: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"git">;
+        readonly sourceType: Schema.Literal<"git">;
+        readonly sourceName: Schema.Literal<"git">;
+        readonly extensionType: Schema.Literal<"subagent">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly url: Schema.String;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"local">;
+        readonly sourceType: Schema.Literal<"local">;
+        readonly sourceName: Schema.Literal<"local">;
+        readonly extensionType: Schema.Literal<"subagent">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly path: Schema.String;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"registry">;
+        readonly sourceType: Schema.Literal<"registry">;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"subagent">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly owner: Schema.brand<Schema.String, "Handle">;
+        readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+        readonly integrity: Schema.String;
+        readonly sourceName: Schema.String;
+        readonly publisherBindingId: Schema.NonEmptyString;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>]>;
+    readonly rule: Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"github">;
+        readonly sourceType: Schema.Literal<"github">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"rule">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"gitlab">;
+        readonly sourceType: Schema.Literal<"gitlab">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"rule">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"bitbucket">;
+        readonly sourceType: Schema.Literal<"bitbucket">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"rule">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"azurerepos">;
+        readonly sourceType: Schema.Literal<"azurerepos">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"rule">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly organization: Schema.NonEmptyString;
+        readonly project: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"git">;
+        readonly sourceType: Schema.Literal<"git">;
+        readonly sourceName: Schema.Literal<"git">;
+        readonly extensionType: Schema.Literal<"rule">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly url: Schema.String;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"local">;
+        readonly sourceType: Schema.Literal<"local">;
+        readonly sourceName: Schema.Literal<"local">;
+        readonly extensionType: Schema.Literal<"rule">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly path: Schema.String;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"registry">;
+        readonly sourceType: Schema.Literal<"registry">;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"rule">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly owner: Schema.brand<Schema.String, "Handle">;
+        readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+        readonly integrity: Schema.String;
+        readonly sourceName: Schema.String;
+        readonly publisherBindingId: Schema.NonEmptyString;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>]>;
+    readonly hook: Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"github">;
+        readonly sourceType: Schema.Literal<"github">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"hook">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"gitlab">;
+        readonly sourceType: Schema.Literal<"gitlab">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"hook">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"bitbucket">;
+        readonly sourceType: Schema.Literal<"bitbucket">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"hook">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"azurerepos">;
+        readonly sourceType: Schema.Literal<"azurerepos">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"hook">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly organization: Schema.NonEmptyString;
+        readonly project: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"git">;
+        readonly sourceType: Schema.Literal<"git">;
+        readonly sourceName: Schema.Literal<"git">;
+        readonly extensionType: Schema.Literal<"hook">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly url: Schema.String;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"local">;
+        readonly sourceType: Schema.Literal<"local">;
+        readonly sourceName: Schema.Literal<"local">;
+        readonly extensionType: Schema.Literal<"hook">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly path: Schema.String;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"registry">;
+        readonly sourceType: Schema.Literal<"registry">;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"hook">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly owner: Schema.brand<Schema.String, "Handle">;
+        readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+        readonly integrity: Schema.String;
+        readonly sourceName: Schema.String;
+        readonly publisherBindingId: Schema.NonEmptyString;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>]>;
+    readonly knowledge: Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"github">;
+        readonly sourceType: Schema.Literal<"github">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"knowledge">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"gitlab">;
+        readonly sourceType: Schema.Literal<"gitlab">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"knowledge">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"bitbucket">;
+        readonly sourceType: Schema.Literal<"bitbucket">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"knowledge">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"azurerepos">;
+        readonly sourceType: Schema.Literal<"azurerepos">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"knowledge">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly organization: Schema.NonEmptyString;
+        readonly project: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"git">;
+        readonly sourceType: Schema.Literal<"git">;
+        readonly sourceName: Schema.Literal<"git">;
+        readonly extensionType: Schema.Literal<"knowledge">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly url: Schema.String;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"local">;
+        readonly sourceType: Schema.Literal<"local">;
+        readonly sourceName: Schema.Literal<"local">;
+        readonly extensionType: Schema.Literal<"knowledge">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly path: Schema.String;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"registry">;
+        readonly sourceType: Schema.Literal<"registry">;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"knowledge">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly owner: Schema.brand<Schema.String, "Handle">;
+        readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+        readonly integrity: Schema.String;
+        readonly sourceName: Schema.String;
+        readonly publisherBindingId: Schema.NonEmptyString;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>]>;
+};
+export declare const LockfileSchema: Schema.Struct<{
+    readonly lockfileVersion: Schema.Literal<6>;
+    readonly skills: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"github">;
+        readonly sourceType: Schema.Literal<"github">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"skill">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literals<readonly ["agentxm", "agent-skill"]>;
+        readonly packageOwner: Schema.optional<Schema.brand<Schema.String, "Handle">>;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"gitlab">;
+        readonly sourceType: Schema.Literal<"gitlab">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"skill">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literals<readonly ["agentxm", "agent-skill"]>;
+        readonly packageOwner: Schema.optional<Schema.brand<Schema.String, "Handle">>;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"bitbucket">;
+        readonly sourceType: Schema.Literal<"bitbucket">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"skill">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literals<readonly ["agentxm", "agent-skill"]>;
+        readonly packageOwner: Schema.optional<Schema.brand<Schema.String, "Handle">>;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"azurerepos">;
+        readonly sourceType: Schema.Literal<"azurerepos">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"skill">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literals<readonly ["agentxm", "agent-skill"]>;
+        readonly packageOwner: Schema.optional<Schema.brand<Schema.String, "Handle">>;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly organization: Schema.NonEmptyString;
+        readonly project: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"git">;
+        readonly sourceType: Schema.Literal<"git">;
+        readonly sourceName: Schema.Literal<"git">;
+        readonly extensionType: Schema.Literal<"skill">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literals<readonly ["agentxm", "agent-skill"]>;
+        readonly packageOwner: Schema.optional<Schema.brand<Schema.String, "Handle">>;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly url: Schema.String;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"local">;
+        readonly sourceType: Schema.Literal<"local">;
+        readonly sourceName: Schema.Literal<"local">;
+        readonly extensionType: Schema.Literal<"skill">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literals<readonly ["agentxm", "agent-skill"]>;
+        readonly packageOwner: Schema.optional<Schema.brand<Schema.String, "Handle">>;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly path: Schema.String;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"registry">;
+        readonly sourceType: Schema.Literal<"registry">;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"skill">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly owner: Schema.brand<Schema.String, "Handle">;
+        readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+        readonly integrity: Schema.String;
+        readonly sourceName: Schema.String;
+        readonly publisherBindingId: Schema.NonEmptyString;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>]>>;
+    readonly subagents: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"github">;
+        readonly sourceType: Schema.Literal<"github">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"subagent">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"gitlab">;
+        readonly sourceType: Schema.Literal<"gitlab">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"subagent">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"bitbucket">;
+        readonly sourceType: Schema.Literal<"bitbucket">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"subagent">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"azurerepos">;
+        readonly sourceType: Schema.Literal<"azurerepos">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"subagent">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly organization: Schema.NonEmptyString;
+        readonly project: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"git">;
+        readonly sourceType: Schema.Literal<"git">;
+        readonly sourceName: Schema.Literal<"git">;
+        readonly extensionType: Schema.Literal<"subagent">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly url: Schema.String;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"local">;
+        readonly sourceType: Schema.Literal<"local">;
+        readonly sourceName: Schema.Literal<"local">;
+        readonly extensionType: Schema.Literal<"subagent">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly path: Schema.String;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"registry">;
+        readonly sourceType: Schema.Literal<"registry">;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"subagent">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly owner: Schema.brand<Schema.String, "Handle">;
+        readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+        readonly integrity: Schema.String;
+        readonly sourceName: Schema.String;
+        readonly publisherBindingId: Schema.NonEmptyString;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>]>>>;
+    readonly mcpServers: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"github">;
+        readonly sourceType: Schema.Literal<"github">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"mcp-server">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"gitlab">;
+        readonly sourceType: Schema.Literal<"gitlab">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"mcp-server">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"bitbucket">;
+        readonly sourceType: Schema.Literal<"bitbucket">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"mcp-server">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"azurerepos">;
+        readonly sourceType: Schema.Literal<"azurerepos">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"mcp-server">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly organization: Schema.NonEmptyString;
+        readonly project: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"git">;
+        readonly sourceType: Schema.Literal<"git">;
+        readonly sourceName: Schema.Literal<"git">;
+        readonly extensionType: Schema.Literal<"mcp-server">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly url: Schema.String;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"local">;
+        readonly sourceType: Schema.Literal<"local">;
+        readonly sourceName: Schema.Literal<"local">;
+        readonly extensionType: Schema.Literal<"mcp-server">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly path: Schema.String;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"registry">;
+        readonly sourceType: Schema.Literal<"registry">;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"mcp-server">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly owner: Schema.brand<Schema.String, "Handle">;
+        readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+        readonly integrity: Schema.String;
+        readonly sourceName: Schema.String;
+        readonly publisherBindingId: Schema.NonEmptyString;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>]>>>;
+    readonly rules: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"github">;
+        readonly sourceType: Schema.Literal<"github">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"rule">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"gitlab">;
+        readonly sourceType: Schema.Literal<"gitlab">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"rule">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"bitbucket">;
+        readonly sourceType: Schema.Literal<"bitbucket">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"rule">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"azurerepos">;
+        readonly sourceType: Schema.Literal<"azurerepos">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"rule">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly organization: Schema.NonEmptyString;
+        readonly project: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"git">;
+        readonly sourceType: Schema.Literal<"git">;
+        readonly sourceName: Schema.Literal<"git">;
+        readonly extensionType: Schema.Literal<"rule">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly url: Schema.String;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"local">;
+        readonly sourceType: Schema.Literal<"local">;
+        readonly sourceName: Schema.Literal<"local">;
+        readonly extensionType: Schema.Literal<"rule">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly path: Schema.String;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"registry">;
+        readonly sourceType: Schema.Literal<"registry">;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"rule">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly owner: Schema.brand<Schema.String, "Handle">;
+        readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+        readonly integrity: Schema.String;
+        readonly sourceName: Schema.String;
+        readonly publisherBindingId: Schema.NonEmptyString;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>]>>>;
+    readonly hooks: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"github">;
+        readonly sourceType: Schema.Literal<"github">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"hook">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"gitlab">;
+        readonly sourceType: Schema.Literal<"gitlab">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"hook">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"bitbucket">;
+        readonly sourceType: Schema.Literal<"bitbucket">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"hook">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"azurerepos">;
+        readonly sourceType: Schema.Literal<"azurerepos">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"hook">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly organization: Schema.NonEmptyString;
+        readonly project: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"git">;
+        readonly sourceType: Schema.Literal<"git">;
+        readonly sourceName: Schema.Literal<"git">;
+        readonly extensionType: Schema.Literal<"hook">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly url: Schema.String;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"local">;
+        readonly sourceType: Schema.Literal<"local">;
+        readonly sourceName: Schema.Literal<"local">;
+        readonly extensionType: Schema.Literal<"hook">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly path: Schema.String;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"registry">;
+        readonly sourceType: Schema.Literal<"registry">;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"hook">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly owner: Schema.brand<Schema.String, "Handle">;
+        readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+        readonly integrity: Schema.String;
+        readonly sourceName: Schema.String;
+        readonly publisherBindingId: Schema.NonEmptyString;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>]>>>;
+    readonly knowledge: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"github">;
+        readonly sourceType: Schema.Literal<"github">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"knowledge">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"gitlab">;
+        readonly sourceType: Schema.Literal<"gitlab">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"knowledge">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"bitbucket">;
+        readonly sourceType: Schema.Literal<"bitbucket">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"knowledge">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly owner: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"azurerepos">;
+        readonly sourceType: Schema.Literal<"azurerepos">;
+        readonly sourceName: Schema.String;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"knowledge">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly organization: Schema.NonEmptyString;
+        readonly project: Schema.NonEmptyString;
+        readonly repo: Schema.NonEmptyString;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"git">;
+        readonly sourceType: Schema.Literal<"git">;
+        readonly sourceName: Schema.Literal<"git">;
+        readonly extensionType: Schema.Literal<"knowledge">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly url: Schema.String;
+        readonly ref: Schema.optional<Schema.NonEmptyString>;
+        readonly path: Schema.optional<Schema.NonEmptyString>;
+        readonly resolvedCommit: Schema.NonEmptyString;
+        readonly resolvedTree: Schema.NonEmptyString;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"local">;
+        readonly sourceType: Schema.Literal<"local">;
+        readonly sourceName: Schema.Literal<"local">;
+        readonly extensionType: Schema.Literal<"knowledge">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly packageOwner: Schema.brand<Schema.String, "Handle">;
+        readonly packageName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly path: Schema.String;
+        readonly contentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"registry">;
+        readonly sourceType: Schema.Literal<"registry">;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"knowledge">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly owner: Schema.brand<Schema.String, "Handle">;
+        readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+        readonly integrity: Schema.String;
+        readonly sourceName: Schema.String;
+        readonly publisherBindingId: Schema.NonEmptyString;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>]>>>;
+    readonly packs: Schema.optional<Schema.$Record<Schema.String, Schema.Struct<{
+        readonly type: Schema.Literal<"registry">;
+        readonly sourceType: Schema.Literal<"registry">;
+        readonly endpoint: Schema.URLFromString;
+        readonly extensionType: Schema.Literal<"pack">;
+        readonly workspaceName: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly packageFormat: Schema.Literal<"agentxm">;
+        readonly owner: Schema.brand<Schema.String, "Handle">;
+        readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly resolvedVersion: Schema.brand<Schema.String, "Version">;
+        readonly integrity: Schema.String;
+        readonly manifestContentIdentity: Schema.brand<Schema.String, "SourceHash">;
+        readonly sourceName: Schema.String;
+        readonly publisherBindingId: Schema.NonEmptyString;
+        readonly treeIntegrity: Schema.brand<Schema.String, "TreeIntegrity">;
+    }>>>;
+}>;
+/**
+ * Inferred type for Lockfile schema.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type Lockfile = Schema.Schema.Type<typeof LockfileSchema>;
+//# sourceMappingURL=schema.d.ts.map