diff --git a/extensions/git/package.json b/extensions/git/package.json
index 45befc1179f..3f879567091 100644
--- a/extensions/git/package.json
+++ b/extensions/git/package.json
@@ -220,305 +220,305 @@
         },
         {
           "command": "git.init",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == norepo"
+          "when": "config.git.enabled && scmProvider == git && gitState == norepo"
         },
         {
           "command": "git.refresh",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.openChange",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.openFile",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.stage",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.stageAll",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.stageSelectedRanges",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.revertSelectedRanges",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.unstage",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.unstageAll",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.unstageSelectedRanges",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.clean",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.cleanAll",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.commit",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.commitStaged",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.commitStagedSigned",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.commitAll",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.commitAllSigned",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.undoCommit",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.checkout",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.branch",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.pull",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.pullRebase",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.push",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.pushTo",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.sync",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.publish",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.showOutput",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         }
       ],
       "scm/title": [
         {
           "command": "git.init",
           "group": "navigation",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == norepo"
+          "when": "config.git.enabled && scmProvider == git && gitState == norepo"
         },
         {
           "command": "git.commit",
           "group": "navigation",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.refresh",
           "group": "navigation",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.sync",
           "group": "1_sync",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.pull",
           "group": "1_sync",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.pullRebase",
           "group": "1_sync",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.push",
           "group": "1_sync",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.pushTo",
           "group": "1_sync",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.publish",
           "group": "2_publish",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.commitStaged",
           "group": "3_commit",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.commitStagedSigned",
           "group": "3_commit",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.commitAll",
           "group": "3_commit",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.commitAllSigned",
           "group": "3_commit",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.undoCommit",
           "group": "3_commit",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.unstageAll",
           "group": "4_stage",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.cleanAll",
           "group": "4_stage",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         },
         {
           "command": "git.showOutput",
           "group": "5_output",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle"
+          "when": "config.git.enabled && scmProvider == git && gitState == idle"
         }
       ],
       "scm/resourceGroup/context": [
         {
           "command": "git.stageAll",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle && scmResourceGroup == merge",
+          "when": "config.git.enabled && scmProvider == git && gitState == idle && scmResourceGroup == merge",
           "group": "1_modification"
         },
         {
           "command": "git.stageAll",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle && scmResourceGroup == merge",
+          "when": "config.git.enabled && scmProvider == git && gitState == idle && scmResourceGroup == merge",
           "group": "inline"
         },
         {
           "command": "git.unstageAll",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle && scmResourceGroup == index",
+          "when": "config.git.enabled && scmProvider == git && gitState == idle && scmResourceGroup == index",
           "group": "1_modification"
         },
         {
           "command": "git.unstageAll",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle && scmResourceGroup == index",
+          "when": "config.git.enabled && scmProvider == git && gitState == idle && scmResourceGroup == index",
           "group": "inline"
         },
         {
           "command": "git.cleanAll",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle && scmResourceGroup == workingTree",
+          "when": "config.git.enabled && scmProvider == git && gitState == idle && scmResourceGroup == workingTree",
           "group": "1_modification"
         },
         {
           "command": "git.stageAll",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle && scmResourceGroup == workingTree",
+          "when": "config.git.enabled && scmProvider == git && gitState == idle && scmResourceGroup == workingTree",
           "group": "1_modification"
         },
         {
           "command": "git.cleanAll",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle && scmResourceGroup == workingTree",
+          "when": "config.git.enabled && scmProvider == git && gitState == idle && scmResourceGroup == workingTree",
           "group": "inline"
         },
         {
           "command": "git.stageAll",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle && scmResourceGroup == workingTree",
+          "when": "config.git.enabled && scmProvider == git && gitState == idle && scmResourceGroup == workingTree",
           "group": "inline"
         }
       ],
       "scm/resource/context": [
         {
           "command": "git.stage",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle && scmResourceGroup == merge",
+          "when": "config.git.enabled && scmProvider == git && gitState == idle && scmResourceGroup == merge",
           "group": "1_modification"
         },
         {
           "command": "git.stage",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle && scmResourceGroup == merge",
+          "when": "config.git.enabled && scmProvider == git && gitState == idle && scmResourceGroup == merge",
           "group": "inline"
         },
         {
           "command": "git.openChange",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle && scmResourceGroup == index",
+          "when": "config.git.enabled && scmProvider == git && gitState == idle && scmResourceGroup == index",
           "group": "navigation"
         },
         {
           "command": "git.openFile",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle && scmResourceGroup == index",
+          "when": "config.git.enabled && scmProvider == git && gitState == idle && scmResourceGroup == index",
           "group": "navigation"
         },
         {
           "command": "git.unstage",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle && scmResourceGroup == index",
+          "when": "config.git.enabled && scmProvider == git && gitState == idle && scmResourceGroup == index",
           "group": "1_modification"
         },
         {
           "command": "git.unstage",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle && scmResourceGroup == index",
+          "when": "config.git.enabled && scmProvider == git && gitState == idle && scmResourceGroup == index",
           "group": "inline"
         },
         {
           "command": "git.openChange",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle && scmResourceGroup == workingTree",
+          "when": "config.git.enabled && scmProvider == git && gitState == idle && scmResourceGroup == workingTree",
           "group": "navigation"
         },
         {
           "command": "git.openFile",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle && scmResourceGroup == workingTree",
+          "when": "config.git.enabled && scmProvider == git && gitState == idle && scmResourceGroup == workingTree",
           "group": "navigation"
         },
         {
           "command": "git.stage",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle && scmResourceGroup == workingTree",
+          "when": "config.git.enabled && scmProvider == git && gitState == idle && scmResourceGroup == workingTree",
           "group": "1_modification"
         },
         {
           "command": "git.clean",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle && scmResourceGroup == workingTree",
+          "when": "config.git.enabled && scmProvider == git && gitState == idle && scmResourceGroup == workingTree",
           "group": "1_modification"
         },
         {
           "command": "git.clean",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle && scmResourceGroup == workingTree",
+          "when": "config.git.enabled && scmProvider == git && gitState == idle && scmResourceGroup == workingTree",
           "group": "inline"
         },
         {
           "command": "git.stage",
-          "when": "config.git.enabled && scmProvider == git && scmProviderState == idle && scmResourceGroup == workingTree",
+          "when": "config.git.enabled && scmProvider == git && gitState == idle && scmResourceGroup == workingTree",
           "group": "inline"
         }
       ],
diff --git a/extensions/git/src/commands.ts b/extensions/git/src/commands.ts
index 6611e40af0c..3c548a008c4 100644
--- a/extensions/git/src/commands.ts
+++ b/extensions/git/src/commands.ts
@@ -112,7 +112,12 @@ export class CommandCenter {
 		await this.model.status();
 	}
 
