@agentxm/workspace-state 0.28.4-bootstrap.0 → 0.28.5

package/dist/src/index.d.ts

@@ -54,6 +54,7 @@ export { hookLockEntryToRef, knowledgeLockEntryToRef, mcpServerLockEntryToRef, p
 export { lockEntryToSourceParams, printSkillLockSourceLocator, } from "./workspace/lock-entry-to-source-params.js";
 export { sourceToLockEntry, type SourceToLockEntryInput, } from "./workspace/source-to-lock-entry.js";
 export { deriveSourceMetaFromLockType, type SourceMeta } from "./workspace/source-metadata.js";
+export { mcpRegistryResolutionKey, mcpResolutionKey } from "./workspace/mcp-source-identity.js";
 export { READ_MODEL_EXTENSION_FAMILY_BY_TYPE, makeWorkspaceReadModel, WorkspaceReadModelConfig, type RawSourceBytes, type ScopedOwnerApi, type ScopedSourceHostsApi, type ScopedStateApi, type WorkspaceReadModel, type WorkspaceReadModelConfigService, } from "./workspace/read-model/service.js";
 export { AgentRootResolver, AgentRootResolverLive, } from "./workspace/read-model/agent-root-resolver.js";
 export { ExtensionInventoryClassificationSchema, ExtensionInventoryLifecycleSchema, ExtensionInventoryRowSchema, ExtensionInventorySchema, projectExtensionInventory, type ExtensionInventory, type ExtensionInventoryClassification, type ExtensionInventoryLifecycle, type ExtensionInventoryObservation, type ExtensionInventoryRow, type LifecycleInventoryCandidate, type ProjectExtensionInventoryInput, } from "./workspace/read-model/extensions/inventory.js";
@@ -62,7 +63,7 @@ export type { ActualMcpServer, ActualPack, ActualSkill, ActualSubagent, Installe
 export type { FileSpec, FixtureSpec, ScopeFiles, TreeFiles, } from "./workspace/read-model/__fixtures__/builder.js";
 export { WorkspaceMutations, type MakeWorkspaceTransactionCapabilities, type WorkspaceMutationsService, type WorkspaceMutationsError, type WorkspaceMutationsOptions, type WorkspaceSettingsReadFailure, type WorkspaceLockfileReadFailure, type WorkspaceStateReadFailure, type WorkspaceSettingsMutationFailure, type WorkspaceLockfileMutationFailure, type WorkspaceStateMutationFailure, type SetSkillArgs, type SetPackArgs, type SetMcpServerArgs, type SetSubagentArgs, type PackDirPath, type ExtensionTarget, type ExtensionTargetFor, type LockfileState, type WorkspaceTransactionRunner, type WorkspaceTransactionCapabilities, type WorkspaceTransitionAcquirer, type WorkspaceTransitionRequest, type WorkspaceLifecycleTransactionArgs, type SkillExtensionTarget, type PackExtensionTarget, type McpServerExtensionTarget, type SubagentExtensionTarget, type RuleExtensionTarget, type HookExtensionTarget, type KnowledgeExtensionTarget, } from "./workspace/service-interface.js";
 export { makeWorkspaceMutations, type WorkspaceLayerOptions } from "./workspace/service.js";
-export { LockfileDecodeError, LockfileIoError, LockfileParseError, SettingsDecodeError, SettingsIoError, SettingsParseError, SkillDiscoveryRootInvalid, SubagentScanFailed, WorkspaceRootEscape, type LockfileReadError, type SettingsReadError, } from "./workspace/read-model/errors.js";
+export { LockfileDecodeError, LockfileIoError, LockfileParseError, LockfileVersionUnsupported, SettingsDecodeError, SettingsIoError, SettingsParseError, SkillDiscoveryRootInvalid, SubagentScanFailed, WorkspaceRootEscape, type LockfileReadError, type SettingsReadError, } from "./workspace/read-model/errors.js";
 export { AcceptedResolutionMissing, CanonicalPathRemovalError, DesiredPackGraphIncomplete, InlineExtensionSourceMissing, InvalidAgentId, LockedSkillMissing, LockEntryEndpointConflict, LockEntryNameInvalid, LockEntrySourceMissing, LockEntrySourceTypeConflict, LockEntryUrlInvalid, PackageContentHashFailed, SettingsEntryMissing, SupersededCanonicalRemovalFailed, SymlinkCreationError, WorkspaceLayoutError, WorkspaceNotInitialized, WorkspaceSourceInvalid, } from "./workspace/errors.js";
 export { CurrentWorkspaceClosure, CurrentWorkspaceTransaction, protectCreatedAncestors, protectInContext, protectWorkspacePath, readPendingClosureRestorationFailures, type Snapshot, type WorkspaceTransactionContext, TransitionLockError, TransitionLockUnavailable, WorkspaceDirectoryError, WorkspaceRestorationError, WorkspaceRestorationIncomplete, WorkspaceSnapshotError, WorkspaceTransitionCompromised, type TransitionContention, type TransitionLockHolder, type WorkspaceTransactionFailure, type WorkspaceTransitionAcquireFailure, } from "./workspace/transaction.js";
 export { setupScopeSupport, setupScopeSupportOutcomes, type SetupScopeSupportCategory, type SetupScopeSupportOutcome, type SetupScopeSupportReasonCode, type SetupScopeSupportStatus, } from "./workspace/setup-scope-support.js";

package/dist/src/index.js

@@ -67,6 +67,7 @@ export { lockEntryToSourceParams, printSkillLockSourceLocator, } from "./workspa
 export { sourceToLockEntry, } from "./workspace/source-to-lock-entry.js";
 // Source metadata
 export { deriveSourceMetaFromLockType } from "./workspace/source-metadata.js";
+export { mcpRegistryResolutionKey, mcpResolutionKey } from "./workspace/mcp-source-identity.js";
 // Workspace read model
 export { READ_MODEL_EXTENSION_FAMILY_BY_TYPE, makeWorkspaceReadModel, WorkspaceReadModelConfig, } from "./workspace/read-model/service.js";
 export { AgentRootResolver, AgentRootResolverLive, } from "./workspace/read-model/agent-root-resolver.js";
@@ -76,7 +77,7 @@ export { getPriorityDirectories, parsePluginManifests, scanAgentSubagentFiles, s
 export { WorkspaceMutations, } from "./workspace/service-interface.js";
 export { makeWorkspaceMutations } from "./workspace/service.js";
 // Read-model per-source typed failure families
-export { LockfileDecodeError, LockfileIoError, LockfileParseError, SettingsDecodeError, SettingsIoError, SettingsParseError, SkillDiscoveryRootInvalid, SubagentScanFailed, WorkspaceRootEscape, } from "./workspace/read-model/errors.js";
+export { LockfileDecodeError, LockfileIoError, LockfileParseError, LockfileVersionUnsupported, SettingsDecodeError, SettingsIoError, SettingsParseError, SkillDiscoveryRootInvalid, SubagentScanFailed, WorkspaceRootEscape, } from "./workspace/read-model/errors.js";
 // Workspace-state typed failure families
 export { AcceptedResolutionMissing, CanonicalPathRemovalError, DesiredPackGraphIncomplete, InlineExtensionSourceMissing, InvalidAgentId, LockedSkillMissing, LockEntryEndpointConflict, LockEntryNameInvalid, LockEntrySourceMissing, LockEntrySourceTypeConflict, LockEntryUrlInvalid, PackageContentHashFailed, SettingsEntryMissing, SupersededCanonicalRemovalFailed, SymlinkCreationError, WorkspaceLayoutError, WorkspaceNotInitialized, WorkspaceSourceInvalid, } from "./workspace/errors.js";
 // Workspace transaction registration (the WS half of the transaction seam)

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

@@ -173,7 +173,7 @@ export declare const commitLockfileUpdates: (axmDir: string, lockfile: Lockfile,
             readonly treeIntegrity: string & import("effect/Brand").Brand<"TreeIntegrity">;
         };
     };
-    readonly lockfileVersion: 6;
+    readonly lockfileVersion: 7;
     readonly knowledge?: {
         readonly [x: string]: {
             readonly type: "github";
@@ -913,7 +913,7 @@ export declare const commitLockfileSnapshotUpdateAtPath: (lockfilePath: string,
             readonly treeIntegrity: string & import("effect/Brand").Brand<"TreeIntegrity">;
         };
     };
-    readonly lockfileVersion: 6;
+    readonly lockfileVersion: 7;
     readonly knowledge?: {
         readonly [x: string]: {
             readonly type: "github";
@@ -1642,7 +1642,7 @@ export declare const commitLockfileSnapshotUpdate: (axmDir: string, base: Lockfi
             readonly treeIntegrity: string & import("effect/Brand").Brand<"TreeIntegrity">;
         };
     };
-    readonly lockfileVersion: 6;
+    readonly lockfileVersion: 7;
     readonly knowledge?: {
         readonly [x: string]: {
             readonly type: "github";

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

@@ -4,13 +4,13 @@
  * The lockfile (axm-lock.yaml) records accepted immutable resolutions for
  * externally sourced extensions.
  *
- * Lockfile v6 is authority, not receipt history. It contains no authored,
+ * Lockfile v7 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;
+export declare const LOCKFILE_VERSION = 7;
 /**
  * Lock entry for a single installed skill.
  * Discriminated union by the `type` field.
@@ -667,7 +667,8 @@ export declare const McpServerLockEntrySchema: Schema.Union<readonly [Schema.Str
  */
 export type McpServerLockEntry = Schema.Schema.Type<typeof McpServerLockEntrySchema>;
 /**
- * Map of MCP server names to their lock entries.
+ * Map of canonical MCP source-resolution identities to their lock entries.
+ * Local connection names live only in settings and native projections.
  *
  * @experimental This API is unstable and may change without notice.
  */
@@ -2339,7 +2340,7 @@ export declare const LOCK_ENTRY_SCHEMA_BY_TYPE: {
     }>]>;
 };
 export declare const LockfileSchema: Schema.Struct<{
-    readonly lockfileVersion: Schema.Literal<6>;
+    readonly lockfileVersion: Schema.Literal<7>;
     readonly skills: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
         readonly type: Schema.Literal<"github">;
         readonly sourceType: Schema.Literal<"github">;

package/dist/src/lockfile/schema.js

@@ -4,7 +4,7 @@
  * The lockfile (axm-lock.yaml) records accepted immutable resolutions for
  * externally sourced extensions.
  *
- * Lockfile v6 is authority, not receipt history. It contains no authored,
+ * Lockfile v7 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.
@@ -16,7 +16,7 @@ import { TreeIntegritySchema } from "../workspace/materialized-tree.js";
 import { ExtensionNameSchema } from "@agentxm/extension-model/unstable/extensions/common";
 import { VersionSchema } from "@agentxm/extension-model/unstable/version-constraints";
 import { SourceNamespaceSchema, SourceRefSchema, SourceSegmentSchema, SourceSubPathSchema, } from "@agentxm/extension-model/unstable/sources/types";
-export const LOCKFILE_VERSION = 6;
+export const LOCKFILE_VERSION = 7;
 // =============================================================================
 // Flat Source Schemas (discriminated by type field)
 // =============================================================================
@@ -234,7 +234,8 @@ export const McpServerLockEntrySchema = makeSourceLockUnion("mcp-server", Handle
 // MCP Servers Lock Map
 // =============================================================================
 /**
- * Map of MCP server names to their lock entries.
+ * Map of canonical MCP source-resolution identities to their lock entries.
+ * Local connection names live only in settings and native projections.
  *
  * @experimental This API is unstable and may change without notice.
  */
@@ -379,7 +380,7 @@ export const LOCK_ENTRY_SCHEMA_BY_TYPE = {
  * enabling reproducible installations across environments.
  *
  * Structure:
- * - lockfileVersion: Schema version (currently 6)
+ * - lockfileVersion: Schema version (currently 7)
  * - skills: Map of skill names to their lock entries
  * - packs: Map of pack names to their lock entries (optional)
  *

package/dist/src/workspace/accepted-canonical-ref.d.ts

@@ -9,7 +9,7 @@ import type { WorkspaceSnapshotError } from "./transaction.js";
 import { type LockEntryToRefError } from "./lock-entry-to-ref.js";
 import { type AcceptedExtensionResolution, type CanonicalObservation } from "./canonical-observation.js";
 import type { DesiredExtensionNode } from "./desired-state-graph.js";
-import type { WorkspaceLockfileReadFailure, WorkspaceMutationsService, WorkspaceStateReadFailure } from "./service-interface.js";
+import type { WorkspaceMutationsService, WorkspaceStateReadFailure } from "./service-interface.js";
 interface AcceptedCanonicalRefArgs {
     readonly workspace: WorkspaceMutationsService;
     readonly type: DesiredExtensionNode["type"];
@@ -34,7 +34,7 @@ export interface UsableAcceptedCanonical extends UsableAcceptedCanonicalObservat
 /** Canonical package AXM may delete when removing desired state. Authored source is durable. */
 export declare const removableAcceptedCanonicalPath: (canonical: Option.Option<AcceptedCanonicalObservation>) => Option.Option<string>;
 /** Exact acquired canonical path reconstructed directly from accepted lock authority. */
-export declare const acceptedLockedCanonicalPath: (args: AcceptedCanonicalRefArgs) => Effect.Effect<Option.Option<string>, WorkspaceLockfileReadFailure, Path.Path>;
+export declare const acceptedLockedCanonicalPath: (args: AcceptedCanonicalRefArgs) => Effect.Effect<Option.Option<string>, WorkspaceStateReadFailure, Path.Path>;
 /**
  * Capture exact cleanup for a superseded accepted package. The old path is
  * read before the lock transition; the returned effect runs afterward and
@@ -42,7 +42,7 @@ export declare const acceptedLockedCanonicalPath: (args: AcceptedCanonicalRefArg
  */
 export declare const prepareAcceptedCanonicalTransition: (args: AcceptedCanonicalRefArgs & {
     readonly ref: ExtensionRef;
-}) => Effect.Effect<Effect.Effect<void, WorkspaceSnapshotError | SupersededCanonicalRemovalFailed>, WorkspaceLockfileReadFailure, FileSystem.FileSystem | Path.Path>;
+}) => Effect.Effect<Effect.Effect<void, WorkspaceSnapshotError | SupersededCanonicalRemovalFailed>, WorkspaceStateReadFailure, FileSystem.FileSystem | Path.Path>;
 /** Reconstruct a ref directly from accepted lock authority without desired reachability. */
 export declare const acceptedLockedResolutionRef: (args: AcceptedCanonicalRefArgs) => Effect.Effect<Option.Option<ExtensionRef>, AcceptedCanonicalRefError, FileSystem.FileSystem | Path.Path>;
 /**

package/dist/src/workspace/accepted-canonical-ref.js

@@ -21,7 +21,7 @@ const getAcceptedResolution = (workspace, type, name) => {
             case "skill":
                 return workspace.getLockedSkill(name);
             case "mcp-server":
-                return workspace.getLockedMcpServer(name);
+                return workspace.getLockedMcpServerForConnection(name);
             case "subagent":
                 return workspace.getLockedSubagent(name);
             case "rule":
@@ -101,7 +101,7 @@ const refFromAcceptedResolution = (workspace, type, name) => Effect.gen(function
             });
         }
         case "mcp-server": {
-            const entry = yield* workspace.getLockedMcpServer(name);
+            const entry = yield* workspace.getLockedMcpServerForConnection(name);
             return yield* Option.match(entry, {
                 onNone: () => Effect.fail(missingAccepted("MCP", name)),
                 onSome: (value) => mcpServerLockEntryToRef(name, value, deps),

package/dist/src/workspace/canonical-observation.js

@@ -19,6 +19,7 @@ import { printSourceParams } from "@agentxm/extension-model/unstable/sources/pri
 import { lockEntryToSourceParams } from "./lock-entry-to-source-params.js";
 import { collectDesiredConstraintContributors, } from "./desired-state-graph.js";
 import { computeExtensionPathsForLayout, extensionPathSourceFromLockEntry, } from "./extension-paths.js";
+import { mcpResolutionKey } from "./mcp-source-identity.js";
 const MANIFEST_CONTRACTS = {
     skill: { filename: "skill.json", schema: SkillManifestSchema },
     "mcp-server": { filename: "mcp.json", schema: McpServerManifestSchema },
@@ -100,11 +101,13 @@ export const observeCanonicalExtension = ({ layout, desired, accepted, }) => Eff
             status: "missing-resolution",
         };
     }
-    const acceptedIdentity = accepted?.type === "registry"
-        ? `${accepted.owner}/${toExtensionTypePlural(desired.type)}/${accepted.name}`
-        : accepted === undefined
-            ? undefined
-            : printSourceParams(lockEntryToSourceParams(accepted));
+    const acceptedIdentity = accepted?.extensionType === "mcp-server"
+        ? mcpResolutionKey(accepted)
+        : accepted?.type === "registry"
+            ? `${accepted.owner}/${toExtensionTypePlural(desired.type)}/${accepted.name}`
+            : accepted === undefined
+                ? undefined
+                : printSourceParams(lockEntryToSourceParams(accepted));
     if (!workspaceAuthored &&
         !bundled &&
         acceptedIdentity !== desired.identity &&

package/dist/src/workspace/desired-state-graph.d.ts

@@ -7,12 +7,14 @@ import type { Settings } from "../settings/index.js";
 import { type WorkspaceLayout } from "./layout.js";
 export type DesiredExtensionOrigin = {
     readonly type: "settings";
+    readonly localName?: string;
     readonly authority?: "sourced";
     readonly source: string;
     readonly enabled: boolean;
     readonly constraint?: string;
 } | {
     readonly type: "settings";
+    readonly localName?: string;
     readonly authority: "inline";
     readonly source?: undefined;
     readonly constraint?: undefined;
@@ -52,6 +54,7 @@ export interface DesiredConstraintContributor {
     readonly range: string;
     readonly location: string;
     readonly dependingPack?: string;
+    readonly localName?: string;
 }
 export type DesiredStateProblem = {
     readonly type: "workspace-owner-missing";
@@ -98,8 +101,15 @@ export type DesiredStateProblem = {
 export interface DesiredStateGraph {
     readonly complete: boolean;
     readonly nodes: ReadonlyArray<DesiredExtensionNode>;
+    readonly mcpSourceClosures: ReadonlyArray<DesiredMcpSourceClosure>;
     readonly problems: ReadonlyArray<DesiredStateProblem>;
 }
+export interface DesiredMcpSourceClosure {
+    readonly identity: string;
+    readonly localNames: ReadonlyArray<string>;
+    readonly constraints: ReadonlyArray<string>;
+    readonly origins: ReadonlyArray<DesiredExtensionOrigin>;
+}
 export type ProspectivePackRef = Pick<PackRef, "owner" | "pack" | "version">;
 interface DesiredStateGraphArgs {
     readonly baseDir: string;
@@ -107,8 +117,10 @@ interface DesiredStateGraphArgs {
     readonly layout?: WorkspaceLayout;
     /** Resolved Pack roots whose manifests supersede the currently materialized copy. */
     readonly prospectivePacks?: ReadonlyArray<ProspectivePackRef>;
+    /** Registry source aliases mapped to their stable authority endpoints. */
+    readonly registryAuthorities?: Readonly<Record<string, URL | string>>;
 }
 export declare const collectDesiredConstraintContributors: (_path: Path.Path, origins: ReadonlyArray<DesiredExtensionOrigin>) => ReadonlyArray<DesiredConstraintContributor>;
-export declare const buildDesiredStateGraph: ({ baseDir, settings, layout, prospectivePacks, }: DesiredStateGraphArgs) => Effect.Effect<DesiredStateGraph, never, FileSystem.FileSystem | Path.Path>;
+export declare const buildDesiredStateGraph: ({ baseDir, settings, layout, prospectivePacks, registryAuthorities, }: DesiredStateGraphArgs) => Effect.Effect<DesiredStateGraph, never, FileSystem.FileSystem | Path.Path>;
 export {};
 //# sourceMappingURL=desired-state-graph.d.ts.map

package/dist/src/workspace/desired-state-graph.js

@@ -13,6 +13,7 @@ import { configuredAuthoredDirectory } from "./layout.js";
 import { SETTINGS_FILENAME } from "@agentxm/extension-model/unstable/workspace-files";
 import { ACQUIRED_EXTENSIONS_DIR } from "./constants.js";
 import { intersectVersionConstraints } from "@agentxm/extension-model/unstable/version-constraints";
+import { mcpRegistryResolutionKey } from "./mcp-source-identity.js";
 export const isInlineDesiredExtension = (node) => node.authority === "inline";
 export const isSourcedDesiredExtension = (node) => node.authority !== "inline";
 const nodeKey = (type, name) => `${type}:${name}`;
@@ -26,7 +27,17 @@ const registryLocator = (source) => {
     const ref = source.slice(separator + 1);
     return ref.startsWith("@") ? { sourceName: source.slice(0, separator), ref } : undefined;
 };
-const sourceIdentity = (type, name, source, settings) => {
+const withVersionConstraint = (source, constraint) => {
+    const locator = registryLocator(source);
+    if (locator === undefined)
+        return source;
+    const parsed = parseRegistrySourceRef(locator.ref);
+    if (parsed === undefined)
+        return source;
+    const prefix = source.startsWith("@") ? "" : `${locator.sourceName}:`;
+    return `${prefix}${parsed.owner}/${parsed.type}/${parsed.name}@${constraint}`;
+};
+const sourceIdentity = (type, name, source, settings, registryAuthorities) => {
     if (isWorkspaceSourceLocator(source)) {
         return settings.owner === undefined
             ? { identity: source }
@@ -35,8 +46,15 @@ const sourceIdentity = (type, name, source, settings) => {
     const locator = registryLocator(source);
     const parsed = locator === undefined ? undefined : parseRegistrySourceRef(locator.ref);
     if (parsed !== undefined && parsed.type === toExtensionTypePlural(type)) {
+        const registryAuthority = locator === undefined ? undefined : registryAuthorities[locator.sourceName];
         return {
-            identity: `${parsed.owner}/${parsed.type}/${parsed.name}`,
+            identity: type === "mcp-server" && registryAuthority !== undefined
+                ? mcpRegistryResolutionKey({
+                    authority: registryAuthority,
+                    owner: parsed.owner,
+                    name: parsed.name,
+                })
+                : `${parsed.owner}/${parsed.type}/${parsed.name}`,
             ...(parsed.versionRange === undefined ? {} : { constraint: parsed.versionRange }),
         };
     }
@@ -83,6 +101,7 @@ export const collectDesiredConstraintContributors = (_path, origins) => origins
                 source: "settings",
                 range: origin.constraint,
                 location: SETTINGS_FILENAME,
+                ...(origin.localName === undefined ? {} : { localName: origin.localName }),
             },
         ];
     }
@@ -113,7 +132,7 @@ const parsePackManifest = (raw) => {
     const decoded = Schema.decodeUnknownResult(PackManifestSchema)(parsed);
     return Result.isSuccess(decoded) ? decoded.success : undefined;
 };
-export const buildDesiredStateGraph = ({ baseDir, settings, layout, prospectivePacks = [], }) => Effect.gen(function* () {
+export const buildDesiredStateGraph = ({ baseDir, settings, layout, prospectivePacks = [], registryAuthorities = {}, }) => Effect.gen(function* () {
     const fs = yield* FileSystem.FileSystem;
     const path = yield* Path.Path;
     const candidates = [];
@@ -124,7 +143,7 @@ export const buildDesiredStateGraph = ({ baseDir, settings, layout, prospectiveP
             const bundled = type === "skill" && entry.origin === "bundled";
             const identity = bundled
                 ? { identity: `bundled:@agentxm/skills/${name}` }
-                : sourceIdentity(type, name, entry.source, settings);
+                : sourceIdentity(type, name, entry.source, settings, registryAuthorities);
             if (!bundled && isWorkspaceSourceLocator(entry.source) && settings.owner === undefined) {
                 problems.push({ type: "workspace-owner-missing", extensionType: type, name });
             }
@@ -138,6 +157,7 @@ export const buildDesiredStateGraph = ({ baseDir, settings, layout, prospectiveP
                 ...(identity.constraint === undefined ? {} : { constraint: identity.constraint }),
                 origin: {
                     type: "settings",
+                    localName: name,
                     authority: "sourced",
                     source: entry.source,
                     enabled: entry.enabled,
@@ -155,11 +175,16 @@ export const buildDesiredStateGraph = ({ baseDir, settings, layout, prospectiveP
                 identity: `@workspace/mcps/${name}`,
                 authority: "inline",
                 enabled: entry.enabled,
-                origin: { type: "settings", authority: "inline", enabled: entry.enabled },
+                origin: {
+                    type: "settings",
+                    localName: name,
+                    authority: "inline",
+                    enabled: entry.enabled,
+                },
             });
             continue;
         }
-        const identity = sourceIdentity("mcp-server", name, entry.source, settings);
+        const identity = sourceIdentity("mcp-server", name, entry.source, settings, registryAuthorities);
         if (isWorkspaceSourceLocator(entry.source) && settings.owner === undefined) {
             problems.push({ type: "workspace-owner-missing", extensionType: "mcp-server", name });
         }
@@ -173,6 +198,7 @@ export const buildDesiredStateGraph = ({ baseDir, settings, layout, prospectiveP
             ...(identity.constraint === undefined ? {} : { constraint: identity.constraint }),
             origin: {
                 type: "settings",
+                localName: name,
                 authority: "sourced",
                 source: entry.source,
                 enabled: entry.enabled,
@@ -207,6 +233,7 @@ export const buildDesiredStateGraph = ({ baseDir, settings, layout, prospectiveP
             ...(identity.constraint === undefined ? {} : { constraint: identity.constraint }),
             origin: {
                 type: "settings",
+                localName: identity.name,
                 authority: "sourced",
                 source: entry.source,
                 enabled: entry.enabled !== false,
@@ -267,10 +294,18 @@ export const buildDesiredStateGraph = ({ baseDir, settings, layout, prospectiveP
             const parsed = parseExtensionFqnParts(fqn);
             if (parsed === undefined || parsed.type === "pack")
                 continue;
+            const dependencyIdentity = parsed.type === "mcp-server" &&
+                registryAuthorities[configuredRegistrySource] !== undefined
+                ? mcpRegistryResolutionKey({
+                    authority: registryAuthorities[configuredRegistrySource],
+                    owner: parsed.owner,
+                    name: parsed.name,
+                })
+                : `${parsed.owner}/${toExtensionTypePlural(parsed.type)}/${parsed.name}`;
             candidates.push({
                 type: parsed.type,
                 name: parsed.name,
-                identity: `${parsed.owner}/${toExtensionTypePlural(parsed.type)}/${parsed.name}`,
+                identity: dependencyIdentity,
                 authority: "sourced",
                 source: `${fqn}@${constraint}`,
                 enabled: entry.enabled !== false,
@@ -344,7 +379,21 @@ export const buildDesiredStateGraph = ({ baseDir, settings, layout, prospectiveP
             origins,
         });
     }
+    const mcpClosuresByIdentity = new Map();
     for (const node of nodes.values()) {
+        if (node.type === "mcp-server" && isSourcedDesiredExtension(node)) {
+            const existing = mcpClosuresByIdentity.get(node.identity);
+            mcpClosuresByIdentity.set(node.identity, {
+                identity: node.identity,
+                localNames: [...(existing?.localNames ?? []), node.name].sort(),
+                constraints: [
+                    ...(existing?.constraints ?? []),
+                    ...node.constraints.filter((constraint) => !(existing?.constraints ?? []).includes(constraint)),
+                ],
+                origins: [...(existing?.origins ?? []), ...node.origins],
+            });
+            continue;
+        }
         if (intersectVersionConstraints(node.constraints) === undefined) {
             problems.push({
                 type: "constraint-conflict",
@@ -355,16 +404,36 @@ export const buildDesiredStateGraph = ({ baseDir, settings, layout, prospectiveP
             });
         }
     }
+    const mcpSourceClosures = [...mcpClosuresByIdentity.values()].sort((left, right) => left.identity.localeCompare(right.identity));
+    for (const closure of mcpSourceClosures) {
+        if (intersectVersionConstraints(closure.constraints) === undefined) {
+            problems.push({
+                type: "constraint-conflict",
+                extensionType: "mcp-server",
+                name: closure.localNames.join(", "),
+                constraints: closure.constraints,
+                contributors: collectDesiredConstraintContributors(path, closure.origins),
+            });
+        }
+    }
     const typeOrder = new Map(extensionTypes.map((type, index) => [type, index]));
     const orderedNodes = [...nodes.values()]
         .map((node) => {
         if (isInlineDesiredExtension(node))
             return node;
-        const constraint = intersectVersionConstraints(node.constraints);
+        const constraints = node.type === "mcp-server"
+            ? (mcpClosuresByIdentity.get(node.identity)?.constraints ?? node.constraints)
+            : node.constraints;
+        const constraint = intersectVersionConstraints(constraints);
         return {
             ...node,
-            source: node.identity.startsWith("@") && node.constraints.length > 0 && constraint !== undefined
-                ? `${node.identity}@${constraint}`
+            constraints,
+            source: constraints.length > 0 && constraint !== undefined
+                ? node.type === "mcp-server"
+                    ? withVersionConstraint(node.source, constraint)
+                    : node.identity.startsWith("@")
+                        ? `${node.identity}@${constraint}`
+                        : node.source
                 : node.source,
         };
     })
@@ -378,6 +447,7 @@ export const buildDesiredStateGraph = ({ baseDir, settings, layout, prospectiveP
     return {
         complete: problems.length === 0,
         nodes: orderedNodes,
+        mcpSourceClosures,
         problems,
     };
 });

package/dist/src/workspace/mcp-source-identity.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Canonical identity for one accepted MCP source-resolution closure.
+ *
+ * Connection names deliberately do not participate: several local MCP
+ * connections may share this identity and therefore one accepted resolution.
+ */
+import type { Handle } from "@agentxm/extension-model/unstable/extensions/handle";
+import type { ExtensionName } from "@agentxm/extension-model/unstable/extensions/common";
+import type { McpServerLockEntry } from "../lockfile/schema.js";
+export declare const mcpRegistryResolutionKey: (args: {
+    readonly authority: URL | string;
+    readonly owner: Handle | string;
+    readonly name: ExtensionName | string;
+}) => string;
+/** Deterministic lock-map key for every currently accepted MCP source class. */
+export declare const mcpResolutionKey: (entry: McpServerLockEntry) => string;
+//# sourceMappingURL=mcp-source-identity.d.ts.map

package/dist/src/workspace/mcp-source-identity.js

@@ -0,0 +1,40 @@
+/**
+ * Canonical identity for one accepted MCP source-resolution closure.
+ *
+ * Connection names deliberately do not participate: several local MCP
+ * connections may share this identity and therefore one accepted resolution.
+ */
+const normalizeAuthority = (authority) => {
+    const raw = authority instanceof URL ? authority.href : authority;
+    try {
+        const normalized = new URL(raw).href;
+        return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+    }
+    catch {
+        return raw.endsWith("/") ? raw.slice(0, -1) : raw;
+    }
+};
+const encodeIdentityPart = (value) => encodeURIComponent(value);
+export const mcpRegistryResolutionKey = (args) => `registry:${encodeIdentityPart(normalizeAuthority(args.authority))}:${args.owner}/mcps/${args.name}`;
+/** Deterministic lock-map key for every currently accepted MCP source class. */
+export const mcpResolutionKey = (entry) => {
+    switch (entry.type) {
+        case "registry":
+            return mcpRegistryResolutionKey({
+                authority: entry.endpoint,
+                owner: entry.owner,
+                name: entry.name,
+            });
+        case "github":
+        case "gitlab":
+        case "bitbucket":
+            return `${entry.type}:${encodeIdentityPart(normalizeAuthority(entry.endpoint))}:${entry.owner}/${entry.repo}:${entry.packageOwner ?? ""}/mcps/${entry.packageName}`;
+        case "azurerepos":
+            return `azurerepos:${encodeIdentityPart(normalizeAuthority(entry.endpoint))}:${entry.organization}/${entry.project}/${entry.repo}:${entry.packageOwner ?? ""}/mcps/${entry.packageName}`;
+        case "git":
+            return `git:${encodeIdentityPart(normalizeAuthority(entry.url))}:${entry.packageOwner ?? ""}/mcps/${entry.packageName}`;
+        case "local":
+            return `local:${encodeIdentityPart(entry.path)}:${entry.packageOwner ?? ""}/mcps/${entry.packageName}`;
+    }
+};
+//# sourceMappingURL=mcp-source-identity.js.map

package/dist/src/workspace/read-model/__fixtures__/builder.js

@@ -362,7 +362,7 @@ const validSettingsContents = {
     skills: { "managed-tool": { source: "github:owner/repo", enabled: true } },
 };
 const validLockfileContents = {
-    lockfileVersion: 6,
+    lockfileVersion: 7,
     skills: {
         "managed-tool": {
             type: "github",

package/dist/src/workspace/read-model/errors.d.ts

@@ -59,8 +59,18 @@ export declare class LockfileDecodeError extends LockfileDecodeError_base<{
     readonly raw: unknown;
 }> {
 }
-/** Lockfile-read failure union (IO, parse, decode). */
-export type LockfileReadError = LockfileIoError | LockfileParseError | LockfileDecodeError;
+declare const LockfileVersionUnsupported_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "LockfileVersionUnsupported";
+} & Readonly<A>;
+/** A syntactically valid lockfile declares a version this CLI cannot read. */
+export declare class LockfileVersionUnsupported extends LockfileVersionUnsupported_base<{
+    readonly path: string;
+    readonly observedVersion: number;
+    readonly supportedVersion: number;
+}> {
+}
+/** Lockfile-read failure union (IO, parse, decode, unsupported version). */
+export type LockfileReadError = LockfileIoError | LockfileParseError | LockfileDecodeError | LockfileVersionUnsupported;
 declare const WorkspaceRootEscape_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
     readonly _tag: "WorkspaceRootEscape";
 } & Readonly<A>;

package/dist/src/workspace/read-model/errors.js

@@ -18,6 +18,9 @@ export class LockfileParseError extends Data.TaggedError("LockfileParseError") {
 /** Lockfile schema decode failure; `raw` carries the parsed value. */
 export class LockfileDecodeError extends Data.TaggedError("LockfileDecodeError") {
 }
+/** A syntactically valid lockfile declares a version this CLI cannot read. */
+export class LockfileVersionUnsupported extends Data.TaggedError("LockfileVersionUnsupported") {
+}
 /** Provider-construction error: workspace root escapes the configured allowed root. */
 export class WorkspaceRootEscape extends Data.TaggedError("WorkspaceRootEscape") {
 }

package/dist/src/workspace/read-model/extensions/mcp-server.js

@@ -10,6 +10,7 @@
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { decodeExtensionNameSync, } from "@agentxm/extension-model/unstable/extensions/common";
+import { parseSourceQualifiedRegistrySourcePatternParts } from "@agentxm/extension-model/unstable/extensions";
 import { filterMapOccurrences } from "./actual-helpers.js";
 import { canonicalAxmPackageRoot } from "./package-root.js";
 import { makeProjectedSubjectCells, projectInstalledExtensions, } from "./projection.js";
@@ -24,18 +25,39 @@ const declaredFromSettings = (settings) => {
         entry,
     }));
 };
-const resolvedFromLockfile = (lockfile) => {
-    if (lockfile.mcpServers === undefined)
-        return [];
-    return Object.entries(lockfile.mcpServers).map(([name, lockEntry]) => ({
-        name: decodeExtensionNameSync(name),
-        lockEntry,
-    }));
+const resolvedFromState = (settings, lockfile, packs) => {
+    const locked = Object.values(lockfile.mcpServers ?? {});
+    const resolved = [];
+    const names = new Set();
+    for (const [localName, entry] of Object.entries(settings.mcpServers ?? {})) {
+        if (entry.kind === "inline")
+            continue;
+        const parsed = parseSourceQualifiedRegistrySourcePatternParts(entry.source);
+        const lockEntry = locked.find((candidate) => parsed !== undefined && candidate.type === "registry"
+            ? candidate.sourceName === parsed.sourceName &&
+                candidate.owner === parsed.owner &&
+                candidate.name === parsed.name
+            : candidate.workspaceName === localName);
+        if (lockEntry === undefined)
+            continue;
+        names.add(localName);
+        resolved.push({ name: decodeExtensionNameSync(localName), lockEntry });
+    }
+    for (const member of packs.flatMap((pack) => pack.mcpServers)) {
+        if (names.has(member.name))
+            continue;
+        const lockEntry = locked.find((candidate) => candidate.workspaceName === member.name);
+        if (lockEntry === undefined)
+            continue;
+        names.add(member.name);
+        resolved.push({ name: member.name, lockEntry });
+    }
+    return resolved;
 };
-const canonicalToActual = (occ, scope) => {
+const canonicalToActual = (occ, scope, localName = occ.name) => {
     const packageRoot = canonicalAxmPackageRoot(occ);
     return {
-        key: { scope, type: "mcp-server", name: occ.name },
+        key: { scope, type: "mcp-server", name: localName },
         origin: occ.origin === "canonical-axm"
             ? { _tag: "canonical-axm-mcp-server" }
             : { _tag: "external-axm-mcp-server" },
@@ -94,11 +116,24 @@ const mcpServerPolicy = (scope) => ({
 export const makeMcpServerExtensionsApi = (deps) => Effect.gen(function* () {
     const { scope, loaders, scanners, installedPacks, diagnostics } = deps;
     const declared = loaders.settings.pipe(Effect.map((opt) => Option.map(opt, declaredFromSettings)));
-    const resolved = loaders.lockfile.pipe(Effect.map((opt) => Option.map(opt, resolvedFromLockfile)));
+    const resolved = Effect.all({
+        settings: loaders.settings.pipe(Effect.catch(() => Effect.succeed(Option.none()))),
+        lockfile: loaders.lockfile,
+        packs: installedPacks.pipe(Effect.catch(() => Effect.succeed([]))),
+    }).pipe(Effect.map(({ settings, lockfile, packs }) => Option.all({ settings, lockfile }).pipe(Option.map(({ settings: decodedSettings, lockfile: decodedLockfile }) => resolvedFromState(decodedSettings, decodedLockfile, packs)))));
     const actual = Effect.gen(function* () {
         const canonical = yield* scanners.canonical;
         const mcpConfig = yield* scanners.mcpConfig;
-        const fromCanonical = filterMapOccurrences(canonical, "mcp-server", (occ) => canonicalToActual(occ, scope));
+        const accepted = yield* resolved.pipe(Effect.catch(() => Effect.succeed(Option.none())));
+        const resolvedEntries = Option.getOrElse(accepted, () => []);
+        const fromCanonical = filterMapOccurrences(canonical, "mcp-server", (occ) => occ).flatMap((occ) => {
+            const matchingNames = resolvedEntries
+                .filter((entry) => entry.lockEntry.type === "registry" && entry.lockEntry.name === occ.name)
+                .map((entry) => entry.name);
+            return matchingNames.length === 0
+                ? [canonicalToActual(occ, scope)]
+                : matchingNames.map((name) => canonicalToActual(occ, scope, name));
+        });
         const fromMcpConfig = mcpConfig.map((occ) => mcpConfigToActual(occ, scope));
         return [...fromCanonical, ...fromMcpConfig];
     });

package/dist/src/workspace/read-model/state.js

@@ -3,10 +3,10 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
 import YAML from "yaml";
-import { LockfileSchema } from "../../lockfile/schema.js";
+import { LOCKFILE_VERSION, LockfileSchema } from "../../lockfile/schema.js";
 import { formatSchemaIssuesToLines } from "@agentxm/extension-model/unstable/schema-issues";
 import { SettingsSchema } from "../../settings/schema.js";
-import { LockfileDecodeError, LockfileIoError, LockfileParseError, SettingsDecodeError, SettingsIoError, SettingsParseError, } from "./errors.js";
+import { LockfileDecodeError, LockfileIoError, LockfileParseError, LockfileVersionUnsupported, SettingsDecodeError, SettingsIoError, SettingsParseError, } from "./errors.js";
 // ---------------------------------------------------------------------------
 // Raw bytes loaders (shared by the decoded loaders and the public raw cells)
 // ---------------------------------------------------------------------------
@@ -71,6 +71,22 @@ const loadLockfile = (rawCell) => Effect.gen(function* () {
         try: () => YAML.parse(bytes),
         catch: (cause) => new LockfileParseError({ path, raw: bytes, cause }),
     });
+    if (typeof parsed === "object" &&
+        parsed !== null &&
+        !Array.isArray(parsed) &&
+        Object.hasOwn(parsed, "lockfileVersion")) {
+        const observedVersion = Reflect.get(parsed, "lockfileVersion");
+        if (typeof observedVersion === "number" &&
+            Number.isSafeInteger(observedVersion) &&
+            observedVersion > 0 &&
+            observedVersion !== LOCKFILE_VERSION) {
+            return yield* Effect.fail(new LockfileVersionUnsupported({
+                path,
+                observedVersion,
+                supportedVersion: LOCKFILE_VERSION,
+            }));
+        }
+    }
     const decoded = yield* Schema.decodeUnknownEffect(LockfileSchema)(parsed).pipe(Effect.mapError((error) => new LockfileDecodeError({
         path,
         issues: formatSchemaIssuesToLines(error.issue),

package/dist/src/workspace/read-model/types.d.ts

@@ -63,7 +63,7 @@ export interface InstalledPackRef {
  *
  * The failure channels are intentionally narrow: `declared` only fails with
  * `SettingsReadError` (3 tags), `resolved` only fails with
- * `LockfileReadError` (3 tags), and `actual` never fails — workspace-root
+ * `LockfileReadError` (4 tags), and `actual` never fails — workspace-root
  * path-escape is validated once at provider construction (Layer-level), not
  * per cell.
  */

package/dist/src/workspace/service-interface.d.ts

@@ -212,6 +212,8 @@ export interface SetSubagentArgs {
  */
 export interface SetMcpServerArgs {
     readonly name: string;
+    /** Canonical source-resolution key. Unlike name, this is not connection-scoped. */
+    readonly resolutionKey: string;
     readonly lockEntry: McpServerLockEntry;
     readonly versionRange: Option.Option<string>;
     readonly env?: Readonly<Record<string, string>>;
@@ -408,8 +410,10 @@ export interface WorkspaceMutationsService {
     readonly removeSubagentLock: (name: string) => Effect.Effect<void, WorkspaceLockfileMutationFailure>;
     /** Read lockfile and return the MCP servers lock map. */
     readonly getLockedMcpServers: () => Effect.Effect<McpServersLockMap, WorkspaceLockfileReadFailure>;
-    /** Read lockfile and return the entry for a specific MCP server, or Option.none(). */
-    readonly getLockedMcpServer: (name: string) => Effect.Effect<Option.Option<McpServerLockEntry>, WorkspaceLockfileReadFailure>;
+    /** Read lockfile and return an MCP accepted resolution by source-resolution identity. */
+    readonly getLockedMcpServer: (resolutionKey: string) => Effect.Effect<Option.Option<McpServerLockEntry>, WorkspaceLockfileReadFailure>;
+    /** Resolve a local MCP connection name to its shared accepted resolution. */
+    readonly getLockedMcpServerForConnection: (localName: string) => Effect.Effect<Option.Option<McpServerLockEntry>, WorkspaceStateReadFailure>;
     /** Update desired MCP settings and any external accepted resolution atomically. */
     readonly setMcpServer: (args: SetMcpServerArgs) => Effect.Effect<void, WorkspaceStateMutationFailure>;
     /** Add or update an MCP server in lockfile only (skip settings). Used for pack dependencies. Serialized by semaphore. */
@@ -469,11 +473,11 @@ export interface WorkspaceMutationsOptions {
     readonly allowUninitialized?: boolean;
 }
 /**
- * Error loading workspace mutations: scoped settings reads, layout
- * resolution, and the initialization gate.
+ * Error loading workspace mutations: scoped settings and lockfile reads,
+ * layout resolution, and the initialization gate.
  *
  * @experimental This API is unstable and may change without notice.
  */
-export type WorkspaceMutationsError = WorkspaceSettingsReadFailure | WorkspaceLayoutError | WorkspaceNotInitialized;
+export type WorkspaceMutationsError = WorkspaceSettingsReadFailure | WorkspaceLockfileReadFailure | WorkspaceLayoutError | WorkspaceNotInitialized;
 export {};
 //# sourceMappingURL=service-interface.d.ts.map

package/dist/src/workspace/service.d.ts

@@ -22,6 +22,7 @@ import * as Path from "effect/Path";
 import * as Option from "effect/Option";
 import type { Handle } from "@agentxm/extension-model/unstable/extensions/handle";
 import { DesiredPackGraphIncomplete, InvalidAgentId, LockedSkillMissing, SettingsEntryMissing, WorkspaceNotInitialized } from "./errors.js";
+import { LockfileVersionUnsupported } from "./read-model/errors.js";
 import { LockfileValidationError } from "../lockfile/errors.js";
 import { type HookEntry, type KnowledgeEntry, type InstructionsConfigValue, type McpServerEntry, type SkillEntry, type SubagentEntry, type PackEntry, type RuleEntry, type SourceHostConfig } from "../settings/index.js";
 import { type ScopedReleaseAgeExcludePattern } from "@agentxm/extension-model/unstable/extensions/release-age";
@@ -36,8 +37,9 @@ export type WorkspaceLayerOptions = WorkspaceMutationsOptions;
 /**
  * Create the workspace mutations service from an existing workspace on disk.
  *
- * The workspace must already be initialized. Missing or invalid settings fail
- * fast with a typed `WorkspaceMutationsError`. The two operations-side
+ * The workspace must already be initialized. Missing or invalid settings and
+ * invalid or unsupported lockfiles fail fast with a typed
+ * `WorkspaceMutationsError`. The two operations-side
  * capabilities — the transaction runner and transition acquirer — are
  * injected through `makeCapabilities`; the composition seam in
  * `./operations/load-workspace.ts` supplies the live implementation.
@@ -52,7 +54,7 @@ export declare const makeWorkspaceMutations: (options: WorkspaceLayerOptions, ma
     getLockfileState: () => Effect.Effect<LockfileState, LockfileValidationError | WorkspaceRootEscape>;
     getDesiredStateGraph: (graphOptions?: Parameters<(graphOptions?: {
         readonly prospectivePacks?: Parameters<typeof buildDesiredStateGraph>[0]["prospectivePacks"];
-    }) => Effect.Effect<import("./desired-state-graph.js").DesiredStateGraph, SettingsReadError | LockfileReadError | WorkspaceRootEscape, never>>[0]) => Effect.Effect<import("./desired-state-graph.js").DesiredStateGraph, SettingsReadError | LockfileReadError | WorkspaceRootEscape, never>;
+    }) => Effect.Effect<import("./desired-state-graph.js").DesiredStateGraph, import("./read-model/errors.js").SettingsIoError | import("./read-model/errors.js").SettingsParseError | import("./read-model/errors.js").SettingsDecodeError | import("./read-model/errors.js").LockfileIoError | import("./read-model/errors.js").LockfileParseError | import("./read-model/errors.js").LockfileDecodeError | LockfileVersionUnsupported | WorkspaceRootEscape, never>>[0]) => Effect.Effect<import("./desired-state-graph.js").DesiredStateGraph, import("./read-model/errors.js").SettingsIoError | import("./read-model/errors.js").SettingsParseError | import("./read-model/errors.js").SettingsDecodeError | import("./read-model/errors.js").LockfileIoError | import("./read-model/errors.js").LockfileParseError | import("./read-model/errors.js").LockfileDecodeError | LockfileVersionUnsupported | WorkspaceRootEscape, never>;
     getConfiguredSources: () => Effect.Effect<ReadonlyArray<SourceHostConfig>, WorkspaceSettingsReadFailure>;
     getConfiguredSourceByName: (name: string) => Effect.Effect<Option.Option<{
         readonly name: string;
@@ -1534,7 +1536,7 @@ export declare const makeWorkspaceMutations: (options: WorkspaceLayerOptions, ma
             readonly treeIntegrity: string & import("effect/Brand").Brand<"TreeIntegrity">;
         };
     }, LockfileReadError | WorkspaceRootEscape, never>;
-    getLockedMcpServer: (name: string) => Effect.Effect<Option.Option<{
+    getLockedMcpServer: (resolutionKey: string) => Effect.Effect<Option.Option<{
         readonly type: "github";
         readonly owner: string;
         readonly sourceType: "github";
@@ -1650,8 +1652,239 @@ export declare const makeWorkspaceMutations: (options: WorkspaceLayerOptions, ma
         readonly publisherBindingId: string;
         readonly treeIntegrity: string & import("effect/Brand").Brand<"TreeIntegrity">;
     }>, LockfileReadError | WorkspaceRootEscape, never>;
-    setMcpServer: ({ name, lockEntry, versionRange, env, enabled, agents }: SetMcpServerArgs) => Effect.Effect<void, import("../settings/errors.ts").SettingsWriteError | import("./transaction.ts").WorkspaceSnapshotError | import("../lockfile/errors.js").LockfileWriteError | LockfileValidationError | SettingsReadError | LockfileReadError | WorkspaceRootEscape, never>;
-    setMcpServerLock: ({ name, lockEntry }: SetMcpServerArgs) => Effect.Effect<void, import("../lockfile/errors.js").LockfileWriteError | LockfileValidationError | LockfileReadError | WorkspaceRootEscape, never>;
+    getLockedMcpServerForConnection: (localName: string) => Effect.Effect<Option.None<{
+        readonly type: "github";
+        readonly owner: string;
+        readonly sourceType: "github";
+        readonly extensionType: "mcp-server";
+        readonly sourceName: string;
+        readonly packageFormat: "agentxm";
+        readonly endpoint: URL;
+        readonly workspaceName: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly packageOwner: string & import("effect/Brand").Brand<"Handle">;
+        readonly packageName: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly repo: string;
+        readonly resolvedCommit: string;
+        readonly resolvedTree: string;
+        readonly contentIdentity: string & import("effect/Brand").Brand<"SourceHash">;
+        readonly treeIntegrity: string & import("effect/Brand").Brand<"TreeIntegrity">;
+        readonly path?: string | undefined;
+        readonly ref?: string | undefined;
+    } | {
+        readonly type: "gitlab";
+        readonly owner: string;
+        readonly sourceType: "gitlab";
+        readonly extensionType: "mcp-server";
+        readonly sourceName: string;
+        readonly packageFormat: "agentxm";
+        readonly endpoint: URL;
+        readonly workspaceName: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly packageOwner: string & import("effect/Brand").Brand<"Handle">;
+        readonly packageName: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly repo: string;
+        readonly resolvedCommit: string;
+        readonly resolvedTree: string;
+        readonly contentIdentity: string & import("effect/Brand").Brand<"SourceHash">;
+        readonly treeIntegrity: string & import("effect/Brand").Brand<"TreeIntegrity">;
+        readonly path?: string | undefined;
+        readonly ref?: string | undefined;
+    } | {
+        readonly type: "bitbucket";
+        readonly owner: string;
+        readonly sourceType: "bitbucket";
+        readonly extensionType: "mcp-server";
+        readonly sourceName: string;
+        readonly packageFormat: "agentxm";
+        readonly endpoint: URL;
+        readonly workspaceName: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly packageOwner: string & import("effect/Brand").Brand<"Handle">;
+        readonly packageName: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly repo: string;
+        readonly resolvedCommit: string;
+        readonly resolvedTree: string;
+        readonly contentIdentity: string & import("effect/Brand").Brand<"SourceHash">;
+        readonly treeIntegrity: string & import("effect/Brand").Brand<"TreeIntegrity">;
+        readonly path?: string | undefined;
+        readonly ref?: string | undefined;
+    } | {
+        readonly type: "azurerepos";
+        readonly sourceType: "azurerepos";
+        readonly extensionType: "mcp-server";
+        readonly sourceName: string;
+        readonly packageFormat: "agentxm";
+        readonly endpoint: URL;
+        readonly workspaceName: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly packageOwner: string & import("effect/Brand").Brand<"Handle">;
+        readonly packageName: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly repo: string;
+        readonly resolvedCommit: string;
+        readonly resolvedTree: string;
+        readonly contentIdentity: string & import("effect/Brand").Brand<"SourceHash">;
+        readonly treeIntegrity: string & import("effect/Brand").Brand<"TreeIntegrity">;
+        readonly organization: string;
+        readonly project: string;
+        readonly path?: string | undefined;
+        readonly ref?: string | undefined;
+    } | {
+        readonly type: "git";
+        readonly url: string;
+        readonly sourceType: "git";
+        readonly extensionType: "mcp-server";
+        readonly sourceName: "git";
+        readonly packageFormat: "agentxm";
+        readonly workspaceName: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly packageOwner: string & import("effect/Brand").Brand<"Handle">;
+        readonly packageName: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly resolvedCommit: string;
+        readonly resolvedTree: string;
+        readonly contentIdentity: string & import("effect/Brand").Brand<"SourceHash">;
+        readonly treeIntegrity: string & import("effect/Brand").Brand<"TreeIntegrity">;
+        readonly path?: string | undefined;
+        readonly ref?: string | undefined;
+    } | {
+        readonly type: "local";
+        readonly sourceType: "local";
+        readonly sourceName: "local";
+        readonly extensionType: "mcp-server";
+        readonly workspaceName: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly packageFormat: "agentxm";
+        readonly packageOwner: string & import("effect/Brand").Brand<"Handle">;
+        readonly packageName: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly path: string;
+        readonly contentIdentity: string & import("effect/Brand").Brand<"SourceHash">;
+        readonly treeIntegrity: string & import("effect/Brand").Brand<"TreeIntegrity">;
+    } | {
+        readonly type: "registry";
+        readonly sourceType: "registry";
+        readonly endpoint: URL;
+        readonly extensionType: "mcp-server";
+        readonly workspaceName: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly packageFormat: "agentxm";
+        readonly owner: string & import("effect/Brand").Brand<"Handle">;
+        readonly name: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly resolvedVersion: string & import("effect/Brand").Brand<"Version">;
+        readonly integrity: string;
+        readonly sourceName: string;
+        readonly publisherBindingId: string;
+        readonly treeIntegrity: string & import("effect/Brand").Brand<"TreeIntegrity">;
+    }> | Option.Some<{
+        readonly type: "github";
+        readonly owner: string;
+        readonly sourceType: "github";
+        readonly extensionType: "mcp-server";
+        readonly sourceName: string;
+        readonly packageFormat: "agentxm";
+        readonly endpoint: URL;
+        readonly workspaceName: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly packageOwner: string & import("effect/Brand").Brand<"Handle">;
+        readonly packageName: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly repo: string;
+        readonly resolvedCommit: string;
+        readonly resolvedTree: string;
+        readonly contentIdentity: string & import("effect/Brand").Brand<"SourceHash">;
+        readonly treeIntegrity: string & import("effect/Brand").Brand<"TreeIntegrity">;
+        readonly path?: string | undefined;
+        readonly ref?: string | undefined;
+    } | {
+        readonly type: "gitlab";
+        readonly owner: string;
+        readonly sourceType: "gitlab";
+        readonly extensionType: "mcp-server";
+        readonly sourceName: string;
+        readonly packageFormat: "agentxm";
+        readonly endpoint: URL;
+        readonly workspaceName: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly packageOwner: string & import("effect/Brand").Brand<"Handle">;
+        readonly packageName: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly repo: string;
+        readonly resolvedCommit: string;
+        readonly resolvedTree: string;
+        readonly contentIdentity: string & import("effect/Brand").Brand<"SourceHash">;
+        readonly treeIntegrity: string & import("effect/Brand").Brand<"TreeIntegrity">;
+        readonly path?: string | undefined;
+        readonly ref?: string | undefined;
+    } | {
+        readonly type: "bitbucket";
+        readonly owner: string;
+        readonly sourceType: "bitbucket";
+        readonly extensionType: "mcp-server";
+        readonly sourceName: string;
+        readonly packageFormat: "agentxm";
+        readonly endpoint: URL;
+        readonly workspaceName: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly packageOwner: string & import("effect/Brand").Brand<"Handle">;
+        readonly packageName: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly repo: string;
+        readonly resolvedCommit: string;
+        readonly resolvedTree: string;
+        readonly contentIdentity: string & import("effect/Brand").Brand<"SourceHash">;
+        readonly treeIntegrity: string & import("effect/Brand").Brand<"TreeIntegrity">;
+        readonly path?: string | undefined;
+        readonly ref?: string | undefined;
+    } | {
+        readonly type: "azurerepos";
+        readonly sourceType: "azurerepos";
+        readonly extensionType: "mcp-server";
+        readonly sourceName: string;
+        readonly packageFormat: "agentxm";
+        readonly endpoint: URL;
+        readonly workspaceName: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly packageOwner: string & import("effect/Brand").Brand<"Handle">;
+        readonly packageName: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly repo: string;
+        readonly resolvedCommit: string;
+        readonly resolvedTree: string;
+        readonly contentIdentity: string & import("effect/Brand").Brand<"SourceHash">;
+        readonly treeIntegrity: string & import("effect/Brand").Brand<"TreeIntegrity">;
+        readonly organization: string;
+        readonly project: string;
+        readonly path?: string | undefined;
+        readonly ref?: string | undefined;
+    } | {
+        readonly type: "git";
+        readonly url: string;
+        readonly sourceType: "git";
+        readonly extensionType: "mcp-server";
+        readonly sourceName: "git";
+        readonly packageFormat: "agentxm";
+        readonly workspaceName: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly packageOwner: string & import("effect/Brand").Brand<"Handle">;
+        readonly packageName: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly resolvedCommit: string;
+        readonly resolvedTree: string;
+        readonly contentIdentity: string & import("effect/Brand").Brand<"SourceHash">;
+        readonly treeIntegrity: string & import("effect/Brand").Brand<"TreeIntegrity">;
+        readonly path?: string | undefined;
+        readonly ref?: string | undefined;
+    } | {
+        readonly type: "local";
+        readonly sourceType: "local";
+        readonly sourceName: "local";
+        readonly extensionType: "mcp-server";
+        readonly workspaceName: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly packageFormat: "agentxm";
+        readonly packageOwner: string & import("effect/Brand").Brand<"Handle">;
+        readonly packageName: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly path: string;
+        readonly contentIdentity: string & import("effect/Brand").Brand<"SourceHash">;
+        readonly treeIntegrity: string & import("effect/Brand").Brand<"TreeIntegrity">;
+    } | {
+        readonly type: "registry";
+        readonly sourceType: "registry";
+        readonly endpoint: URL;
+        readonly extensionType: "mcp-server";
+        readonly workspaceName: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly packageFormat: "agentxm";
+        readonly owner: string & import("effect/Brand").Brand<"Handle">;
+        readonly name: string & import("effect/Brand").Brand<"ExtensionName">;
+        readonly resolvedVersion: string & import("effect/Brand").Brand<"Version">;
+        readonly integrity: string;
+        readonly sourceName: string;
+        readonly publisherBindingId: string;
+        readonly treeIntegrity: string & import("effect/Brand").Brand<"TreeIntegrity">;
+    }>, import("./read-model/errors.js").SettingsIoError | import("./read-model/errors.js").SettingsParseError | import("./read-model/errors.js").SettingsDecodeError | LockfileReadError | WorkspaceRootEscape, never>;
+    setMcpServer: ({ name, resolutionKey, lockEntry, versionRange, env, enabled, agents, }: SetMcpServerArgs) => Effect.Effect<void, import("../settings/errors.ts").SettingsWriteError | import("./transaction.ts").WorkspaceSnapshotError | import("../lockfile/errors.js").LockfileWriteError | LockfileValidationError | SettingsReadError | LockfileReadError | WorkspaceRootEscape, never>;
+    setMcpServerLock: ({ name: _name, resolutionKey, lockEntry }: SetMcpServerArgs) => Effect.Effect<void, import("../lockfile/errors.js").LockfileWriteError | LockfileValidationError | LockfileReadError | WorkspaceRootEscape, never>;
     updateMcpServerEntry: (name: string, updater: (entry: McpServerEntry) => McpServerEntry) => Effect.Effect<void, import("../settings/errors.ts").SettingsWriteError | import("./transaction.ts").WorkspaceSnapshotError | SettingsEntryMissing | SettingsReadError | WorkspaceRootEscape, never>;
     setMcpServerEntry: (name: string, entry: McpServerEntry) => Effect.Effect<void, import("../settings/errors.ts").SettingsWriteError | import("./transaction.ts").WorkspaceSnapshotError | SettingsReadError | WorkspaceRootEscape, never>;
     removeMcpServer: (name: string) => Effect.Effect<void, import("../settings/errors.ts").SettingsWriteError | import("./transaction.ts").WorkspaceSnapshotError | import("../lockfile/errors.js").LockfileWriteError | LockfileValidationError | SettingsReadError | LockfileReadError | WorkspaceRootEscape, never>;
@@ -1660,6 +1893,6 @@ export declare const makeWorkspaceMutations: (options: WorkspaceLayerOptions, ma
     removeMcpServerLock: (name: string) => Effect.Effect<void, import("../lockfile/errors.js").LockfileWriteError | LockfileValidationError | LockfileReadError | WorkspaceRootEscape, never>;
     removePackSettings: (name: string) => Effect.Effect<void, import("../settings/errors.ts").SettingsWriteError | import("./transaction.ts").WorkspaceSnapshotError | SettingsReadError | WorkspaceRootEscape, never>;
     removePackLock: (name: string) => Effect.Effect<void, import("../lockfile/errors.js").LockfileWriteError | LockfileValidationError | LockfileReadError | WorkspaceRootEscape, never>;
-    isExtensionRequiredByInstalledPack: (target: ExtensionTarget) => Effect.Effect<boolean, DesiredPackGraphIncomplete | SettingsReadError | LockfileReadError | WorkspaceRootEscape, never>;
-}, import("./errors.js").WorkspaceLayoutError | WorkspaceNotInitialized | WorkspaceSettingsReadFailure, FileSystem.FileSystem | Path.Path>;
+    isExtensionRequiredByInstalledPack: (target: ExtensionTarget) => Effect.Effect<boolean, DesiredPackGraphIncomplete | import("./read-model/errors.js").SettingsIoError | import("./read-model/errors.js").SettingsParseError | import("./read-model/errors.js").SettingsDecodeError | import("./read-model/errors.js").LockfileIoError | import("./read-model/errors.js").LockfileParseError | import("./read-model/errors.js").LockfileDecodeError | LockfileVersionUnsupported | WorkspaceRootEscape, never>;
+}, import("./errors.js").WorkspaceLayoutError | WorkspaceNotInitialized | LockfileReadError | WorkspaceSettingsReadFailure, FileSystem.FileSystem | Path.Path>;
 //# sourceMappingURL=service.d.ts.map

package/dist/src/workspace/service.js

@@ -28,6 +28,7 @@ import { computePackPathsForLayout } from "./pack-paths.js";
 import { sanitizeName } from "./extension-name.js";
 import { ConfigurableAgentIdSchema, decodeExtensionNameSync, formatFqn, parseSourceQualifiedRegistrySourcePatternParts, } from "@agentxm/extension-model/unstable/extensions";
 import { DesiredPackGraphIncomplete, InvalidAgentId, LockedSkillMissing, SettingsEntryMissing, WorkspaceNotInitialized, } from "./errors.js";
+import { LockfileVersionUnsupported } from "./read-model/errors.js";
 import { LockfileValidationError } from "../lockfile/errors.js";
 import { createDefaultSettings, writeSettingsAtPath, } from "../settings/index.js";
 import { DEFAULT_MINIMUM_RELEASE_AGE } from "@agentxm/registry-protocol/unstable/registry/release-age-policy";
@@ -71,15 +72,22 @@ const lockEntrySemanticallyEqual = (current, next) => current !== undefined && s
 const skillLockEntrySemanticallyEqual = (current, next) => lockEntrySemanticallyEqual(current, next);
 const preserveAcceptedResolutionOnNoop = (current, next) => (lockEntrySemanticallyEqual(current, next) && current !== undefined ? current : next);
 const subagentLockEntrySemanticallyEqual = (current, next) => lockEntrySemanticallyEqual(current, next);
-const requireInitializedWorkspace = (settingsPath, settings) => settings.pipe(Effect.flatMap(Option.match({
-    onNone: () => Effect.fail(new WorkspaceNotInitialized({ settingsPath })),
+const requireInitializedWorkspace = (settingsPath, settings, lockfile) => settings.pipe(Effect.flatMap(Option.match({
+    onNone: () => lockfile.pipe(Effect.matchEffect({
+        onFailure: (error) => error instanceof LockfileVersionUnsupported &&
+            error.observedVersion > error.supportedVersion
+            ? Effect.fail(error)
+            : Effect.fail(new WorkspaceNotInitialized({ settingsPath })),
+        onSuccess: () => Effect.fail(new WorkspaceNotInitialized({ settingsPath })),
+    })),
     onSome: () => Effect.void,
 })));
 /**
  * Create the workspace mutations service from an existing workspace on disk.
  *
- * The workspace must already be initialized. Missing or invalid settings fail
- * fast with a typed `WorkspaceMutationsError`. The two operations-side
+ * The workspace must already be initialized. Missing or invalid settings and
+ * invalid or unsupported lockfiles fail fast with a typed
+ * `WorkspaceMutationsError`. The two operations-side
  * capabilities — the transaction runner and transition acquirer — are
  * injected through `makeCapabilities`; the composition seam in
  * `./operations/load-workspace.ts` supplies the live implementation.
@@ -112,7 +120,8 @@ export const makeWorkspaceMutations = (options, makeCapabilities) => Effect.gen(
     const readSettingsCell = (dir, sharedScope) => makeWorkspaceReadModel(scopeForDir(dir, sharedScope)).pipe(Effect.flatMap((readModel) => readModel.state.settings), Effect.provide(contextEnv));
     const readLockfileCell = (dir, sharedScope) => makeWorkspaceReadModel(scopeForDir(dir, sharedScope)).pipe(Effect.flatMap((readModel) => readModel.state.lockfile), Effect.map(Option.getOrElse(createEmptyLockfile)), Effect.provide(contextEnv));
     if (options.allowUninitialized !== true) {
-        yield* requireInitializedWorkspace(settingsPath, readSettingsCell(workspaceDir));
+        yield* requireInitializedWorkspace(settingsPath, readSettingsCell(workspaceDir), readLockfileCell(workspaceDir));
+        yield* readLockfileCell(workspaceDir);
     }
     const projectSettings = yield* readSettingsCell(localRuntimeDir, "project").pipe(Effect.map(Option.getOrElse(() => createDefaultSettings())));
     const userSettings = yield* readSettingsCell(userRuntimeDir, "user").pipe(Effect.map(Option.getOrElse(() => createDefaultSettings())));
@@ -161,15 +170,23 @@ export const makeWorkspaceMutations = (options, makeCapabilities) => Effect.gen(
         }
         // An unreadable or corrupt lockfile is actionable workspace state,
         // not a violated invariant.
-        return yield* readLockfileSafe(workspaceDir).pipe(Effect.as("ok"), Effect.catchTag(["LockfileIoError", "LockfileParseError", "LockfileDecodeError"], () => Effect.succeed("invalid")));
+        return yield* readLockfileSafe(workspaceDir).pipe(Effect.as("ok"), Effect.catchTag([
+            "LockfileIoError",
+            "LockfileParseError",
+            "LockfileDecodeError",
+            "LockfileVersionUnsupported",
+        ], () => Effect.succeed("invalid")));
     }).pipe(Effect.withSpan("WorkspaceMutations.getLockfileState"));
     const readScopedContext = (f) => makeWorkspaceReadModel(scopeForDir(workspaceDir)).pipe(Effect.flatMap(f), Effect.provide(contextEnv));
     const readDesiredStateGraph = (graphOptions) => Effect.gen(function* () {
         const settings = yield* readSettingsSafe(workspaceDir);
+        const configuredSources = yield* getConfiguredSources();
+        const registryAuthorities = Object.fromEntries(configuredSources.flatMap((source) => source.type === "registry" ? [[source.name, source.location]] : []));
         const graph = yield* buildDesiredStateGraph({
             baseDir,
             settings,
             layout,
+            registryAuthorities,
             ...(graphOptions?.prospectivePacks === undefined
                 ? {}
                 : { prospectivePacks: graphOptions.prospectivePacks }),
@@ -1083,8 +1100,16 @@ export const makeWorkspaceMutations = (options, makeCapabilities) => Effect.gen(
         // MCP Server methods
         // -----------------------------------------------------------------------
         getLockedMcpServers: () => readLockfileSafe(workspaceDir).pipe(Effect.map((lf) => lf.mcpServers ?? {})),
-        getLockedMcpServer: (name) => readLockfileSafe(workspaceDir).pipe(Effect.map((lf) => Option.fromUndefinedOr((lf.mcpServers ?? {})[name]))),
-        setMcpServer: ({ name, lockEntry, versionRange, env, enabled, agents }) => withMutex(Effect.gen(function* () {
+        getLockedMcpServer: (resolutionKey) => readLockfileSafe(workspaceDir).pipe(Effect.map((lf) => Option.fromUndefinedOr((lf.mcpServers ?? {})[resolutionKey]))),
+        getLockedMcpServerForConnection: (localName) => Effect.gen(function* () {
+            const graph = yield* readDesiredStateGraph();
+            const node = graph.nodes.find((candidate) => candidate.type === "mcp-server" && candidate.name === localName);
+            if (node === undefined || node.authority === "inline")
+                return Option.none();
+            const lockfile = yield* readLockfileSafe(workspaceDir);
+            return Option.fromUndefinedOr((lockfile.mcpServers ?? {})[node.identity]);
+        }),
+        setMcpServer: ({ name, resolutionKey, lockEntry, versionRange, env, enabled, agents, }) => withMutex(Effect.gen(function* () {
             // Update settings (uses "mcpServers" key)
             const currentSettings = yield* readSettingsSafe(workspaceDir);
             const currentMcpServers = currentSettings.mcpServers ?? {};
@@ -1098,7 +1123,7 @@ export const makeWorkspaceMutations = (options, makeCapabilities) => Effect.gen(
                         const fqn = formatFqn({
                             owner: lockEntry.owner,
                             type: "mcp-server",
-                            name: decodeExtensionNameSync(name),
+                            name: lockEntry.name,
                         });
                         const locator = Option.isSome(versionRange)
                             ? `${fqn}@${versionRange.value}`
@@ -1127,12 +1152,12 @@ export const makeWorkspaceMutations = (options, makeCapabilities) => Effect.gen(
                 ...currentLockfile,
                 mcpServers: {
                     ...currentLockedMcpServers,
-                    [name]: preserveAcceptedResolutionOnNoop(currentLockedMcpServers[name], lockEntry),
+                    [resolutionKey]: preserveAcceptedResolutionOnNoop(currentLockedMcpServers[resolutionKey], lockEntry),
                 },
             };
             yield* commitWorkspaceState(currentLockfile, updatedLockfile);
         })).pipe(Effect.withSpan("WorkspaceMutations.setMcpServer")),
-        setMcpServerLock: ({ name, lockEntry }) => withMutex(Effect.gen(function* () {
+        setMcpServerLock: ({ name: _name, resolutionKey, lockEntry }) => withMutex(Effect.gen(function* () {
             // Update lockfile only (skip settings) — used for pack dependencies
             const currentLockfile = yield* readLockfileSafe(workspaceDir);
             const currentLockedMcpServers = currentLockfile.mcpServers ?? {};
@@ -1140,7 +1165,7 @@ export const makeWorkspaceMutations = (options, makeCapabilities) => Effect.gen(
                 ...currentLockfile,
                 mcpServers: {
                     ...currentLockedMcpServers,
-                    [name]: preserveAcceptedResolutionOnNoop(currentLockedMcpServers[name], lockEntry),
+                    [resolutionKey]: preserveAcceptedResolutionOnNoop(currentLockedMcpServers[resolutionKey], lockEntry),
                 },
             };
             yield* commitWorkspaceState(currentLockfile, updatedLockfile);
@@ -1166,6 +1191,11 @@ export const makeWorkspaceMutations = (options, makeCapabilities) => Effect.gen(
             yield* writeScopedSettings(updatedSettings).pipe(Effect.provide(fsLayer));
         })),
         removeMcpServer: (name) => withMutex(Effect.gen(function* () {
+            const graph = yield* readDesiredStateGraph();
+            const desiredNode = graph.nodes.find((node) => node.type === "mcp-server" && node.name === name);
+            const closure = desiredNode === undefined || desiredNode.authority === "inline"
+                ? undefined
+                : graph.mcpSourceClosures.find((candidate) => candidate.identity === desiredNode.identity);
             // Update settings (uses "mcpServers" key)
             const currentSettings = yield* readSettingsSafe(workspaceDir);
             const currentMcpServers = currentSettings.mcpServers ?? {};
@@ -1182,8 +1212,14 @@ export const makeWorkspaceMutations = (options, makeCapabilities) => Effect.gen(
             // Update lockfile (uses "mcpServers" key)
             const currentLockfile = yield* readLockfileSafe(workspaceDir);
             const currentLockedMcpServers = currentLockfile.mcpServers ?? {};
-            if (name in currentLockedMcpServers) {
-                const { [name]: __, ...remainingLockedMcpServers } = currentLockedMcpServers;
+            const resolutionKey = desiredNode?.identity;
+            const keepSharedResolution = closure !== undefined &&
+                (closure.localNames.length > 1 ||
+                    closure.origins.some((origin) => origin.type === "pack"));
+            if (resolutionKey !== undefined &&
+                !keepSharedResolution &&
+                resolutionKey in currentLockedMcpServers) {
+                const { [resolutionKey]: __, ...remainingLockedMcpServers } = currentLockedMcpServers;
                 void __;
                 const updatedLockfile = {
                     ...currentLockfile,

package/dist/src/workspace/test-stubs.js

@@ -188,7 +188,7 @@ export const makeBaseWorkspaceMock = (axmDir = "/tmp/axm", overrides) => {
                 ],
             };
         }));
-        return { complete: true, nodes, problems: [] };
+        return { complete: true, nodes, mcpSourceClosures: [], problems: [] };
     });
     const runTransaction = (args) => Effect.gen(function* () {
         const value = yield* args.transition;
@@ -304,6 +304,7 @@ export const makeBaseWorkspaceMock = (axmDir = "/tmp/axm", overrides) => {
         removeSubagentLock: () => Effect.void,
         getLockedMcpServers: lockedMcpServers,
         getLockedMcpServer: entryFrom(lockedMcpServers),
+        getLockedMcpServerForConnection: entryFrom(lockedMcpServers),
         setMcpServer: () => Effect.void,
         setMcpServerLock: () => Effect.void,
         updateMcpServerEntry: () => Effect.void,
@@ -337,7 +338,7 @@ export const writeWorkspaceFiles = (runtimeDir, opts = {}) => {
         ...(opts.sources && { sources: opts.sources }),
     };
     const lockfile = {
-        lockfileVersion: 6,
+        lockfileVersion: 7,
         skills: opts.lockfileSkills ?? {},
         ...(hasEntries(opts.lockfileMcpServers) && { mcps: opts.lockfileMcpServers }),
         ...(hasEntries(opts.lockfileSubagents) && { subagents: opts.lockfileSubagents }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentxm/workspace-state",
-  "version": "0.28.4-bootstrap.0",
+  "version": "0.28.5",
   "description": "AXM workspace state kernel: settings, lockfile, read model, and desired-state vocabulary for the axm CLI. Unstable and unsupported — use the axm.sh CLI.",
   "type": "module",
   "license": "FSL-1.1-MIT",
@@ -18,10 +18,12 @@
   "exports": {
     ".": {
       "types": "./dist/src/index.d.ts",
+      "axm-source": "./src/index.ts",
       "default": "./dist/src/index.js"
     },
     "./testing": {
       "types": "./dist/src/testing.d.ts",
+      "axm-source": "./src/testing.ts",
       "default": "./dist/src/testing.js"
     }
   },
@@ -43,8 +45,8 @@
     "jsonc-parser": "^3.3.1",
     "semver": "^7.8.5",
     "yaml": "^2.9.0",
-    "@agentxm/registry-protocol": "^0.28.4-bootstrap.0",
-    "@agentxm/extension-model": "^0.28.4-bootstrap.0"
+    "@agentxm/extension-model": "^0.28.5",
+    "@agentxm/registry-protocol": "^0.28.5"
   },
   "devDependencies": {
     "@effect/platform-node": "4.0.0-rc.112",