-	async open(resource: Resource): Promise<void> {
+	@command('git.openResource')
+	async openResource(resource: Resource): Promise<void> {
+		await this._openResource(resource);
+	}
+
+	private async _openResource(resource: Resource): Promise<void> {
 		const left = this.getLeftResource(resource);
 		const right = this.getRightResource(resource);
 		const title = this.getTitle(resource);
@@ -137,7 +142,7 @@ export class CommandCenter {
 				return resource.original.with({ scheme: 'git', query: 'HEAD' });
 
 			case Status.MODIFIED:
-				return resource.sourceUri.with({ scheme: 'git', query: '~' });
+				return resource.resourceUri.with({ scheme: 'git', query: '~' });
 		}
 	}
 
@@ -146,34 +151,34 @@ export class CommandCenter {
 			case Status.INDEX_MODIFIED:
 			case Status.INDEX_ADDED:
 			case Status.INDEX_COPIED:
-				return resource.sourceUri.with({ scheme: 'git' });
+				return resource.resourceUri.with({ scheme: 'git' });
 
 			case Status.INDEX_RENAMED:
-				return resource.sourceUri.with({ scheme: 'git' });
+				return resource.resourceUri.with({ scheme: 'git' });
 
 			case Status.INDEX_DELETED:
 			case Status.DELETED:
-				return resource.sourceUri.with({ scheme: 'git', query: 'HEAD' });
+				return resource.resourceUri.with({ scheme: 'git', query: 'HEAD' });
 
 			case Status.MODIFIED:
 			case Status.UNTRACKED:
 			case Status.IGNORED:
-				const uriString = resource.sourceUri.toString();
-				const [indexStatus] = this.model.indexGroup.resources.filter(r => r.sourceUri.toString() === uriString);
+				const uriString = resource.resourceUri.toString();
+				const [indexStatus] = this.model.indexGroup.resources.filter(r => r.resourceUri.toString() === uriString);
 
-				if (indexStatus && indexStatus.rename) {
-					return indexStatus.rename;
+				if (indexStatus && indexStatus.renameResourceUri) {
+					return indexStatus.renameResourceUri;
 				}
 
-				return resource.sourceUri;
+				return resource.resourceUri;
 
 			case Status.BOTH_MODIFIED:
-				return resource.sourceUri;
+				return resource.resourceUri;
 		}
 	}
 
 	private getTitle(resource: Resource): string {
-		const basename = path.basename(resource.sourceUri.fsPath);
+		const basename = path.basename(resource.resourceUri.fsPath);
 
 		switch (resource.type) {
 			case Status.INDEX_MODIFIED:
@@ -251,7 +256,7 @@ export class CommandCenter {
 			return;
 		}
 
-		return await commands.executeCommand<void>('vscode.open', resource.sourceUri);
+		return await commands.executeCommand<void>('vscode.open', resource.resourceUri);
 	}
 
 	@command('git.openChange')
@@ -262,7 +267,7 @@ export class CommandCenter {
 			return;
 		}
 
-		return await this.open(resource);
+		return await this._openResource(resource);
 	}
 
 	@command('git.stage')
@@ -426,7 +431,7 @@ export class CommandCenter {
 		}
 
 		const message = resources.length === 1
-			? localize('confirm discard', "Are you sure you want to discard changes in {0}?", path.basename(resources[0].sourceUri.fsPath))
+			? localize('confirm discard', "Are you sure you want to discard changes in {0}?", path.basename(resources[0].resourceUri.fsPath))
 			: localize('confirm discard multiple', "Are you sure you want to discard changes in {0} files?", resources.length);
 
 		const yes = localize('discard', "Discard Changes");
@@ -769,20 +774,6 @@ export class CommandCenter {
 			return undefined;
 		}
 
-		if (uri.scheme === 'git-resource') {
-			const {resourceGroupId} = JSON.parse(uri.query) as { resourceGroupId: string, sourceUri: string };
-			const [resourceGroup] = this.model.resources.filter(g => g.contextKey === resourceGroupId);
-
-			if (!resourceGroup) {
-				return;
-			}
-
-			const uriStr = uri.toString();
-			const [resource] = resourceGroup.resources.filter(r => r.uri.toString() === uriStr);
-
-			return resource;
-		}
-
 		if (uri.scheme === 'git') {
 			uri = uri.with({ scheme: 'file' });
 		}
@@ -790,8 +781,8 @@ export class CommandCenter {
 		if (uri.scheme === 'file') {
 			const uriString = uri.toString();
 
-			return this.model.workingTreeGroup.resources.filter(r => r.sourceUri.toString() === uriString)[0]
-				|| this.model.indexGroup.resources.filter(r => r.sourceUri.toString() === uriString)[0];
+			return this.model.workingTreeGroup.resources.filter(r => r.resourceUri.toString() === uriString)[0]
+				|| this.model.indexGroup.resources.filter(r => r.resourceUri.toString() === uriString)[0];
 		}
 	}
 
diff --git a/extensions/git/src/main.ts b/extensions/git/src/main.ts
index 34eeb174a4e..aa9e4e620f4 100644
--- a/extensions/git/src/main.ts
+++ b/extensions/git/src/main.ts
@@ -78,10 +78,10 @@ async function init(context: ExtensionContext, disposables: Disposable[]): Promi
 		}
 	}
 
-	filterEvent(scm.onDidAcceptInputValue, () => scm.activeProvider === provider)
+	filterEvent(scm.onDidAcceptInputValue, () => scm.activeSourceControl === provider.sourceControl)
 		(commandCenter.commitWithInput, commandCenter, disposables);
 
-	if (scm.activeProvider === provider) {
+	if (scm.activeSourceControl === provider.sourceControl) {
 		scm.inputBox.value = await model.getCommitTemplate();
 	}
 }
diff --git a/extensions/git/src/merge.ts b/extensions/git/src/merge.ts
index 0e7a17c7884..457e966d89a 100644
--- a/extensions/git/src/merge.ts
+++ b/extensions/git/src/merge.ts
@@ -62,7 +62,7 @@ class TextEditorMergeDecorator {
 			return;
 		}
 
-		if (this.model.mergeGroup.resources.some(r => r.type === Status.BOTH_MODIFIED && r.sourceUri.toString() === this.uri)) {
+		if (this.model.mergeGroup.resources.some(r => r.type === Status.BOTH_MODIFIED && r.resourceUri.toString() === this.uri)) {
 			decorations = decorate(this.editor.document);
 		}
 
diff --git a/extensions/git/src/model.ts b/extensions/git/src/model.ts
index f9cbd83caf9..8da1f5a959c 100644
--- a/extensions/git/src/model.ts
+++ b/extensions/git/src/model.ts
@@ -5,7 +5,7 @@
 
 'use strict';
 
-import { Uri, EventEmitter, Event, SCMResource, SCMResourceDecorations, SCMResourceGroup, Disposable, window, workspace } from 'vscode';
+import { Uri, Command, EventEmitter, Event, SourceControlResourceState, SourceControlResourceDecorations, Disposable, window, workspace } from 'vscode';
 import { Git, Repository, Ref, Branch, Remote, PushOptions, Commit, GitErrorCodes, GitError } from './git';
 import { anyEvent, eventToPromise, filterEvent, mapEvent, EmptyDisposable, combinedDisposable, dispose } from './util';
 import { memoize, throttle, debounce } from './decorators';
@@ -51,31 +51,29 @@ export enum Status {
 	BOTH_MODIFIED
 }
 
-export class Resource implements SCMResource {
+export class Resource implements SourceControlResourceState {
 
 	@memoize
-	get uri(): Uri {
-		return new Uri().with({
-			scheme: 'git-resource',
-			query: JSON.stringify({
-				resourceGroupId: this.resourceGroupId,
-				sourceUri: this.sourceUri.toString()
-			})
-		});
+	get resourceUri(): Uri {
+		if (this.renameResourceUri && (this._type === Status.MODIFIED || this._type === Status.DELETED || this._type === Status.INDEX_RENAMED)) {
+			return this.renameResourceUri;
+		}
+
+		return this._resourceUri;
 	}
 
 	@memoize
-	get sourceUri(): Uri {
-		if (this.rename && (this._type === Status.MODIFIED || this._type === Status.DELETED || this._type === Status.INDEX_RENAMED)) {
-			return this.rename;
-		}
-
-		return this._sourceUri;
+	get command(): Command {
+		return {
+			command: 'git.openResource',
+			title: localize('open', "Open"),
+			arguments: [this]
+		};
 	}
 
 	get type(): Status { return this._type; }
-	get original(): Uri { return this._sourceUri; }
-	get rename(): Uri | undefined { return this._rename; }
+	get original(): Uri { return this._resourceUri; }
+	get renameResourceUri(): Uri | undefined { return this._renameResourceUri; }
 
 	private static Icons = {
 		light: {
@@ -134,23 +132,19 @@ export class Resource implements SCMResource {
 		}
 	}
 
-	get decorations(): SCMResourceDecorations {
+	get decorations(): SourceControlResourceDecorations {
 		const light = { iconPath: this.getIconPath('light') };
 		const dark = { iconPath: this.getIconPath('dark') };
 
 		return { strikeThrough: this.strikeThrough, light, dark };
 	}
 
-	constructor(private resourceGroupId: string, private _sourceUri: Uri, private _type: Status, private _rename?: Uri) {
-		// console.log(this);
-	}
+	constructor(private resourceGroupId: string, private _resourceUri: Uri, private _type: Status, private _renameResourceUri?: Uri) { }
 }
 
-export class ResourceGroup implements SCMResourceGroup {
-
-	@memoize
-	get uri(): Uri { return Uri.parse(`git-resource-group:${this.contextKey}`); }
+export class ResourceGroup {
 
+	get id(): string { return this._id; }
 	get contextKey(): string { return this._id; }
 	get label(): string { return this._label; }
 	get resources(): Resource[] { return this._resources; }
@@ -280,8 +274,8 @@ export class Model implements Disposable {
 	private _onDidChangeState = new EventEmitter<State>();
 	readonly onDidChangeState: Event<State> = this._onDidChangeState.event;
 
-	private _onDidChangeResources = new EventEmitter<SCMResourceGroup[]>();
-	readonly onDidChangeResources: Event<SCMResourceGroup[]> = this._onDidChangeResources.event;
+	private _onDidChangeResources = new EventEmitter<void>();
+	readonly onDidChangeResources: Event<void> = this._onDidChangeResources.event;
 
 	@memoize
 	get onDidChange(): Event<void> {
@@ -308,22 +302,6 @@ export class Model implements Disposable {
 	private _workingTreeGroup = new WorkingTreeGroup([]);
 	get workingTreeGroup(): WorkingTreeGroup { return this._workingTreeGroup; }
 
-	get resources(): ResourceGroup[] {
-		const result: ResourceGroup[] = [];
-
-		if (this._mergeGroup.resources.length > 0) {
-			result.push(this._mergeGroup);
-		}
-
-		if (this._indexGroup.resources.length > 0) {
-			result.push(this._indexGroup);
-		}
-
-		result.push(this._workingTreeGroup);
-
-		return result;
-	}
-
 	private _HEAD: Branch | undefined;
 	get HEAD(): Branch | undefined {
 		return this._HEAD;
@@ -356,7 +334,7 @@ export class Model implements Disposable {
 		this._mergeGroup = new MergeGroup();
 		this._indexGroup = new IndexGroup();
 		this._workingTreeGroup = new WorkingTreeGroup();
-		this._onDidChangeResources.fire(this.resources);
+		this._onDidChangeResources.fire();
 	}
 
 	private onWorkspaceChange: Event<Uri>;
@@ -412,7 +390,7 @@ export class Model implements Disposable {
 
 	@throttle
 	async add(...resources: Resource[]): Promise<void> {
-		await this.run(Operation.Add, () => this.repository.add(resources.map(r => r.sourceUri.fsPath)));
+		await this.run(Operation.Add, () => this.repository.add(resources.map(r => r.resourceUri.fsPath)));
 	}
 
 	@throttle
@@ -423,7 +401,7 @@ export class Model implements Disposable {
 
 	@throttle
 	async revertFiles(...resources: Resource[]): Promise<void> {
-		await this.run(Operation.RevertFiles, () => this.repository.revertFiles('HEAD', resources.map(r => r.sourceUri.fsPath)));
+		await this.run(Operation.RevertFiles, () => this.repository.revertFiles('HEAD', resources.map(r => r.resourceUri.fsPath)));
 	}
 
 	@throttle
@@ -447,11 +425,11 @@ export class Model implements Disposable {
 				switch (r.type) {
 					case Status.UNTRACKED:
 					case Status.IGNORED:
-						toClean.push(r.sourceUri.fsPath);
+						toClean.push(r.resourceUri.fsPath);
 						break;
 
 					default:
-						toCheckout.push(r.sourceUri.fsPath);
+						toCheckout.push(r.resourceUri.fsPath);
 						break;
 				}
 			});
@@ -671,7 +649,7 @@ export class Model implements Disposable {
 		this._mergeGroup = new MergeGroup(merge);
 		this._indexGroup = new IndexGroup(index);
 		this._workingTreeGroup = new WorkingTreeGroup(workingTree);
-		this._onDidChangeResources.fire(this.resources);
+		this._onDidChangeResources.fire();
 	}
 
 	private onFSChange(uri: Uri): void {
diff --git a/extensions/git/src/scmProvider.ts b/extensions/git/src/scmProvider.ts
index 08db7dd8a1d..f94c141f744 100644
--- a/extensions/git/src/scmProvider.ts
+++ b/extensions/git/src/scmProvider.ts
@@ -5,17 +5,15 @@
 
 'use strict';
 
-import { scm, Uri, Disposable, SCMProvider, SCMResourceGroup, Event, workspace } from 'vscode';
-import { Model, Resource, State } from './model';
+import { scm, Uri, Disposable, SourceControl, SourceControlResourceGroup, Event, workspace, commands } from 'vscode';
+import { Model, State } from './model';
 import { CommandCenter } from './commands';
 import { mapEvent } from './util';
 
-export class GitSCMProvider implements SCMProvider {
+export class GitSCMProvider {
 
 	private disposables: Disposable[] = [];
-
 	get contextKey(): string { return 'git'; }
-	get resources(): SCMResourceGroup[] { return this.model.resources; }
 
 	get onDidChange(): Event<this> {
 		return mapEvent(this.model.onDidChange, () => this);
@@ -38,16 +36,40 @@ export class GitSCMProvider implements SCMProvider {
 		switch (countBadge) {
 			case 'off': return 0;
 			case 'tracked': return this.model.indexGroup.resources.length;
-			default: return this.model.resources.reduce((r, g) => r + g.resources.length, 0);
+			default:
+				return this.model.mergeGroup.resources.length
+					+ this.model.indexGroup.resources.length
+					+ this.model.workingTreeGroup.resources.length;
 		}
 	}
 
-	constructor(private model: Model, private commandCenter: CommandCenter) {
-		scm.registerSCMProvider(this);
+	private _sourceControl: SourceControl;
+
+	get sourceControl(): SourceControl {
+		return this._sourceControl;
 	}
 
-	open(resource: Resource): void {
-		this.commandCenter.open(resource);
+	private mergeGroup: SourceControlResourceGroup;
+	private indexGroup: SourceControlResourceGroup;
+	private workingTreeGroup: SourceControlResourceGroup;
+
+	constructor(private model: Model, private commandCenter: CommandCenter) {
+		this._sourceControl = scm.createSourceControl('git', 'Git');
+		this._sourceControl.quickDiffProvider = this;
+		this.disposables.push(this._sourceControl);
+
+		this.mergeGroup = this._sourceControl.createResourceGroup(model.mergeGroup.id, model.mergeGroup.label);
+		this.indexGroup = this._sourceControl.createResourceGroup(model.indexGroup.id, model.indexGroup.label);
+		this.workingTreeGroup = this._sourceControl.createResourceGroup(model.workingTreeGroup.id, model.workingTreeGroup.label);
+
+		this.mergeGroup.hideWhenEmpty = true;
+		this.indexGroup.hideWhenEmpty = true;
+
+		this.disposables.push(this.mergeGroup);
+		this.disposables.push(this.indexGroup);
+		this.disposables.push(this.workingTreeGroup);
+
+		model.onDidChange(this.onDidModelChange, this, this.disposables);
 	}
 
 	provideOriginalResource(uri: Uri): Uri | undefined {
@@ -60,6 +82,14 @@ export class GitSCMProvider implements SCMProvider {
 		return new Uri().with({ scheme: 'git-original', query: uri.path, path: uri.path + '.git' });
 	}
 
+	private onDidModelChange(): void {
+		this.mergeGroup.resourceStates = this.model.mergeGroup.resources;
+		this.indexGroup.resourceStates = this.model.indexGroup.resources;
+		this.workingTreeGroup.resourceStates = this.model.workingTreeGroup.resources;
+		this._sourceControl.count = this.count;
+		commands.executeCommand('setContext', 'gitState', this.stateContextKey);
+	}
+
 	dispose(): void {
 		this.disposables.forEach(d => d.dispose());
 		this.disposables = [];
diff --git a/src/vs/vscode.d.ts b/src/vs/vscode.d.ts
index 19786714a21..f30f6c78150 100644
--- a/src/vs/vscode.d.ts
+++ b/src/vs/vscode.d.ts
@@ -3857,8 +3857,8 @@ declare module 'vscode' {
 		export function setStatusBarMessage(text: string): Disposable;
 
 		/**
-		 * Show progress in the scm viewlet while running the given callback and while its returned
-		 * promise isn't resolve or rejected.
+		 * Show progress in the Source Control viewlet while running the given callback and while
+		 * its returned promise isn't resolve or rejected.
 		 *
 		 * @param task A callback returning a promise. Progress increments can be reported with
 		 * the provided [progress](#Progress)-object.
@@ -4539,147 +4539,17 @@ declare module 'vscode' {
 	}
 
 	/**
-	 * The theme-aware decorations for a [SCM resource](#SCMResource).
+	 * Represents the input box in the Source Control viewlet.
 	 */
-	export interface SCMResourceThemableDecorations {
+	export interface SourceControlInputBox {
 
 		/**
-		 * The icon path for a specific [SCM resource](#SCMResource).
+		 * Setter and getter for the contents of the input box.
 		 */
-		readonly iconPath?: string | Uri;
+		value: string;
 	}
 
-	/**
-	 * The decorations for a [SCM resource](#SCMResource). Can be specified
-	 * for light and dark themes, independently.
-	 */
-	export interface SCMResourceDecorations extends SCMResourceThemableDecorations {
-
-		/**
-		 * Whether the [SCM resource](#SCMResource) should be striked-through
-		 * in the UI.
-		 */
-		readonly strikeThrough?: boolean;
-
-		/**
-		 * The light theme decorations.
-		 */
-		readonly light?: SCMResourceThemableDecorations;
-
-		/**
-		 * The dark theme decorations.
-		 */
-		readonly dark?: SCMResourceThemableDecorations;
-	}
-
-	/**
-	 * An SCM resource represents the state of an underlying workspace
-	 * resource within a certain SCM provider state.
-	 */
-	export interface SCMResource {
-
-		/**
-		 * The [uri](#Uri) of this SCM resource. This uri should uniquely
-		 * identify this SCM resource. Its value should be semantically
-		 * related to your [SCM provider](#SCMProvider).
-		 *
-		 * For example, consider file `/foo/bar` to be modified. An SCM
-		 * resource which would represent such state could have the
-		 * following properties:
-		 *
-		 *   - `uri = 'git:workingtree/A'`
-		 *   - `sourceUri = 'file:///foo/bar'`
-		 */
-		readonly uri: Uri;
-
-		/**
-		 * The [uri](#Uri) of the underlying resource inside the workspace.
-		 */
-		readonly sourceUri: Uri;
-
-		/**
-		 * The [decorations](#SCMResourceDecorations) for this SCM resource.
-		 */
-		readonly decorations?: SCMResourceDecorations;
-	}
-
-	/**
-	 * An SCM resource group is a collection of [SCM resources](#SCMResource).
-	 */
-	export interface SCMResourceGroup {
-
-		/**
-		 * The [uri](#Uri) of this SCM resource group. This uri should
-		 * uniquely identify this SCM resource group. Its value should be
-		 * semantically related to your [SCM provider](#SCMProvider).
-		 *
-		 * For example, consider a Working Tree resource group. An SCM
-		 * resource group which would represent such state could have the
-		 * following properties:
-		 *
-		 *   - `uri = 'git:workingtree'`
-		 *   - `label = 'Working Tree'`
-		 */
-		readonly uri: Uri;
-
-		/**
-		 * The UI label of the SCM resource group.
-		 */
-		readonly label: string;
-
-		/**
-		 * The context key of the SCM resource group, which will be used to populate
-		 * the value of the `scmResourceGroup` context key.
-		 */
-		readonly contextKey?: string;
-
-		/**
-		 * The collection of [SCM resources](#SCMResource) within the SCM resource group.
-		 */
-		readonly resources: SCMResource[];
-	}
-
-	/**
-	 * An SCM provider is able to provide [SCM resources](#SCMResource) to the editor,
-	 * notify of changes in them and interact with the editor in several SCM related ways.
-	 */
-	export interface SCMProvider {
-
-		/**
-		 * A human-readable label for the name of the SCM Provider.
-		 */
-		readonly label: string;
-
-		/**
-		 * The context key of the SCM provider, which will be used to populate
-		 * the value of the `scmProvider` context key.
-		 */
-		readonly contextKey?: string;
-
-		/**
-		 * The list of SCM resource groups.
-		 */
-		readonly resources: SCMResourceGroup[];
-
-		/**
-		 * A count of resources, used in the UI as the label for the SCM changes count.
-		 */
-		readonly count?: number;
-
-		/**
-		 * A state identifier, which will be used to populate the value of the
-		 * `scmProviderState` context key.
-		 */
-		readonly stateContextKey?: string;
-
-		/**
-		 * An [event](#Event) which should fire when any of the following attributes
-		 * have changed:
-		 *   - [resources](#SCMProvider.resources)
-		 *   - [count](#SCMProvider.count)
-		 *   - [state](#SCMProvider.state)
-		 */
-		readonly onDidChange?: Event<SCMProvider>;
+	interface QuickDiffProvider {
 
 		/**
 		 * Provide a [uri](#Uri) to the original resource of any given resource uri.
@@ -4689,58 +4559,174 @@ declare module 'vscode' {
 		 * @return A thenable that resolves to uri of the matching original resource.
 		 */
 		provideOriginalResource?(uri: Uri, token: CancellationToken): ProviderResult<Uri>;
-
-		/**
-		 * Open a specific [SCM resource](#SCMResource). Called when SCM resources
-		 * are clicked in the UI, for example.
-		 *
-		 * @param resource The [SCM resource](#SCMResource) which should be open.
-		 * @param token A cancellation token.
-		 * @return A thenable which resolves when the resource is open.
-		 */
-		open?(resource: SCMResource): void;
 	}
 
 	/**
-	 * Represents the input box in the SCM view.
+	 * The theme-aware decorations for a
+	 * [source control resource state](#SourceControlResourceState).
 	 */
-	export interface SCMInputBox {
+	export interface SourceControlResourceThemableDecorations {
 
 		/**
-		 * Setter and getter for the contents of the input box.
+		 * The icon path for a specific
+		 * [source control resource state](#SourceControlResourceState).
 		 */
-		value: string;
+		readonly iconPath?: string | Uri;
+	}
+
+	/**
+	 * The decorations for a [source control resource state](#SourceControlResourceState).
+	 * Can be independently specified for light and dark themes.
+	 */
+	export interface SourceControlResourceDecorations extends SourceControlResourceThemableDecorations {
+
+		/**
+		 * Whether the [source control resource state](#SourceControlResourceState) should
+		 * be striked-through in the UI.
+		 */
+		readonly strikeThrough?: boolean;
+
+		/**
+		 * The light theme decorations.
+		 */
+		readonly light?: SourceControlResourceThemableDecorations;
+
+		/**
+		 * The dark theme decorations.
+		 */
+		readonly dark?: SourceControlResourceThemableDecorations;
+	}
+
+	/**
+	 * An source control resource state represents the state of an underlying workspace
+	 * resource within a certain [source control group](#SourceControlResourceGroup).
+	 */
+	export interface SourceControlResourceState {
+
+		/**
+		 * The [uri](#Uri) of the underlying resource inside the workspace.
+		 */
+		readonly resourceUri: Uri;
+
+		/**
+		 * The [command](#Command) which should be run when the resource
+		 * state is open in the Source Control viewlet.
+		 */
+		readonly command: Command;
+
+		/**
+		 * The [decorations](#SourceControlResourceDecorations) for this source control
+		 * resource state.
+		 */
+		readonly decorations?: SourceControlResourceDecorations;
+	}
+
+	/**
+	 * A source control resource group is a collection of
+	 * [source control resource states](#SourceControlResourceState).
+	 */
+	export interface SourceControlResourceGroup {
+
+		/**
+		 * The id of this source control resource group.
+		 */
+		readonly id: string;
+
+		/**
+		 * The label of this source control resource group.
+		 */
+		readonly label: string;
+
+		/**
+		 * Whether this source control resource group is hidden when it contains
+		 * no [source control resource states](#SourceControlResourceState).
+		 */
+		hideWhenEmpty?: boolean;
+
+		/**
+		 * This group's collection of
+		 * [source control resource states](#SourceControlResourceState).
+		 */
+		resourceStates: SourceControlResourceState[];
+
+		/**
+		 * Dispose this source control resource group.
+		 */
+		dispose(): void;
+	}
+
+	/**
+	 * An source control is able to provide [resource states](#SourceControlResourceState)
+	 * to the editor and interact with the editor in several source control related ways.
+	 */
+	export interface SourceControl {
+
+		/**
+		 * The id of this source control.
+		 */
+		readonly id: string;
+
+		/**
+		 * The human-readable label of this source control.
+		 */
+		readonly label: string;
+
+		/**
+		 * The UI-visible count of [resource states](#SourceControlResourceState) of
+		 * this source control.
+		 *
+		 * Equals to the total number of [resource state](#SourceControlResourceState)
+		 * of this source control, if undefined.
+		 */
+		count?: number;
+
+		/**
+		 * An optional [quick diff provider](#QuickDiffProvider).
+		 */
+		quickDiffProvider?: QuickDiffProvider;
+
+		/**
+		 * Create a new [resource group](#SourceControlResourceGroup).
+		 */
+		createResourceGroup(id: string, label: string): SourceControlResourceGroup;
+
+		/**
+		 * Dispose this source control.
+		 */
+		dispose(): void;
 	}
 
 	export namespace scm {
 
 		/**
-		 * The currently active [SCM provider](#SCMProvider).
+		 * The currently active [source control](#SourceControl).
 		 */
-		export let activeProvider: SCMProvider | undefined;
+		export let activeSourceControl: SourceControl | undefined;
 
 		/**
-		 * An [event](#Event) which fires when the active [SCM provider](#SCMProvider)
+		 * An [event](#Event) which fires when the active [source control](#SourceControl)
 		 * has changed.
 		 */
-		export const onDidChangeActiveProvider: Event<SCMProvider>;
+		export const onDidChangeActiveSourceControl: Event<SourceControl>;
 
 		/**
-		 * The [input box](#SCMInputBox) in the SCM view.
+		 * The [input box](#SourceControlInputBox) in the Source Control viewlet.
 		 */
-		export const inputBox: SCMInputBox;
+		export const inputBox: SourceControlInputBox;
 
 		/**
 		 * An [event](#Event) which fires when the user has accepted the changes.
 		 */
-		export const onDidAcceptInputValue: Event<SCMInputBox>;
+		export const onDidAcceptInputValue: Event<SourceControlInputBox>;
 
 		/**
-		 * Registers an [SCM provider](#SCMProvider).
+		 * Creates a new [source control](#SourceControl) instance.
 		 *
-		 * @return A disposable which unregisters the provider.
+		 * @param id A unique `id` for the source control. Something short, eg: `git`.
+		 * @param label A human-readable string for the source control. Eg: `Git`.
+		 * @return An instance of [source control](#SourceControl).
 		 */
-		export function registerSCMProvider(provider: SCMProvider): Disposable;
+		export function createSourceControl(id: string, label: string): SourceControl;
 	}
 
 	/**
diff --git a/src/vs/workbench/api/node/extHost.api.impl.ts b/src/vs/workbench/api/node/extHost.api.impl.ts
index 241b7150f91..53af0ff3782 100644
--- a/src/vs/workbench/api/node/extHost.api.impl.ts
+++ b/src/vs/workbench/api/node/extHost.api.impl.ts
@@ -117,7 +117,7 @@ export function createApiFactory(
 	const extHostFileSystemEvent = col.define(ExtHostContext.ExtHostFileSystemEventService).set<ExtHostFileSystemEventService>(new ExtHostFileSystemEventService());
 	const extHostQuickOpen = col.define(ExtHostContext.ExtHostQuickOpen).set<ExtHostQuickOpen>(new ExtHostQuickOpen(threadService));
 	const extHostTerminalService = col.define(ExtHostContext.ExtHostTerminalService).set<ExtHostTerminalService>(new ExtHostTerminalService(threadService));
-	const extHostSCM = col.define(ExtHostContext.ExtHostSCM).set<ExtHostSCM>(new ExtHostSCM(threadService));
+	const extHostSCM = col.define(ExtHostContext.ExtHostSCM).set<ExtHostSCM>(new ExtHostSCM(threadService, extHostCommands));
 	const extHostTask = col.define(ExtHostContext.ExtHostTask).set<ExtHostTask>(new ExtHostTask(threadService));
 	col.define(ExtHostContext.ExtHostExtensionService).set(extensionService);
 	col.finish(false, threadService);
@@ -448,30 +448,30 @@ export function createApiFactory(
 
 		class SCM {
 
-			get activeProvider() {
+			get activeSourceControl() {
 				return extHostSCM.activeProvider;
 			}
 
-			get onDidChangeActiveProvider() {
+			get onDidChangeActiveSourceControl() {
 				return extHostSCM.onDidChangeActiveProvider;
 			}
 
-			get onDidAcceptInputValue() {
-				return mapEvent(extHostSCM.inputBox.onDidAccept, () => extHostSCM.inputBox);
-			}
-
 			get inputBox() {
 				return extHostSCM.inputBox;
 			}
 
-			registerSCMProvider(provider: vscode.SCMProvider) {
+			get onDidAcceptInputValue() {
+				return mapEvent(extHostSCM.inputBox.onDidAccept, () => extHostSCM.inputBox);
+			}
+
+			createSourceControl(id: string, label: string) {
 				telemetryService.publicLog('registerSCMProvider', {
 					extensionId: extension.id,
-					providerLabel: provider.label,
-					providerContextKey: provider.contextKey
+					providerId: id,
+					providerLabel: label
 				});
 
-				return extHostSCM.registerSCMProvider(provider);
+				return extHostSCM.createSourceControl(id, label);
 			}
 		}
 
diff --git a/src/vs/workbench/api/node/extHost.protocol.ts b/src/vs/workbench/api/node/extHost.protocol.ts
index 3ba69934e18..1a2fd7cd764 100644
--- a/src/vs/workbench/api/node/extHost.protocol.ts
+++ b/src/vs/workbench/api/node/extHost.protocol.ts
@@ -251,30 +251,31 @@ export abstract class MainProcessExtensionServiceShape {
 }
 
 export interface SCMProviderFeatures {
-	label: string;
-	contextKey?: string;
-	supportsOpen: boolean;
-	supportsOriginalResource: boolean;
+	hasQuickDiffProvider?: boolean;
+	count?: number;
+}
+
+export interface SCMGroupFeatures {
+	hideWhenEmpty?: boolean;
 }
 
 export type SCMRawResource = [
-	string /*uri*/,
-	string /*sourceUri*/,
+	string /*resourceUri*/,
+	modes.Command /*command*/,
 	string[] /*icons: light, dark*/,
 	boolean /*strike through*/
 ];
 
-export type SCMRawResourceGroup = [
-	string /*uri*/,
-	string | undefined /*context key*/,
-	string /*label*/,
-	SCMRawResource[]
-];
-
 export abstract class MainThreadSCMShape {
-	$register(handle: number, features: SCMProviderFeatures): void { throw ni(); }
-	$unregister(handle: number): void { throw ni(); }
-	$onChange(handle: number, resources: SCMRawResourceGroup[], count: number | undefined, stateContextKey: string | undefined): void { throw ni(); }
+	$registerSourceControl(handle: number, id: string, label: string): void { throw ni(); }
+	$updateSourceControl(handle: number, features: SCMProviderFeatures): void { throw ni(); }
+	$unregisterSourceControl(handle: number): void { throw ni(); }
+
+	$registerGroup(sourceControlHandle: number, handle: number, id: string, label: string): void { throw ni(); }
+	$updateGroup(sourceControlHandle: number, handle: number, features: SCMGroupFeatures): void { throw ni(); }
+	$updateGroupResourceStates(sourceControlHandle: number, groupHandle: number, resources: SCMRawResource[]): void { throw ni(); }
+	$unregisterGroup(sourceControlHandle: number, handle: number): void { throw ni(); }
+
 	$setInputBoxValue(value: string): void { throw ni(); }
 }
 
@@ -418,9 +419,8 @@ export abstract class ExtHostTerminalServiceShape {
 }
 
 export abstract class ExtHostSCMShape {
-	$open(handle: number, uri: string): TPromise<void> { throw ni(); }
-	$getOriginalResource(handle: number, uri: URI): TPromise<URI> { throw ni(); }
-	$onActiveProviderChange(handle: number): TPromise<void> { throw ni(); }
+	$provideOriginalResource(sourceControlHandle: number, uri: URI): TPromise<URI> { throw ni(); }
+	$onActiveSourceControlChange(sourceControlHandle: number): TPromise<void> { throw ni(); }
 	$onInputBoxValueChange(value: string): TPromise<void> { throw ni(); }
 	$onInputBoxAcceptChanges(): TPromise<void> { throw ni(); }
 }
diff --git a/src/vs/workbench/api/node/extHostSCM.ts b/src/vs/workbench/api/node/extHostSCM.ts
index b6c0220018e..91cfc7e7518 100644
--- a/src/vs/workbench/api/node/extHostSCM.ts
+++ b/src/vs/workbench/api/node/extHostSCM.ts
@@ -6,14 +6,14 @@
 
 import URI from 'vs/base/common/uri';
 import { TPromise } from 'vs/base/common/winjs.base';
-import Event, { Emitter, debounceEvent, createEmptyEvent } from 'vs/base/common/event';
+import Event, { Emitter } from 'vs/base/common/event';
 import { asWinJsPromise } from 'vs/base/common/async';
 import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
-import { Disposable } from 'vs/workbench/api/node/extHostTypes';
-import { MainContext, MainThreadSCMShape, SCMRawResource, SCMRawResourceGroup } from './extHost.protocol';
+import { ExtHostCommands, CommandsConverter } from 'vs/workbench/api/node/extHostCommands';
+import { MainContext, MainThreadSCMShape, SCMRawResource } from './extHost.protocol';
 import * as vscode from 'vscode';
 
-function getIconPath(decorations: vscode.SCMResourceThemableDecorations) {
+function getIconPath(decorations: vscode.SourceControlResourceThemableDecorations) {
 	if (!decorations) {
 		return undefined;
 	} else if (typeof decorations.iconPath === 'string') {
@@ -67,6 +67,133 @@ export class ExtHostSCMInputBox {
 	}
 }
 
+class ExtHostSourceControlResourceGroup implements vscode.SourceControlResourceGroup {
+
+	private static _handlePool: number = 0;
+
+	get id(): string {
+		return this._id;
+	}
+
+	get label(): string {
+		return this._label;
+	}
+
+	private _hideWhenEmpty: boolean | undefined = undefined;
+
+	get hideWhenEmpty(): boolean | undefined {
+		return this._hideWhenEmpty;
+	}
+
+	set hideWhenEmpty(hideWhenEmpty: boolean | undefined) {
+		this._hideWhenEmpty = hideWhenEmpty;
+		this._proxy.$updateGroup(this._sourceControlHandle, this._handle, { hideWhenEmpty });
+	}
+
+	private _resourcesStates: vscode.SourceControlResourceState[] = [];
+
+	get resourceStates(): vscode.SourceControlResourceState[] {
+		return this._resourcesStates;
+	}
+
+	set resourceStates(resources: vscode.SourceControlResourceState[]) {
+		this._resourcesStates = resources;
+
+		const rawResources = resources.map(r => {
+			const sourceUri = r.resourceUri.toString();
+			const command = this._commands.toInternal(r.command);
+			const iconPath = getIconPath(r.decorations);
+			const lightIconPath = r.decorations && getIconPath(r.decorations.light) || iconPath;
+			const darkIconPath = r.decorations && getIconPath(r.decorations.dark) || iconPath;
+			const icons: string[] = [];
+
+			if (lightIconPath || darkIconPath) {
+				icons.push(lightIconPath);
+			}
+
+			if (darkIconPath !== lightIconPath) {
+				icons.push(darkIconPath);
+			}
+
+			const strikeThrough = r.decorations && !!r.decorations.strikeThrough;
+
+			return [sourceUri, command, icons, strikeThrough] as SCMRawResource;
+		});
+
+		this._proxy.$updateGroupResourceStates(this._sourceControlHandle, this._handle, rawResources);
+	}
+
+	private _handle: number = ExtHostSourceControlResourceGroup._handlePool++;
+
+	constructor(
+		private _proxy: MainThreadSCMShape,
+		private _commands: CommandsConverter,
+		private _sourceControlHandle: number,
+		private _id: string,
+		private _label: string,
+	) {
+		this._proxy.$registerGroup(_sourceControlHandle, this._handle, _id, _label);
+	}
+
+	dispose(): void {
+		this._proxy.$unregisterGroup(this._sourceControlHandle, this._handle);
+	}
+}
+
+class ExtHostSourceControl implements vscode.SourceControl {
+
+	private static _handlePool: number = 0;
+
+	get id(): string {
+		return this._id;
+	}
+
+	get label(): string {
+		return this._label;
+	}
+
+	private _count: number | undefined = undefined;
+
+	get count(): number | undefined {
+		return this._count;
+	}
+
+	set count(count: number | undefined) {
+		this._count = count;
+		this._proxy.$updateSourceControl(this._handle, { count });
+	}
+
+	private _quickDiffProvider: vscode.QuickDiffProvider | undefined = undefined;
+
+	get quickDiffProvider(): vscode.QuickDiffProvider | undefined {
+		return this._quickDiffProvider;
+	}
+
+	set quickDiffProvider(quickDiffProvider: vscode.QuickDiffProvider | undefined) {
+		this._quickDiffProvider = quickDiffProvider;
+		this._proxy.$updateSourceControl(this._handle, { hasQuickDiffProvider: !!quickDiffProvider });
+	}
+
+	private _handle: number = ExtHostSourceControl._handlePool++;
+
+	constructor(
+		private _proxy: MainThreadSCMShape,
+		private _commands: CommandsConverter,
+		private _id: string,
+		private _label: string,
+	) {
+		this._proxy.$registerSourceControl(this._handle, _id, _label);
+	}
+
+	createResourceGroup(id: string, label: string): ExtHostSourceControlResourceGroup {
+		return new ExtHostSourceControlResourceGroup(this._proxy, this._commands, this._handle, id, label);
+	}
+
+	dispose(): void {
+		this._proxy.$unregisterSourceControl(this._handle);
+	}
+}
+
 type ProviderHandle = number;
 
 export class ExtHostSCM {
@@ -74,112 +201,45 @@ export class ExtHostSCM {
 	private static _handlePool: number = 0;
 
 	private _proxy: MainThreadSCMShape;
-	private _providers: Map<ProviderHandle, vscode.SCMProvider> = new Map<ProviderHandle, vscode.SCMProvider>();
-	private _cache: Map<ProviderHandle, Map<string, vscode.SCMResource>> = new Map<ProviderHandle, Map<string, vscode.SCMResource>>();
+	private _sourceControls: Map<ProviderHandle, vscode.SourceControl> = new Map<ProviderHandle, vscode.SourceControl>();
 
-	private _onDidChangeActiveProvider = new Emitter<vscode.SCMProvider>();
-	get onDidChangeActiveProvider(): Event<vscode.SCMProvider> { return this._onDidChangeActiveProvider.event; }
+	private _onDidChangeActiveProvider = new Emitter<vscode.SourceControl>();
+	get onDidChangeActiveProvider(): Event<vscode.SourceControl> { return this._onDidChangeActiveProvider.event; }
 
-	private _activeProvider: vscode.SCMProvider | undefined;
-	get activeProvider(): vscode.SCMProvider | undefined { return this._activeProvider; }
+	private _activeProvider: vscode.SourceControl | undefined;
+	get activeProvider(): vscode.SourceControl | undefined { return this._activeProvider; }
 
 	private _inputBox: ExtHostSCMInputBox;
 	get inputBox(): ExtHostSCMInputBox { return this._inputBox; }
 
-	constructor(threadService: IThreadService) {
+	constructor(
+		threadService: IThreadService,
+		private _commands: ExtHostCommands
+	) {
 		this._proxy = threadService.get(MainContext.MainThreadSCM);
 		this._inputBox = new ExtHostSCMInputBox(this._proxy);
 	}
 
-	registerSCMProvider(provider: vscode.SCMProvider): Disposable {
+	createSourceControl(id: string, label: string): vscode.SourceControl {
 		const handle = ExtHostSCM._handlePool++;
+		const sourceControl = new ExtHostSourceControl(this._proxy, this._commands.converter, id, label);
+		this._sourceControls.set(handle, sourceControl);
 
-		this._providers.set(handle, provider);
-
-		this._proxy.$register(handle, {
-			label: provider.label,
-			contextKey: provider.contextKey,
-			supportsOpen: !!provider.open,
-			supportsOriginalResource: !!provider.provideOriginalResource
-		});
-
-		const onDidChange = debounceEvent(provider.onDidChange || createEmptyEvent<vscode.SCMProvider>(), (l, e) => e, 100);
-		const onDidChangeListener = onDidChange(scmProvider => {
-			const cache = new Map<string, vscode.SCMResource>();
-			this._cache.set(handle, cache);
-
-			const rawResourceGroups = scmProvider.resources.map(g => {
-				const rawResources = g.resources.map(r => {
-					const uri = r.uri.toString();
-					cache.set(uri, r);
-
-					const sourceUri = r.sourceUri.toString();
-					const iconPath = getIconPath(r.decorations);
-					const lightIconPath = r.decorations && getIconPath(r.decorations.light) || iconPath;
-					const darkIconPath = r.decorations && getIconPath(r.decorations.dark) || iconPath;
-					const icons: string[] = [];
-
-					if (lightIconPath || darkIconPath) {
-						icons.push(lightIconPath);
-					}
-
-					if (darkIconPath !== lightIconPath) {
-						icons.push(darkIconPath);
-					}
-
-					const strikeThrough = r.decorations && !!r.decorations.strikeThrough;
-
-					return [uri, sourceUri, icons, strikeThrough] as SCMRawResource;
-				});
-
-				return [g.uri.toString(), g.contextKey, g.label, rawResources] as SCMRawResourceGroup;
-			});
-
-			this._proxy.$onChange(handle, rawResourceGroups, provider.count, provider.stateContextKey);
-		});
-
-		return new Disposable(() => {
-			onDidChangeListener.dispose();
-			this._providers.delete(handle);
-			this._proxy.$unregister(handle);
-		});
+		return sourceControl;
 	}
 
-	$open(handle: number, uri: string): TPromise<void> {
-		const provider = this._providers.get(handle);
+	$provideOriginalResource(sourceControlHandle: number, uri: URI): TPromise<URI> {
+		const sourceControl = this._sourceControls.get(sourceControlHandle);
 
-		if (!provider) {
+		if (!sourceControl || !sourceControl.quickDiffProvider) {
 			return TPromise.as(null);
 		}
 
-		const cache = this._cache.get(handle);
-
-		if (!cache) {
-			return TPromise.as(null);
-		}
-
-		const resource = cache.get(uri);
-
-		if (!resource) {
-			return TPromise.as(null);
-		}
-
-		provider.open(resource);
-		return TPromise.as(null);
+		return asWinJsPromise(token => sourceControl.quickDiffProvider.provideOriginalResource(uri, token));
 	}
 
-	$getOriginalResource(handle: number, uri: URI): TPromise<URI> {
-		const provider = this._providers.get(handle);
-
-		if (!provider) {
-			return TPromise.as(null);
-		}
-
-		return asWinJsPromise(token => provider.provideOriginalResource(uri, token));
-	}
-
-	$onActiveProviderChange(handle: number): TPromise<void> {
-		this._activeProvider = this._providers.get(handle);
+	$onActiveSourceControlChange(handle: number): TPromise<void> {
+		this._activeProvider = this._sourceControls.get(handle);
 		return TPromise.as(null);
 	}
 
diff --git a/src/vs/workbench/api/node/mainThreadSCM.ts b/src/vs/workbench/api/node/mainThreadSCM.ts
index 608e598a3a4..f3cc5c8547a 100644
--- a/src/vs/workbench/api/node/mainThreadSCM.ts
+++ b/src/vs/workbench/api/node/mainThreadSCM.ts
@@ -7,154 +7,223 @@
 import { TPromise } from 'vs/base/common/winjs.base';
 import URI from 'vs/base/common/uri';
 import Event, { Emitter } from 'vs/base/common/event';
-import { onUnexpectedError } from 'vs/base/common/errors';
+import { assign } from 'vs/base/common/objects';
 import { IDisposable, dispose } from 'vs/base/common/lifecycle';
 import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
 import { ISCMService, ISCMProvider, ISCMResource, ISCMResourceGroup } from 'vs/workbench/services/scm/common/scm';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { ICommandService } from 'vs/platform/commands/common/commands';
-import { ExtHostContext, MainThreadSCMShape, ExtHostSCMShape, SCMProviderFeatures, SCMRawResourceGroup } from './extHost.protocol';
+import { ExtHostContext, MainThreadSCMShape, ExtHostSCMShape, SCMProviderFeatures, SCMRawResource, SCMGroupFeatures } from './extHost.protocol';
+
+interface IMainThreadSCMResourceGroup {
+	uri: URI;
+	features: SCMGroupFeatures;
+	label: string;
+	contextKey?: string;
+	resources: ISCMResource[];
+}
 
 class MainThreadSCMProvider implements ISCMProvider {
 
-	private _resources: ISCMResourceGroup[] = [];
-	get resources(): ISCMResourceGroup[] { return this._resources; }
+	private _groups: IMainThreadSCMResourceGroup[] = [];
+	private _groupsByHandle: { [handle: number]: IMainThreadSCMResourceGroup; } = Object.create(null);
 
-	private _onDidChange = new Emitter<ISCMResourceGroup[]>();
-	get onDidChange(): Event<ISCMResourceGroup[]> { return this._onDidChange.event; }
+	get resources(): ISCMResourceGroup[] {
+		return this._groups
+			.filter(g => g.resources.length > 0 || !g.features.hideWhenEmpty);
+	}
 
-	private disposables: IDisposable[] = [];
+	private _onDidChange = new Emitter<void>();
+	get onDidChange(): Event<void> { return this._onDidChange.event; }
+
+	private features: SCMProviderFeatures = {};
 
 	get handle(): number { return this._handle; }
-	get label(): string { return this.features.label; }
-	get contextKey(): string { return this.features.contextKey; }
+	get label(): string { return this._label; }
+	get contextKey(): string { return this._id; }
 
 	private _count: number | undefined = undefined;
 	get count(): number | undefined { return this._count; }
 
-	private _stateContextKey: string | undefined = undefined;
-	get stateContextKey(): string | undefined { return this._stateContextKey; }
-
 	constructor(
-		private _handle: number,
 		private proxy: ExtHostSCMShape,
-		private features: SCMProviderFeatures,
+		private _handle: number,
+		private _id: string,
+		private _label: string,
 		@ISCMService scmService: ISCMService,
 		@ICommandService private commandService: ICommandService
-	) {
-		scmService.onDidChangeProvider(this.onDidChangeProvider, this, this.disposables);
+	) { }
+
+	$updateSourceControl(features: SCMProviderFeatures): void {
+		this.features = assign(this.features, features);
+		this._onDidChange.fire();
 	}
 
-	open(resource: ISCMResource): void {
-		if (!this.features.supportsOpen) {
+	$registerGroup(handle: number, id: string, label: string): void {
+		const group: IMainThreadSCMResourceGroup = {
+			contextKey: id,
+			label,
+			uri: null,
+			resources: [],
+			features: {}
+		};
+
+		this._groups.push(group);
+		this._groupsByHandle[handle] = group;
+	}
+
+	$updateGroup(handle: number, features: SCMGroupFeatures): void {
+		const group = this._groupsByHandle[handle];
+
+		if (!group) {
 			return;
 		}
 
-		this.proxy.$open(this.handle, resource.uri.toString())
-			.done(null, onUnexpectedError);
+		group.features = assign(group.features, features);
+		this._onDidChange.fire();
+	}
+
+	$updateGroupResourceStates(handle: number, resources: SCMRawResource[]): void {
+		const group = this._groupsByHandle[handle];
+
+		if (!group) {
+			return;
+		}
+
+		group.resources = resources.map(rawResource => {
+			const [sourceUri, command, icons, strikeThrough] = rawResource;
+			const icon = icons[0];
+			const iconDark = icons[1] || icon;
+			const decorations = {
+				icon: icon && URI.parse(icon),
+				iconDark: iconDark && URI.parse(iconDark),
+				strikeThrough
+			};
+
+			return {
+				sourceUri: URI.parse(sourceUri),
+				command,
+				resourceGroup: group,
+				decorations
+			};
+		});
+
+		this._onDidChange.fire();
+	}
+
+	$unregisterGroup(handle: number): void {
+		const group = this._groupsByHandle[handle];
+
+		if (!group) {
+			return;
+		}
+
+		delete this._groupsByHandle[handle];
+		this._groups.splice(this._groups.indexOf(group), 1);
 	}
 
 	getOriginalResource(uri: URI): TPromise<URI> {
-		if (!this.features.supportsOriginalResource) {
+		if (!this.features.hasQuickDiffProvider) {
 			return TPromise.as(null);
 		}
 
-		return this.proxy.$getOriginalResource(this.handle, uri);
-	}
-
-	private onDidChangeProvider(provider: ISCMProvider): void {
-		// if (provider === this) {
-		// 	return
-		// }
-	}
-
-	$onChange(rawResourceGroups: SCMRawResourceGroup[], count: number | undefined, stateContextKey: string | undefined): void {
-		this._resources = rawResourceGroups.map(rawGroup => {
-			const [uri, contextKey, label, rawResources] = rawGroup;
-			const resources: ISCMResource[] = [];
-			const group: ISCMResourceGroup = { uri: URI.parse(uri), contextKey, label, resources };
-
-			rawResources.forEach(rawResource => {
-				const [uri, sourceUri, icons, strikeThrough] = rawResource;
-				const icon = icons[0];
-				const iconDark = icons[1] || icon;
-				const decorations = {
-					icon: icon && URI.parse(icon),
-					iconDark: iconDark && URI.parse(iconDark),
-					strikeThrough
-				};
-
-				resources.push({
-					resourceGroup: group,
-					uri: URI.parse(uri),
-					sourceUri: URI.parse(sourceUri),
-					decorations
-				});
-			});
-
-			return group;
-		});
-
-		this._count = count;
-		this._stateContextKey = stateContextKey;
-
-		this._onDidChange.fire(this.resources);
+		return this.proxy.$provideOriginalResource(this.handle, uri);
 	}
 
 	dispose(): void {
-		this.disposables = dispose(this.disposables);
+
 	}
 }
 
 export class MainThreadSCM extends MainThreadSCMShape {
 
-	private proxy: ExtHostSCMShape;
-	private providers: { [handle: number]: MainThreadSCMProvider; } = Object.create(null);
-	private providerDisposables: { [handle: number]: IDisposable; } = Object.create(null);
-
-	private disposables: IDisposable[] = [];
+	private _proxy: ExtHostSCMShape;
+	private _sourceControls: { [handle: number]: MainThreadSCMProvider; } = Object.create(null);
+	private _sourceControlDisposables: { [handle: number]: IDisposable; } = Object.create(null);
+	private _disposables: IDisposable[] = [];
 
 	constructor(
 		@IThreadService threadService: IThreadService,
 		@IInstantiationService private instantiationService: IInstantiationService,
-		@ISCMService private scmService: ISCMService
+		@ISCMService private scmService: ISCMService,
+		@ICommandService private commandService: ICommandService
 	) {
 		super();
-		this.proxy = threadService.get(ExtHostContext.ExtHostSCM);
+		this._proxy = threadService.get(ExtHostContext.ExtHostSCM);
 
-		this.scmService.onDidChangeProvider(this.onDidChangeProvider, this, this.disposables);
-		this.scmService.input.onDidChange(this.proxy.$onInputBoxValueChange, this.proxy, this.disposables);
-		this.scmService.input.onDidAccept(this.proxy.$onInputBoxAcceptChanges, this.proxy, this.disposables);
+		this.scmService.onDidChangeProvider(this.onDidChangeProvider, this, this._disposables);
+		this.scmService.input.onDidChange(this._proxy.$onInputBoxValueChange, this._proxy, this._disposables);
+		this.scmService.input.onDidAccept(this._proxy.$onInputBoxAcceptChanges, this._proxy, this._disposables);
 	}
 
-	$register(handle: number, features: SCMProviderFeatures): void {
-		const provider = this.instantiationService.createInstance(MainThreadSCMProvider, handle, this.proxy, features);
-		this.providers[handle] = provider;
-		this.providerDisposables[handle] = this.scmService.registerSCMProvider(provider);
+	$registerSourceControl(handle: number, id: string, label: string): void {
+		const provider = new MainThreadSCMProvider(this._proxy, handle, id, label, this.scmService, this.commandService);
+		this._sourceControls[handle] = provider;
+		this._sourceControlDisposables[handle] = this.scmService.registerSCMProvider(provider);
 	}
 
-	$unregister(handle: number): void {
-		const provider = this.providers[handle];
+	$updateSourceControl(handle: number, features: SCMProviderFeatures): void {
+		const sourceControl = this._sourceControls[handle];
+
+		if (!sourceControl) {
+			return;
+		}
+
+		sourceControl.$updateSourceControl(features);
+	}
+
+	$unregisterSourceControl(handle: number): void {
+		const sourceControl = this._sourceControls[handle];
+
+		if (!sourceControl) {
+			return;
+		}
+
+		this._sourceControlDisposables[handle].dispose();
+		delete this._sourceControlDisposables[handle];
+
+		sourceControl.dispose();
+		delete this._sourceControls[handle];
+	}
+
+	$registerGroup(sourceControlHandle: number, groupHandle: number, id: string, label: string): void {
+		const provider = this._sourceControls[sourceControlHandle];
 
 		if (!provider) {
 			return;
 		}
 
-		this.providerDisposables[handle].dispose();
-		delete this.providerDisposables[handle];
-
-		provider.dispose();
-		delete this.providers[handle];
+		provider.$registerGroup(groupHandle, id, label);
 	}
 
-	$onChange(handle: number, rawResourceGroups: SCMRawResourceGroup[], count: number | undefined, state: string | undefined): void {
-		const provider = this.providers[handle];
+	$updateGroup(sourceControlHandle: number, groupHandle: number, features: SCMGroupFeatures): void {
+		const provider = this._sourceControls[sourceControlHandle];
 
 		if (!provider) {
 			return;
 		}
 
-		provider.$onChange(rawResourceGroups, count, state);
+		provider.$updateGroup(groupHandle, features);
+	}
+
+	$updateGroupResourceStates(sourceControlHandle: number, groupHandle: number, resources: SCMRawResource[]): void {
+		const provider = this._sourceControls[sourceControlHandle];
+
+		if (!provider) {
+			return;
+		}
+
+		provider.$updateGroupResourceStates(groupHandle, resources);
+	}
+
+	$unregisterGroup(sourceControlHandle: number, handle: number): void {
+		const provider = this._sourceControls[sourceControlHandle];
+
+		if (!provider) {
+			return;
+		}
+
+		provider.$unregisterGroup(handle);
 	}
 
 	$setInputBoxValue(value: string): void {
@@ -162,15 +231,15 @@ export class MainThreadSCM extends MainThreadSCMShape {
 	}
 
 	private onDidChangeProvider(provider: ISCMProvider): void {
-		const handle = Object.keys(this.providers).filter(handle => this.providers[handle] === provider)[0];
-		this.proxy.$onActiveProviderChange(handle && parseInt(handle));
+		const handle = Object.keys(this._sourceControls).filter(handle => this._sourceControls[handle] === provider)[0];
+		this._proxy.$onActiveSourceControlChange(handle && parseInt(handle));
 	}
 
 	dispose(): void {
-		Object.keys(this.providers)
-			.forEach(id => this.providers[id].dispose());
+		Object.keys(this._sourceControls)
+			.forEach(id => this._sourceControls[id].dispose());
 
-		this.providers = Object.create(null);
-		this.disposables = dispose(this.disposables);
+		this._sourceControls = Object.create(null);
+		this._disposables = dispose(this._disposables);
 	}
 }
diff --git a/src/vs/workbench/parts/git/browser/gitScm.ts b/src/vs/workbench/parts/git/browser/gitScm.ts
index c88455979c7..a3b921b5889 100644
--- a/src/vs/workbench/parts/git/browser/gitScm.ts
+++ b/src/vs/workbench/parts/git/browser/gitScm.ts
@@ -25,8 +25,8 @@ export class GitSCMProvider implements IWorkbenchContribution, ISCMProvider, ITe
 	get label() { return 'Git'; }
 	get resources() { return []; }
 
-	private _onDidChange = new Emitter<ISCMResourceGroup[]>();
-	get onDidChange(): Event<ISCMResourceGroup[]> {
+	private _onDidChange = new Emitter<void>();
+	get onDidChange(): Event<void> {
 		return this._onDidChange.event;
 	}
 
diff --git a/src/vs/workbench/parts/scm/electron-browser/scmViewlet.ts b/src/vs/workbench/parts/scm/electron-browser/scmViewlet.ts
index cf053ed089a..5d05d0e93e8 100644
--- a/src/vs/workbench/parts/scm/electron-browser/scmViewlet.ts
+++ b/src/vs/workbench/parts/scm/electron-browser/scmViewlet.ts
@@ -9,6 +9,7 @@ import 'vs/css!./media/scmViewlet';
 import { localize } from 'vs/nls';
 import { TPromise } from 'vs/base/common/winjs.base';
 import { chain } from 'vs/base/common/event';
+import { onUnexpectedError } from 'vs/base/common/errors';
 import * as platform from 'vs/base/common/platform';
 import { domEvent } from 'vs/base/browser/event';
 import { IDisposable, dispose, empty as EmptyDisposable } from 'vs/base/common/lifecycle';
@@ -27,6 +28,7 @@ import { ISCMService, ISCMProvider, ISCMResourceGroup, ISCMResource } from 'vs/w
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { IContextViewService, IContextMenuService } from 'vs/platform/contextview/browser/contextView';
 import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
+import { ICommandService } from 'vs/platform/commands/common/commands';
 import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding';
 import { IMessageService } from 'vs/platform/message/common/message';
 import { IListService } from 'vs/platform/list/browser/listService';
@@ -203,7 +205,8 @@ export class SCMViewlet extends Viewlet {
 		@IContextMenuService private contextMenuService: IContextMenuService,
 		@IThemeService protected themeService: IThemeService,
 		@IMenuService private menuService: IMenuService,
-		@IModelService private modelService: IModelService
+		@IModelService private modelService: IModelService,
+		@ICommandService private commandService: ICommandService
 	) {
 		super(VIEWLET_ID, telemetryService, themeService);
 
@@ -321,7 +324,8 @@ export class SCMViewlet extends Viewlet {
 	}
 
 	private open(e: ISCMResource): void {
-		this.scmService.activeProvider.open(e);
+		this.commandService.executeCommand(e.command.id, ...e.command.arguments)
+			.done(undefined, onUnexpectedError);
 	}
 
 	getActions(): IAction[] {
diff --git a/src/vs/workbench/services/scm/common/scm.ts b/src/vs/workbench/services/scm/common/scm.ts
index b96ed8dfd85..3cfcce36383 100644
--- a/src/vs/workbench/services/scm/common/scm.ts
+++ b/src/vs/workbench/services/scm/common/scm.ts
@@ -10,6 +10,7 @@ import URI from 'vs/base/common/uri';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
 import Event from 'vs/base/common/event';
 import { IDisposable } from 'vs/base/common/lifecycle';
+import { Command } from 'vs/editor/common/modes';
 
 export interface IBaselineResourceProvider {
 	getBaselineResource(resource: URI): TPromise<URI>;
@@ -24,14 +25,15 @@ export interface ISCMResourceDecorations {
 }
 
 export interface ISCMResource {
+	// readonly uri: URI;
 	readonly resourceGroup: ISCMResourceGroup;
-	readonly uri: URI;
 	readonly sourceUri: URI;
+	readonly command: Command;
 	readonly decorations: ISCMResourceDecorations;
 }
 
 export interface ISCMResourceGroup {
-	readonly uri: URI;
+	// readonly uri: URI;
 	readonly label: string;
 	readonly contextKey?: string;
 	readonly resources: ISCMResource[];
@@ -41,11 +43,10 @@ export interface ISCMProvider extends IDisposable {
 	readonly label: string;
 	readonly contextKey?: string;
 	readonly resources: ISCMResourceGroup[];
-	readonly onDidChange: Event<ISCMResourceGroup[]>;
+	// TODO: Event<void>
+	readonly onDidChange: Event<void>;
 	readonly count?: number;
-	readonly stateContextKey?: string;
 
-	open(uri: ISCMResource): void;
 	getOriginalResource(uri: URI): TPromise<URI>;
 }
 
diff --git a/src/vs/workbench/services/scm/common/scmService.ts b/src/vs/workbench/services/scm/common/scmService.ts
index 7e24d418b8a..e6299424ed3 100644
--- a/src/vs/workbench/services/scm/common/scmService.ts
+++ b/src/vs/workbench/services/scm/common/scmService.ts
@@ -41,7 +41,6 @@ export class SCMService implements ISCMService {
 
 	private providerChangeDisposable: IDisposable = EmptyDisposable;
 	private activeProviderContextKey: IContextKey<string | undefined>;
-	private activeProviderStateContextKey: IContextKey<string | undefined>;
 
 	private _activeProvider: ISCMProvider | undefined;
 
@@ -62,8 +61,6 @@ export class SCMService implements ISCMService {
 		this.activeProviderContextKey.set(provider ? provider.contextKey : void 0);
 
 		this.providerChangeDisposable.dispose();
-		this.providerChangeDisposable = provider.onDidChange(this.onDidChangeProviderState, this);
-		this.onDidChangeProviderState();
 
 		this._onDidChangeProvider.fire(provider);
 	}
@@ -81,7 +78,6 @@ export class SCMService implements ISCMService {
 		@IContextKeyService contextKeyService: IContextKeyService
 	) {
 		this.activeProviderContextKey = contextKeyService.createKey<string | undefined>('scmProvider', void 0);
-		this.activeProviderStateContextKey = contextKeyService.createKey<string | undefined>('scmProviderState', void 0);
 	}
 
 	registerSCMProvider(provider: ISCMProvider): IDisposable {
@@ -105,8 +101,4 @@ export class SCMService implements ISCMService {
 			}
 		});
 	}
-
-	private onDidChangeProviderState(): void {
-		this.activeProviderStateContextKey.set(this.activeProvider.stateContextKey);
-	}
 }
\ No newline at end of file