diff --git a/keymaps/git.cson b/keymaps/git.cson
index 81abdfa803..98e30a2427 100644
--- a/keymaps/git.cson
+++ b/keymaps/git.cson
@@ -1,6 +1,6 @@
 '.workspace':
-  'ctrl-9': 'github:toggle-git-panel'
-  'ctrl-(': 'github:toggle-git-panel-focus' # ctrl-shift-9
+  'ctrl-9': 'github:toggle-git-tab'
+  'ctrl-(': 'github:toggle-git-tab-focus' # ctrl-shift-9
 
 '.github-Panel':
   'cmd-enter': 'github:commit'
diff --git a/lib/controllers/commit-view-controller.js b/lib/controllers/commit-view-controller.js
index 5d63054aa2..e75762f698 100644
--- a/lib/controllers/commit-view-controller.js
+++ b/lib/controllers/commit-view-controller.js
@@ -71,8 +71,8 @@ export default class CommitViewController {
     let message = this.regularCommitMessage;
     if (this.props.isAmending) {
       message = this.amendingCommitMessage;
-      if (!message.length && this.props.lastCommit) {
-        message = this.props.lastCommit.message;
+      if (!message.length && this.props.lastCommit.isPresent()) {
+        message = this.props.lastCommit.getMessage();
       }
     } else if (!message.length && this.props.mergeMessage) {
       message = this.props.mergeMessage;
diff --git a/lib/controllers/file-patch-controller.js b/lib/controllers/file-patch-controller.js
index d8abe05648..2722869510 100644
--- a/lib/controllers/file-patch-controller.js
+++ b/lib/controllers/file-patch-controller.js
@@ -10,7 +10,8 @@ import FilePatchView from '../views/file-patch-view';
 
 export default class FilePatchController extends React.Component {
   static propTypes = {
-    repository: PropTypes.object,
+    activeWorkingDirectory: PropTypes.string,
+    repository: PropTypes.object.isRequired,
     commandRegistry: PropTypes.object.isRequired,
     filePatch: PropTypes.object.isRequired,
     stagingStatus: PropTypes.oneOf(['unstaged', 'staged']).isRequired,
@@ -223,6 +224,13 @@ export default class FilePatchController extends React.Component {
     return this.props.repository.hasDiscardHistory(this.props.filePatch.getPath());
   }
 
+  /**
+   * Used to detect the context when this PaneItem is active
+   */
+  getWorkingDirectory() {
+    return this.props.activeWorkingDirectory;
+  }
+
   destroy() {
     this.emitter.emit('did-destroy');
   }
diff --git a/lib/controllers/git-tab-controller.js b/lib/controllers/git-tab-controller.js
index 96e30e5a28..6f043a970a 100644
--- a/lib/controllers/git-tab-controller.js
+++ b/lib/controllers/git-tab-controller.js
@@ -6,6 +6,8 @@ import etch from 'etch';
 
 import GitTabView from '../views/git-tab-view';
 import ModelObserver from '../models/model-observer';
+import {nullBranch} from '../models/branch';
+import {nullCommit} from '../models/commit';
 import {autobind} from 'core-decorators';
 import yubikiri from 'yubikiri';
 
@@ -18,7 +20,7 @@ export default class GitTabController {
       fetchData: this.fetchRepositoryData,
       didUpdate: () => {
         this.refreshResolutionProgress(false, false);
-        return etch.update(this);
+        return this.update();
       },
     });
     this.repositoryObserver.setActiveModel(props.repository);
@@ -32,11 +34,11 @@ export default class GitTabController {
   }
 
   render() {
-    const modelData = this.repositoryObserver.getActiveModelData() || {fetchInProgress: true};
+    const modelData = this.repositoryObserver.getActiveModelData() || this.defaultRepositoryData();
     const hasUndoHistory = this.props.repository ? this.hasUndoHistory() : false;
     return (
       <GitTabView
-        ref="gitPanel"
+        ref="gitTab"
         {...modelData}
         repository={this.props.repository}
         resolutionProgress={this.props.resolutionProgress}
@@ -133,9 +135,25 @@ export default class GitTabController {
         const isMerging = await query.isMerging;
         return isMerging ? repository.getMergeMessage() : null;
       },
+      fetchInProgress: Promise.resolve(false),
     });
   }
 
+  defaultRepositoryData() {
+    return {
+      lastCommit: nullCommit,
+      isMerging: false,
+      isRebasing: false,
+      currentBranch: nullBranch,
+      unstagedChanges: [],
+      stagedChanges: [],
+      mergeConflicts: [],
+      workingDirectoryPath: this.props.repository.getWorkingDirectoryPath(),
+      mergeMessage: null,
+      fetchInProgress: true,
+    };
+  }
+
   fetchStagedChanges(repository) {
     if (this.props.isAmending) {
       return repository.getStagedChangesSinceParentCommit();
@@ -190,7 +208,7 @@ export default class GitTabController {
 
     this.stagingOperationInProgress = true;
 
-    const fileListUpdatePromise = this.refs.gitPanel.refs.stagingView.getNextListUpdatePromise();
+    const fileListUpdatePromise = this.refs.gitTab.refs.stagingView.getNextListUpdatePromise();
     let stageOperationPromise;
     if (stageStatus === 'staged') {
       stageOperationPromise = this.unstageFiles(filePaths);
@@ -233,7 +251,7 @@ export default class GitTabController {
 
   @autobind
   async prepareToCommit() {
-    return !await this.props.ensureGitPanel();
+    return !await this.props.ensureGitTab();
   }
 
   @autobind
@@ -275,6 +293,8 @@ export default class GitTabController {
           `Cannot abort because ${e.path} is both dirty and staged.`,
           {dismissable: true},
         );
+      } else {
+        throw e;
       }
     }
     return etch.update(this);
@@ -308,20 +328,20 @@ export default class GitTabController {
   }
 
   focus() {
-    this.refs.gitPanel.focus();
+    this.refs.gitTab.focus();
   }
 
   focusAndSelectStagingItem(filePath, stagingStatus) {
-    return this.refs.gitPanel.focusAndSelectStagingItem(filePath, stagingStatus);
+    return this.refs.gitTab.focusAndSelectStagingItem(filePath, stagingStatus);
   }
 
   isFocused() {
-    return this.refs.gitPanel.isFocused();
+    return this.refs.gitTab.isFocused();
   }
 
   @autobind
   quietlySelectItem(filePath, stagingStatus) {
-    return this.refs.gitPanel.quitelySelectItem(filePath, stagingStatus);
+    return this.refs.gitTab.quitelySelectItem(filePath, stagingStatus);
   }
 
   @autobind
diff --git a/lib/controllers/github-tab-controller.js b/lib/controllers/github-tab-controller.js
index f15655db05..eff2da6f35 100644
--- a/lib/controllers/github-tab-controller.js
+++ b/lib/controllers/github-tab-controller.js
@@ -4,7 +4,6 @@ import {autobind} from 'core-decorators';
 import yubikiri from 'yubikiri';
 
 import RemotePrController from './remote-pr-controller';
-import Repository from '../models/repository';
 import GithubLoginModel from '../models/github-login-model';
 import ObserveModel from '../views/observe-model';
 import {RemotePropType} from '../prop-types';
@@ -27,9 +26,9 @@ class RemoteSelector extends React.Component {
         </p>
         <ul>
           {remotes.map(remote => (
-            <li key={remote.name}>
+            <li key={remote.getName()}>
               <a href="#" onClick={e => selectRemote(e, remote)}>
-                {remote.name} ({remote.info.owner}/{remote.info.name})
+                {remote.getName()} ({remote.getOwner()}/{remote.getRepo()})
               </a>
             </li>
           ))}
@@ -51,12 +50,9 @@ export default class GithubTabController extends React.Component {
 
   fetchModelData(repo) {
     return yubikiri({
-      remotes: repo.getRemotes().then(remotes => {
-        return remotes.map(({name, url}) => ({name, url, info: Repository.githubInfoFromRemote(url)}))
-          .filter(remote => remote.info.githubRepo);
-      }),
+      remotes: repo.getRemotes().then(remotes => remotes.filter(remote => remote.isGithubRepo())),
       currentBranch: repo.getCurrentBranch(),
-      selectedRemote: repo.getConfig('atomGithub.currentRemote'),
+      selectedRemoteName: repo.getConfig('atomGithub.currentRemote'),
     });
   }
 
@@ -75,15 +71,15 @@ export default class GithubTabController extends React.Component {
   }
 
   renderWithData({remotes, currentBranch, selectedRemote}) {
-    if (!this.props.repository || !remotes) {
+    if (!this.props.repository.isPresent() || !remotes) {
       return null;
     }
 
-    if (!currentBranch || currentBranch.isDetached) {
+    if (!currentBranch.isPresent() || currentBranch.isDetached()) {
       return null;
     }
 
-    let remote = remotes.find(r => r.name === selectedRemote);
+    let remote = remotes.find(r => r.getName() === selectedRemote);
     let manyRemotesAvailable = false;
     if (!remote && remotes.length === 1) {
       remote = remotes[0];
@@ -100,13 +96,13 @@ export default class GithubTabController extends React.Component {
               host="https://api.github.com"
               loginModel={this.loginModel}
               remote={remote}
-              currentBranchName={currentBranch.name}
+              currentBranchName={currentBranch.getName()}
             />
           }
           {!remote && manyRemotesAvailable &&
             <RemoteSelector
               remotes={remotes}
-              currentBranchName={currentBranch.name}
+              currentBranchName={currentBranch.getName()}
               selectRemote={this.handleRemoteSelect}
             />
           }
@@ -147,6 +143,6 @@ export default class GithubTabController extends React.Component {
   @autobind
   handleRemoteSelect(e, remote) {
     e.preventDefault();
-    this.props.repository.setConfig('atomGithub.currentRemote', remote.name);
+    this.props.repository.setConfig('atomGithub.currentRemote', remote.getName());
   }
 }
diff --git a/lib/controllers/pr-info-controller.js b/lib/controllers/pr-info-controller.js
index 62c461271e..b61a6eccd2 100644
--- a/lib/controllers/pr-info-controller.js
+++ b/lib/controllers/pr-info-controller.js
@@ -24,7 +24,7 @@ export default class PrInfoController extends React.Component {
   shouldComponentUpdate(nextProps) {
     return (
       nextProps.token !== this.props.token ||
-      nextProps.hsot !== this.props.host ||
+      nextProps.host !== this.props.host ||
       nextProps.currentBranchName !== this.props.currentBranchName ||
       nextProps.onLogin !== this.props.onLogin ||
       nextProps.remote !== this.props.remote
@@ -39,8 +39,8 @@ export default class PrInfoController extends React.Component {
     }
 
     const route = new PrInfoByBranchRoute({
-      repoOwner: this.props.remote.info.owner,
-      repoName: this.props.remote.info.name,
+      repoOwner: this.props.remote.getOwner(),
+      repoName: this.props.remote.getName(),
       branchName: this.props.currentBranchName,
     });
 
diff --git a/lib/controllers/remote-pr-controller.js b/lib/controllers/remote-pr-controller.js
index 5c2f64f38a..c2a2fd4acc 100644
--- a/lib/controllers/remote-pr-controller.js
+++ b/lib/controllers/remote-pr-controller.js
@@ -7,6 +7,7 @@ import {RemotePropType} from '../prop-types';
 import ObserveModelDecorator from '../decorators/observe-model';
 import GithubLoginView from '../views/github-login-view';
 import {UNAUTHENTICATED} from '../models/github-login-model';
+import {nullRemote} from '../models/remote';
 import PrInfoController from './pr-info-controller';
 
 @ObserveModelDecorator({
@@ -31,6 +32,7 @@ export default class RemotePrController extends React.Component {
 
   static defaultProps = {
     host: 'https://api.github.com',
+    remote: nullRemote,
     token: null,
   }
 
diff --git a/lib/controllers/repository-conflict-controller.js b/lib/controllers/repository-conflict-controller.js
index 965a0bb1aa..530f8f114f 100644
--- a/lib/controllers/repository-conflict-controller.js
+++ b/lib/controllers/repository-conflict-controller.js
@@ -25,16 +25,15 @@ export default class RepositoryConflictController extends React.Component {
   static propTypes = {
     workspace: PropTypes.object.isRequired,
     commandRegistry: PropTypes.object.isRequired,
-    resolutionProgress: PropTypes.object,
-    repository: PropTypes.object,
-    workingDirectoryPath: PropTypes.string,
+    resolutionProgress: PropTypes.object.isRequired,
+    repository: PropTypes.object.isRequired,
     mergeConflictPaths: PropTypes.arrayOf(PropTypes.string),
     isRebasing: PropTypes.bool,
     refreshResolutionProgress: PropTypes.func,
   };
 
   static defaultProps = {
-    resolutionProgress: ResolutionProgress.empty(),
+    resolutionProgress: new ResolutionProgress(),
     mergeConflictPaths: [],
     isRebasing: false,
     refreshResolutionProgress: () => {},
@@ -76,14 +75,13 @@ export default class RepositoryConflictController extends React.Component {
 
   getConflictingEditors() {
     if (
-      !this.props.workingDirectoryPath ||
       this.props.mergeConflictPaths.length === 0 ||
       this.state.openEditors.length === 0
     ) {
       return [];
     }
 
-    const commonBasePath = this.props.workingDirectoryPath;
+    const commonBasePath = this.props.repository.getWorkingDirectoryPath();
     const fullMergeConflictPaths = new Set(
       this.props.mergeConflictPaths.map(relativePath => path.join(commonBasePath, relativePath)),
     );
diff --git a/lib/controllers/root-controller.js b/lib/controllers/root-controller.js
index 1de2800792..6a2c88c527 100644
--- a/lib/controllers/root-controller.js
+++ b/lib/controllers/root-controller.js
@@ -16,6 +16,7 @@ import DockItem from '../views/dock-item';
 import Resizer from '../views/resizer';
 import Tabs from '../views/tabs';
 import CloneDialog from '../views/clone-dialog';
+import InitDialog from '../views/init-dialog';
 import CredentialDialog from '../views/credential-dialog';
 import Commands, {Command} from '../views/commands';
 import GithubTabController from './github-tab-controller';
@@ -45,11 +46,11 @@ export default class RootController extends React.Component {
     tooltips: PropTypes.object.isRequired,
     config: PropTypes.object.isRequired,
     confirm: PropTypes.func.isRequired,
-    activeProjectPath: PropTypes.string,
+    activeWorkingDirectory: PropTypes.string,
     createRepositoryForProjectPath: PropTypes.func,
     cloneRepositoryForProjectPath: PropTypes.func,
-    repository: PropTypes.object,
-    resolutionProgress: PropTypes.object,
+    repository: PropTypes.object.isRequired,
+    resolutionProgress: PropTypes.object.isRequired,
     statusBar: PropTypes.object,
     switchboard: PropTypes.instanceOf(Switchboard),
     savedState: PropTypes.object,
@@ -64,7 +65,7 @@ export default class RootController extends React.Component {
 
   serialize() {
     return {
-      gitPanelActive: this.state.gitPanelActive,
+      gitTabActive: this.state.gitTabActive,
       githubPanelActive: this.state.githubPanelActive,
       panelSize: this.state.panelSize,
       activeTab: this.state.activeTab,
@@ -76,12 +77,13 @@ export default class RootController extends React.Component {
     this.state = {
       ...nullFilePatchState,
       amending: false,
-      gitPanelActive: !!props.savedState.gitPanelActive,
+      gitTabActive: !!props.savedState.gitTabActive,
       githubPanelActive: !!props.savedState.githubPanelActive,
       panelSize: props.savedState.panelSize || 400,
       activeTab: props.savedState.activeTab || 0,
       cloneDialogActive: false,
       cloneDialogInProgress: false,
+      initDialogActive: false,
       credentialDialogQuery: null,
     };
 
@@ -97,8 +99,8 @@ export default class RootController extends React.Component {
     this.subscriptions = new CompositeDisposable();
     this.subscriptions.add(
       props.commandRegistry.add('atom-workspace', {
-        'github:toggle-git-panel': this.toggleGitPanel,
-        'github:toggle-git-panel-focus': this.toggleGitPanelFocus,
+        'github:toggle-git-tab': this.toggleGitTab,
+        'github:toggle-git-tab-focus': this.toggleGitTabFocus,
         'github:toggle-github-panel': this.toggleGithubPanel,
         'github:clone': this.openCloneDialog,
       }),
@@ -131,6 +133,7 @@ export default class RootController extends React.Component {
         {this.renderStatusBarTile()}
         {this.renderPanels()}
         {(this.state.filePath && this.state.filePatch) ? this.renderFilePatchController() : null}
+        {this.renderInitDialog()}
         {this.renderCloneDialog()}
         {this.renderCredentialDialog()}
         {this.renderRepositoryConflictController()}
@@ -147,7 +150,7 @@ export default class RootController extends React.Component {
           commandRegistry={this.props.commandRegistry}
           notificationManager={this.props.notificationManager}
           tooltips={this.props.tooltips}
-          toggleGitPanel={this.toggleGitPanel}
+          toggleGitTab={this.toggleGitTab}
         />
       </StatusBar>
     );
@@ -155,14 +158,14 @@ export default class RootController extends React.Component {
 
   renderPanels() {
     if (!this.props.useLegacyPanels) {
-      const gitPanel = this.state.gitPanelActive && (
+      const gitTab = this.state.gitTabActive && (
         <DockItem
           workspace={this.props.workspace}
           getItem={({subtree}) => subtree.getWrappedComponent()}
-          onDidCloseItem={() => this.setState({gitPanelActive: false})}
+          onDidCloseItem={() => this.setState({gitTabActive: false})}
           stubItemSelector="git-tab-controller">
           <EtchWrapper
-            ref={c => { this.gitPanelController = c; }}
+            ref={c => { this.gitTabController = c; }}
             className="github-PanelEtchWrapper"
             reattachDomNode={false}>
             <GitTabController
@@ -179,7 +182,7 @@ export default class RootController extends React.Component {
               didDiveIntoMergeConflictPath={this.diveIntoMergeConflictFileForPath}
               didChangeAmending={this.didChangeAmending}
               focusFilePatchView={this.focusFilePatchView}
-              ensureGitPanel={this.ensureGitPanel}
+              ensureGitTab={this.ensureGitTab}
               openFiles={this.openFiles}
               discardWorkDirChangesForPaths={this.discardWorkDirChangesForPaths}
               undoLastDiscard={this.undoLastDiscard}
@@ -198,15 +201,15 @@ export default class RootController extends React.Component {
         </DockItem>
       );
 
-      return <div>{gitPanel}{githubPanel}</div>;
+      return <div>{gitTab}{githubPanel}</div>;
     }
 
     return (
       <Panel
         workspace={this.props.workspace}
         location="right"
-        onDidClosePanel={() => this.setState({gitPanelActive: false})}
-        visible={!!this.state.gitPanelActive}>
+        onDidClosePanel={() => this.setState({gitTabActive: false})}
+        visible={!!this.state.gitTabActive}>
         <Resizer
           size={this.state.panelSize}
           onChange={this.handlePanelResize}
@@ -214,7 +217,7 @@ export default class RootController extends React.Component {
           <Tabs activeIndex={this.state.activeTab} onChange={this.handleChangeTab} className="sidebar-tabs">
             <Tabs.Panel title="Git">
               <EtchWrapper
-                ref={c => { this.gitPanelController = c; }}
+                ref={c => { this.gitTabController = c; }}
                 className="github-PanelEtchWrapper"
                 reattachDomNode={false}>
                 <GitTabController
@@ -231,7 +234,7 @@ export default class RootController extends React.Component {
                   didDiveIntoMergeConflictPath={this.diveIntoMergeConflictFileForPath}
                   didChangeAmending={this.didChangeAmending}
                   focusFilePatchView={this.focusFilePatchView}
-                  ensureGitPanel={this.ensureGitPanel}
+                  ensureGitTab={this.ensureGitTab}
                   openFiles={this.openFiles}
                   discardWorkDirChangesForPaths={this.discardWorkDirChangesForPaths}
                   undoLastDiscard={this.undoLastDiscard}
@@ -259,6 +262,7 @@ export default class RootController extends React.Component {
           ref={c => { this.filePatchControllerPane = c; }}
           onDidCloseItem={() => { this.setState({...nullFilePatchState}); }}>
           <FilePatchController
+            activeWorkingDirectory={this.props.activeWorkingDirectory}
             repository={this.props.repository}
             commandRegistry={this.props.commandRegistry}
             filePatch={this.state.filePatch}
@@ -279,6 +283,23 @@ export default class RootController extends React.Component {
     );
   }
 
+  renderInitDialog() {
+    if (!this.state.initDialogActive) {
+      return null;
+    }
+
+    return (
+      <Panel workspace={this.props.workspace} location="modal">
+        <InitDialog
+          config={this.props.config}
+          commandRegistry={this.props.commandRegistry}
+          didAccept={this.acceptInit}
+          didCancel={this.cancelInit}
+        />
+      </Panel>
+    );
+  }
+
   renderCloneDialog() {
     if (!this.state.cloneDialogActive) {
       return null;
@@ -337,8 +358,13 @@ export default class RootController extends React.Component {
   }
 
   @autobind
-  initializeRepo() {
-    this.props.createRepositoryForProjectPath(this.props.activeProjectPath);
+  async initializeRepo() {
+    if (this.props.activeWorkingDirectory) {
+      await this.acceptInit(this.props.activeWorkingDirectory);
+      return;
+    }
+
+    this.setState({initDialogActive: true});
   }
 
   @autobind
@@ -352,11 +378,10 @@ export default class RootController extends React.Component {
     try {
       await this.props.cloneRepositoryForProjectPath(remoteUrl, projectPath);
     } catch (e) {
-      if (!(e instanceof GitError)) {
-        throw e;
-      } else {
-        this.props.notificationManager.addError(`Unable to clone ${remoteUrl}`, {detail: e.stdErr, dismissable: true});
-      }
+      this.props.notificationManager.addError(
+        `Unable to clone ${remoteUrl}`,
+        {detail: e.stdErr, dismissable: true},
+      );
     } finally {
       this.setState({cloneDialogInProgress: false, cloneDialogActive: false});
     }
@@ -367,6 +392,25 @@ export default class RootController extends React.Component {
     this.setState({cloneDialogActive: false});
   }
 
+  @autobind
+  async acceptInit(projectPath) {
+    try {
+      await this.props.createRepositoryForProjectPath(projectPath);
+    } catch (e) {
+      this.props.notificationManager.addError(
+        `Unable to initialize git repository in ${projectPath}`,
+        {detail: e.stdErr, dismissable: true},
+      );
+    } finally {
+      this.setState({initDialogActive: false});
+    }
+  }
+
+  @autobind
+  cancelInit() {
+    this.setState({initDialogActive: false});
+  }
+
   @autobind
   async showFilePatchForPath(filePath, stagingStatus, {activate, amending} = {}) {
     if (!filePath) { return null; }
@@ -403,8 +447,8 @@ export default class RootController extends React.Component {
 
   @autobind
   surfaceFromFileAtPath(filePath, stagingStatus) {
-    if (this.gitPanelController) {
-      this.gitPanelController.getWrappedComponent().focusAndSelectStagingItem(filePath, stagingStatus);
+    if (this.gitTabController) {
+      this.gitTabController.getWrappedComponent().focusAndSelectStagingItem(filePath, stagingStatus);
     }
   }
 
@@ -436,8 +480,8 @@ export default class RootController extends React.Component {
   }
 
   @autobind
-  toggleGitPanel() {
-    this.setState(state => ({gitPanelActive: !state.gitPanelActive}));
+  toggleGitTab() {
+    this.setState(state => ({gitTabActive: !state.gitTabActive}));
   }
 
   @autobind
@@ -446,16 +490,16 @@ export default class RootController extends React.Component {
   }
 
   @autobind
-  toggleGitPanelFocus() {
-    if (!this.state.gitPanelActive) {
-      this.setState({gitPanelActive: true}, () => this.toggleGitPanelFocus());
+  toggleGitTabFocus() {
+    if (!this.state.gitTabActive) {
+      this.setState({gitTabActive: true}, () => this.toggleGitTabFocus());
       return;
     }
 
-    if (this.gitPanelHasFocus()) {
+    if (this.gitTabHasFocus()) {
       this.props.workspace.getActivePane().activate();
     } else {
-      this.focusGitPanel();
+      this.focusGitTab();
     }
   }
 
@@ -465,21 +509,21 @@ export default class RootController extends React.Component {
   }
 
   @autobind
-  focusGitPanel() {
-    this.gitPanelController.getWrappedComponent().focus();
+  focusGitTab() {
+    this.gitTabController.getWrappedComponent().focus();
   }
 
-  gitPanelHasFocus() {
-    return this.gitPanelController.getWrappedComponent().isFocused();
+  gitTabHasFocus() {
+    return this.gitTabController.getWrappedComponent().isFocused();
   }
 
   // Ensure that the Git panel is visible. Returns a Promise that resolves to `true` if the panel was initially
   // hidden or `false` if it was already shown.
   @autobind
-  ensureGitPanel() {
-    if (!this.state.gitPanelActive) {
+  ensureGitTab() {
+    if (!this.state.gitTabActive) {
       return new Promise((resolve, reject) => {
-        this.setState({gitPanelActive: true}, () => resolve(true));
+        this.setState({gitTabActive: true}, () => resolve(true));
       });
     }
 
@@ -500,8 +544,8 @@ export default class RootController extends React.Component {
 
   @autobind
   quietlySelectItem(filePath, stagingStatus) {
-    if (this.gitPanelController) {
-      return this.gitPanelController.getWrappedComponent().quietlySelectItem(filePath, stagingStatus);
+    if (this.gitTabController) {
+      return this.gitTabController.getWrappedComponent().quietlySelectItem(filePath, stagingStatus);
     } else {
       return null;
     }
diff --git a/lib/controllers/status-bar-tile-controller.js b/lib/controllers/status-bar-tile-controller.js
index d43ad90fbd..c452e6339e 100644
--- a/lib/controllers/status-bar-tile-controller.js
+++ b/lib/controllers/status-bar-tile-controller.js
@@ -2,7 +2,7 @@ import React from 'react';
 import PropTypes from 'prop-types';
 
 import ObserveModelDecorator from '../decorators/observe-model';
-import {BranchPropType} from '../prop-types';
+import {BranchPropType, RemotePropType} from '../prop-types';
 import BranchView from '../views/branch-view';
 import BranchMenuView from '../views/branch-menu-view';
 import PushPullView from '../views/push-pull-view';
@@ -10,6 +10,8 @@ import PushPullMenuView from '../views/push-pull-menu-view';
 import ChangedFilesCountView from '../views/changed-files-count-view';
 import Tooltip from '../views/tooltip';
 import Commands, {Command} from '../views/commands';
+import {nullBranch} from '../models/branch';
+import {nullRemote} from '../models/remote';
 import yubikiri from 'yubikiri';
 import {autobind} from 'core-decorators';
 
@@ -35,9 +37,9 @@ import {autobind} from 'core-decorators';
 
         return changedFiles.size;
       }),
-      remoteName: async query => repository.getRemoteForBranch((await query.currentBranch).name),
-      aheadCount: async query => repository.getAheadCount((await query.currentBranch).name),
-      behindCount: async query => repository.getBehindCount((await query.currentBranch).name),
+      currentRemote: async query => repository.getRemoteForBranch((await query.currentBranch).getName()),
+      aheadCount: async query => repository.getAheadCount((await query.currentBranch).getName()),
+      behindCount: async query => repository.getBehindCount((await query.currentBranch).getName()),
     });
   },
 })
@@ -47,18 +49,21 @@ export default class StatusBarTileController extends React.Component {
     notificationManager: PropTypes.object.isRequired,
     commandRegistry: PropTypes.object.isRequired,
     tooltips: PropTypes.object.isRequired,
-    repository: PropTypes.object,
-    currentBranch: BranchPropType,
-    branches: PropTypes.arrayOf(PropTypes.string),
-    remoteName: PropTypes.string,
+    repository: PropTypes.object.isRequired,
+    currentBranch: BranchPropType.isRequired,
+    branches: PropTypes.arrayOf(BranchPropType).isRequired,
+    currentRemote: RemotePropType.isRequired,
     aheadCount: PropTypes.number,
     behindCount: PropTypes.number,
     changedFilesCount: PropTypes.number,
-    toggleGitPanel: PropTypes.func,
+    toggleGitTab: PropTypes.func,
   }
 
   static defaultProps = {
-    toggleGitPanel: () => {},
+    currentBranch: nullBranch,
+    branches: [],
+    currentRemote: nullRemote,
+    toggleGitTab: () => {},
   }
 
   constructor(props, context) {
@@ -73,9 +78,9 @@ export default class StatusBarTileController extends React.Component {
 
   render() {
     const repoProps = {
-      currentBranch: this.props.currentBranch || {name: '', isDetached: false},
+      currentBranch: this.props.currentBranch,
       branches: this.props.branches,
-      remoteName: this.props.remoteName,
+      currentRemote: this.props.currentRemote,
       aheadCount: this.props.aheadCount,
       behindCount: this.props.behindCount,
       changedFilesCount: this.props.changedFilesCount,
@@ -83,16 +88,32 @@ export default class StatusBarTileController extends React.Component {
 
     return (
       <div className="github-StatusBarTileController">
+        {this.renderTiles(repoProps)}
+        <ChangedFilesCountView
+          didClick={this.props.toggleGitTab}
+          {...repoProps}
+        />
+      </div>
+    );
+  }
+
+  renderTiles(repoProps) {
+    if (!this.props.repository.showStatusBarTiles()) {
+      return null;
+    }
+
+    return (
+      <span>
         <Commands registry={this.props.commandRegistry} target="atom-workspace">
           <Command command="github:fetch" callback={this.fetch} />
           <Command command="github:pull" callback={this.pull} />
           <Command
             command="github:push"
-            callback={() => this.push({force: false, setUpstream: !this.props.remoteName})}
+            callback={() => this.push({force: false, setUpstream: !this.props.currentRemote.isPresent()})}
           />
           <Command
             command="github:force-push"
-            callback={() => this.push({force: true, setUpstream: !this.props.remoteName})}
+            callback={() => this.push({force: true, setUpstream: !this.props.currentRemote.isPresent()})}
           />
         </Commands>
         <BranchView
@@ -136,11 +157,7 @@ export default class StatusBarTileController extends React.Component {
             {...repoProps}
           />
         </Tooltip>
-        <ChangedFilesCountView
-          didClick={this.props.toggleGitPanel}
-          {...repoProps}
-        />
-      </div>
+      </span>
     );
   }
 
@@ -177,17 +194,17 @@ export default class StatusBarTileController extends React.Component {
   @autobind
   async push(options) {
     await this.setInProgressWhile(() => {
-      return this.props.repository.push(this.props.currentBranch.name, options);
+      return this.props.repository.push(this.props.currentBranch.getName(), options);
     }, {push: true});
   }
 
   @autobind
   async pull() {
-    await this.setInProgressWhile(() => this.props.repository.pull(this.props.currentBranch.name), {pull: true});
+    await this.setInProgressWhile(() => this.props.repository.pull(this.props.currentBranch.getName()), {pull: true});
   }
 
   @autobind
   async fetch() {
-    await this.setInProgressWhile(() => this.props.repository.fetch(this.props.currentBranch.name), {fetch: true});
+    await this.setInProgressWhile(() => this.props.repository.fetch(this.props.currentBranch.getName()), {fetch: true});
   }
 }
diff --git a/lib/git-prompt-server.js b/lib/git-prompt-server.js
index dcda296843..8c62ad3fa1 100644
--- a/lib/git-prompt-server.js
+++ b/lib/git-prompt-server.js
@@ -1,6 +1,5 @@
 import net from 'net';
 import path from 'path';
-import os from 'os';
 
 import {Emitter} from 'event-kit';
 
@@ -24,8 +23,7 @@ export default class GitPromptServer {
     // TODO: [mkt] Windows?? yes.
     this.promptForInput = promptForInput;
     const windows = process.platform === 'win32';
-    const prefix = windows ? os.tmpdir() : '/tmp';
-    this.tmpFolderPath = await getTempDir(path.join(prefix, 'github-'));
+    this.tmpFolderPath = await getTempDir('github-');
 
     const credentialHelper = {};
     const askPass = {};
diff --git a/lib/git-shell-out-strategy.js b/lib/git-shell-out-strategy.js
index 57c3217364..fb847ea135 100644
--- a/lib/git-shell-out-strategy.js
+++ b/lib/git-shell-out-strategy.js
@@ -236,13 +236,13 @@ export default class GitShellOutStrategy {
    * Staging/Unstaging files and patches and committing
    */
   stageFiles(paths) {
-    if (paths.length === 0) { return null; }
+    if (paths.length === 0) { return Promise.resolve(null); }
     const args = ['add'].concat(paths);
     return this.exec(args, {writeOperation: true});
   }
 
   unstageFiles(paths, commit = 'HEAD') {
-    if (paths.length === 0) { return null; }
+    if (paths.length === 0) { return Promise.resolve(null); }
     const args = ['reset', commit, '--'].concat(paths);
     return this.exec(args, {writeOperation: true});
   }
@@ -463,27 +463,15 @@ export default class GitShellOutStrategy {
     return this.exec(args, {writeOperation: true});
   }
 
-  async getRemoteForBranch(branchName) {
-    try {
-      const output = await this.exec(['config', `branch.${branchName}.remote`]);
-      return output.trim();
-    } catch (e) {
-      return null;
-    }
-  }
-
-  async fetch(branchName) {
-    const remote = await this.getRemoteForBranch(branchName);
+  fetch(remote, branchName) {
     return this.exec(['fetch', remote, branchName], {useGitPromptServer: true, writeOperation: true});
   }
 
-  async pull(branchName) {
-    const remote = await this.getRemoteForBranch(branchName);
+  pull(remote, branchName) {
     return this.gpgExec(['pull', remote, branchName], {useGitPromptServer: true, writeOperation: true});
   }
 
-  async push(branchName, options = {}) {
-    const remote = await this.getRemoteForBranch(branchName);
+  push(remote, branchName, options = {}) {
     const args = ['push', remote || 'origin', branchName];
     if (options.setUpstream) { args.push('--set-upstream'); }
     if (options.force) { args.push('--force'); }
diff --git a/lib/github-package.js b/lib/github-package.js
index 09ee5c186f..c8acb8680c 100644
--- a/lib/github-package.js
+++ b/lib/github-package.js
@@ -1,4 +1,3 @@
-import {File} from 'atom';
 import {CompositeDisposable, Disposable} from 'event-kit';
 
 import path from 'path';
@@ -6,27 +5,28 @@ import path from 'path';
 import React from 'react';
 import ReactDom from 'react-dom';
 import {autobind} from 'core-decorators';
-import compareSets from 'compare-sets';
 
+import {mkdirs} from './helpers';
+import WorkdirCache from './models/workdir-cache';
+import WorkdirContext, {absentWorkdirContext} from './models/workdir-context';
+import WorkdirContextPool from './models/workdir-context-pool';
 import Repository from './models/repository';
-import FileSystemChangeObserver from './models/file-system-change-observer';
-import WorkspaceChangeObserver from './models/workspace-change-observer';
-import ResolutionProgress from './models/conflicts/resolution-progress';
 import StyleCalculator from './models/style-calculator';
-import FilePatchController from './controllers/file-patch-controller';
 import RootController from './controllers/root-controller';
 import IssueishPaneItem from './atom-items/issueish-pane-item';
 import StubItem from './atom-items/stub-item';
 import Switchboard from './switchboard';
 import yardstick from './yardstick';
 import GitTimingsView from './views/git-timings-view';
+import AsyncQueue from './async-queue';
 
 const defaultState = {
   resolutionProgressByPath: {},
 };
 
 export default class GithubPackage {
-  constructor(workspace, project, commandRegistry, notificationManager, tooltips, styles, config, confirm) {
+  constructor(workspace, project, commandRegistry, notificationManager, tooltips, styles, config,
+      confirm, getLoadSettings) {
     this.workspace = workspace;
     this.project = project;
     this.commandRegistry = commandRegistry;
@@ -36,17 +36,40 @@ export default class GithubPackage {
     this.styles = styles;
 
     this.styleCalculator = new StyleCalculator(this.styles, this.config);
-    this.modelPromisesByProjectPath = new Map();
-    this.modelsByProjectPath = new Map();
     this.confirm = confirm;
-    this.activeRepository = null;
-    this.activeResolutionProgress = null;
     this.useLegacyPanels = false;
 
-    this.subscriptions = new CompositeDisposable();
-    this.savedState = {};
+    const criteria = {
+      projectPathCount: this.project.getPaths().length,
+      initPathCount: (getLoadSettings().initialPaths || []).length,
+    };
+
+    this.activeContextQueue = new AsyncQueue();
+    this.activeContext = WorkdirContext.guess(criteria);
+    this.workdirCache = new WorkdirCache();
+    this.contextPool = new WorkdirContextPool({
+      window,
+      workspace,
+      promptCallback: query => this.controller.promptForCredentials(query),
+    });
 
     this.switchboard = new Switchboard();
+
+    // Handle events from all resident contexts.
+    this.subscriptions = new CompositeDisposable(
+      this.contextPool.onDidChangeWorkdirOrHead(context => {
+        this.refreshAtomGitRepository(context.getWorkingDirectory());
+      }),
+      this.contextPool.onDidUpdateRepository(context => {
+        this.switchboard.didUpdateRepository(context.getRepository());
+      }),
+      this.contextPool.onDidDestroyRepository(context => {
+        if (context === this.activeContext) {
+          this.setActiveContext(absentWorkdirContext);
+        }
+      }),
+    );
+
     this.setupYardstick();
   }
 
@@ -54,6 +77,7 @@ export default class GithubPackage {
     const stagingSeries = ['stageLine', 'stageHunk', 'unstageLine', 'unstageHunk'];
 
     this.subscriptions.add(
+      // Staging and unstaging operations
       this.switchboard.onDidBeginStageOperation(payload => {
         if (payload.stage && payload.line) {
           yardstick.begin('stageLine');
@@ -73,17 +97,26 @@ export default class GithubPackage {
           yardstick.finish(stagingSeries);
         }
       }),
+
+      // Active context changes
+      this.switchboard.onDidScheduleActiveContextUpdate(() => {
+        yardstick.begin('activeContextChange');
+      }),
+      this.switchboard.onDidBeginActiveContextUpdate(() => {
+        yardstick.mark('activeContextChange', 'queue-wait');
+      }),
+      this.switchboard.onDidFinishContextChangeRender(() => {
+        yardstick.mark('activeContextChange', 'render');
+      }),
+      this.switchboard.onDidFinishActiveContextUpdate(() => {
+        yardstick.finish('activeContextChange');
+      }),
     );
   }
 
   activate(state = {}) {
     this.savedState = {...defaultState, ...state};
 
-    this.subscriptions = new CompositeDisposable();
-    const projectPaths = this.project.getDirectories().map(dir => dir.getRealPathSync());
-    const initPromises = this.cacheModelsForPaths(projectPaths);
-    this.initWatchersStartedPromise = initPromises.changeObserversStartedPromise;
-    this.initModelsPromise = initPromises.modelsPromise;
     if (!this.workspace.getLeftDock || this.config.get('github.useLegacyPanels')) {
       this.useLegacyPanels = true;
     }
@@ -99,8 +132,8 @@ export default class GithubPackage {
 
         this.rerender();
       }),
-      this.project.onDidChangePaths(this.didChangeProjectPaths),
-      this.workspace.onDidChangeActivePaneItem(this.didChangeActivePaneItem),
+      this.project.onDidChangePaths(this.scheduleActiveContextUpdate),
+      this.workspace.onDidChangeActivePaneItem(this.scheduleActiveContextUpdate),
       this.styleCalculator.startWatching(
         'github-package-styles',
         ['editor.fontSize', 'editor.fontFamily', 'editor.lineHeight'],
@@ -126,52 +159,33 @@ export default class GithubPackage {
       this.workspace.addOpener(IssueishPaneItem.opener),
     );
 
-    this.deserialize(this.savedState);
-
+    this.scheduleActiveContextUpdate(this.savedState);
     this.rerender();
   }
 
   serialize() {
     const activeRepository = this.getActiveRepository();
+    const activeRepositoryPath = activeRepository ? activeRepository.getWorkingDirectoryPath() : null;
 
     const resolutionProgressByPath = {};
-    this.modelsByProjectPath.forEach((models, projectPath) => {
-      const resolutionProgress = models.resolutionProgress;
-      if (!resolutionProgress.isEmpty()) {
-        resolutionProgressByPath[projectPath] = resolutionProgress.serialize();
+    this.contextPool.withResidentContexts((workdir, context) => {
+      const resolutionProgress = context.getResolutionProgress();
+      if (!resolutionProgress || resolutionProgress.isEmpty()) {
+        return;
       }
+
+      resolutionProgressByPath[workdir] = resolutionProgress.serialize();
     });
 
     return {
-      activeRepositoryPath: activeRepository ? activeRepository.getWorkingDirectoryPath() : null,
+      activeRepositoryPath,
       gitController: this.controller.serialize(),
       resolutionProgressByPath,
     };
   }
 
-  async deserialize(state) {
-    // Ensure that Repository promises are available
-    await this.initModelsPromise;
-    let nextActiveRepository, nextActiveResolutionProgress;
-
-    if (state.activeRepositoryPath) {
-      const repository = await this.getRepositoryForWorkdirPath(state.activeRepositoryPath);
-      if (repository) { nextActiveRepository = repository; }
-    }
-
-    if (nextActiveRepository) {
-      const savedResolutionProgress = this.savedState.resolutionProgressByPath[state.activeRepositoryPath] || {};
-      const commit = await nextActiveRepository.getLastCommit();
-      nextActiveResolutionProgress = new ResolutionProgress(commit.sha, savedResolutionProgress);
-
-      this.setActiveModels(nextActiveRepository, nextActiveResolutionProgress);
-    } else {
-      await this.updateActiveModels();
-    }
-  }
-
   @autobind
-  rerender() {
+  rerender(callback) {
     if (!this.element) {
       this.element = document.createElement('div');
       this.subscriptions.add(new Disposable(() => {
@@ -189,7 +203,7 @@ export default class GithubPackage {
         tooltips={this.tooltips}
         config={this.config}
         confirm={this.confirm}
-        activeProjectPath={this.activeProjectPath}
+        activeWorkingDirectory={this.getActiveWorkdir()}
         repository={this.getActiveRepository()}
         resolutionProgress={this.getActiveResolutionProgress()}
         statusBar={this.statusBar}
@@ -198,17 +212,14 @@ export default class GithubPackage {
         cloneRepositoryForProjectPath={this.cloneRepositoryForProjectPath}
         switchboard={this.switchboard}
         useLegacyPanels={this.useLegacyPanels}
-      />, this.element,
+      />, this.element, callback,
     );
   }
 
   async deactivate() {
     this.subscriptions.dispose();
-    if (this.destroyedRepositorySubscription) { this.destroyedRepositorySubscription.dispose(); }
-    await Promise.all([
-      this.destroyModelsForPaths(Array.from(this.modelPromisesByProjectPath.keys())),
-      yardstick.flush(),
-    ]);
+    this.contextPool.clear();
+    await yardstick.flush();
   }
 
   @autobind
@@ -241,237 +252,164 @@ export default class GithubPackage {
     });
   }
 
-  @autobind
-  async didChangeProjectPaths(projectPaths) {
-    this.updateActiveModels();
-    const previousProjectPaths = Array.from(this.modelPromisesByProjectPath.keys());
-    const {added, removed} = compareSets(new Set(previousProjectPaths), new Set(projectPaths));
-    this.cacheModelsForPaths(Array.from(added));
-    await this.destroyModelsForPaths(Array.from(removed));
-  }
-
   @autobind
   async createRepositoryForProjectPath(projectPath) {
-    if (!projectPath) {
-      throw new Error('Must specify a project path to create a repository for');
+    await mkdirs(projectPath);
+
+    const repository = this.contextPool.add(projectPath).getRepository();
+    await repository.init();
+    this.workdirCache.invalidate(projectPath);
+
+    if (!this.project.contains(projectPath)) {
+      this.project.addPath(projectPath);
     }
-    const repository = await Repository.init(projectPath);
-    this.addRepository(repository);
-    await this.updateActiveModels();
+
+    await this.scheduleActiveContextUpdate();
   }
 
   @autobind
   async cloneRepositoryForProjectPath(remoteUrl, projectPath) {
-    const repository = await Repository.clone(remoteUrl, projectPath);
-    this.addRepository(repository);
+    const context = this.contextPool.getContext(projectPath);
+    const repository = context.isPresent() ? context.getRepository() : new Repository(projectPath);
+
+    await repository.clone(remoteUrl);
+    this.workdirCache.invalidate(projectPath);
+
     this.project.addPath(projectPath);
-    await this.updateActiveModels();
+
+    await this.scheduleActiveContextUpdate();
   }
 
-  @autobind
-  didChangeActivePaneItem() {
-    this.updateActiveModels();
+  getActiveWorkdir() {
+    return this.activeContext.getWorkingDirectory();
   }
 
-  getInitialWatchersStartedPromise() {
-    return this.initWatchersStartedPromise;
+  getActiveRepository() {
+    return this.activeContext.getRepository();
   }
 
-  getInitialModelsPromise() {
-    return this.initModelsPromise;
+  getActiveResolutionProgress() {
+    return this.activeContext.getResolutionProgress();
   }
 
-  getActiveProjectPath() {
-    return this.activeProjectPath;
+  getContextPool() {
+    return this.contextPool;
   }
 
-  getActiveRepository() {
-    return this.activeRepository;
+  getSwitchboard() {
+    return this.switchboard;
   }
 
-  getActiveResolutionProgress() {
-    return this.activeResolutionProgress;
+  @autobind
+  async scheduleActiveContextUpdate(savedState = {}) {
+    this.switchboard.didScheduleActiveContextUpdate();
+    await this.activeContextQueue.push(this.updateActiveContext.bind(this, savedState), {parallel: false});
   }
 
-  async updateActiveModels() {
-    await this.initModelsPromise;
-    let nextActiveRepository, nextActiveResolutionProgress, nextActiveProjectPath;
-
-    const activeItem = this.workspace.getActivePaneItem();
-    if (activeItem && typeof activeItem.getPath === 'function') {
-      const projectPath = this.projectPathForItemPath(activeItem.getPath());
-      if (projectPath) {
-        nextActiveProjectPath = projectPath;
-        await Promise.all([
-          this.getRepositoryForWorkdirPath(projectPath).then(r => { nextActiveRepository = r; }),
-          this.getResolutionProgressForWorkdirPath(projectPath).then(rp => { nextActiveResolutionProgress = rp; }),
-        ]);
-      }
-    } else {
-      nextActiveRepository = this.activeRepository;
-      nextActiveResolutionProgress = this.activeResolutionProgress;
-      nextActiveProjectPath = this.activeProjectPath;
+  /**
+   * Derive the git working directory context that should be used for the package's git operations based on the current
+   * state of the Atom workspace. In priority, this prefers:
+   *
+   * - A git working directory that contains the active pane item.
+   * - A git working directory corresponding to a single Project.
+   * - When initially activating the package, the working directory that was active when the package was last
+   *   serialized.
+   * - The current context, unchanged, which may be a `NullWorkdirContext`.
+   *
+   * First updates the pool of resident contexts to match all git working directories that correspond to open
+   * projects and pane items.
+   */
+  async getNextContext(savedState) {
+    const workdirs = new Set(
+      await Promise.all(
+        this.project.getPaths().map(async projectPath => {
+          const workdir = await this.workdirCache.find(projectPath);
+          return workdir || projectPath;
+        }),
+      ),
+    );
+
+    const activeItemPath = pathForPaneItem(this.workspace.getActivePaneItem());
+    let activeItemWorkdir = null;
+    if (activeItemPath) {
+      activeItemWorkdir = await this.workdirCache.find(activeItemPath);
     }
 
-    if (activeItem instanceof FilePatchController) {
-      if (!activeItem.getRepository().isDestroyed()) {
-        nextActiveRepository = activeItem.props.repository;
-        nextActiveResolutionProgress = activeItem.props.resolutionProgress;
-        nextActiveProjectPath = nextActiveRepository.getWorkingDirectoryPath();
-      }
+    if (activeItemWorkdir && !this.project.contains(activeItemPath)) {
+      workdirs.add(activeItemWorkdir);
     }
 
-    if (!activeItem && this.project.getPaths().length === 1) {
-      nextActiveProjectPath = this.project.getPaths()[0];
-      nextActiveRepository = await this.getRepositoryForWorkdirPath(nextActiveProjectPath);
+    this.contextPool.set(workdirs, savedState);
+
+    if (activeItemPath) {
+      // Prefer an active item
+      return this.contextPool.getContext(activeItemWorkdir || activeItemPath);
     }
 
-    if (nextActiveRepository && nextActiveRepository !== this.activeRepository) {
-      this.activeProjectPath = nextActiveProjectPath || null;
-      this.setActiveModels(nextActiveRepository, nextActiveResolutionProgress);
+    if (this.project.getPaths().length === 1) {
+      // Single project
+      const projectPath = this.project.getPaths()[0];
+      const activeWorkingDir = await this.workdirCache.find(projectPath);
+      return this.contextPool.getContext(activeWorkingDir || projectPath);
+    }
 
-      if (this.destroyedRepositorySubscription) { this.destroyedRepositorySubscription.dispose(); }
-      this.destroyedRepositorySubscription = nextActiveRepository.onDidDestroy(() => {
-        if (nextActiveRepository === this.activeRepository) {
-          this.setActiveModels(null);
-        }
-        this.destroyedRepositorySubscription.dispose();
-      });
-    } else if (nextActiveRepository && this.activeProjectPath !== nextActiveProjectPath) {
-      this.activeProjectPath = nextActiveProjectPath || null;
-      this.rerender();
-    } else if (!nextActiveRepository) {
-      this.activeProjectPath = nextActiveProjectPath || null;
-      this.setActiveModels(null, null);
+    if (this.project.getPaths().length === 0 && !this.activeContext.getRepository().isUndetermined()) {
+      // No projects. Revert to the absent context unless we've guessed that more projects are on the way.
+      return absentWorkdirContext;
     }
-  }
 
-  setActiveModels(repository, resolutionProgress) {
-    if (this.activeRepository !== repository) {
-      if (this.changedRepositorySubscription) { this.changedRepositorySubscription.dispose(); }
-      if (repository) {
-        this.changedRepositorySubscription = repository.onDidUpdate(() => {
-          this.switchboard.didUpdateRepository();
-        });
-      }
+    // Restore models from saved state. Will return a NullWorkdirContext if this path is not presently
+    // resident in the pool.
+    const savedWorkingDir = savedState.activeRepositoryPath;
+    if (savedWorkingDir) {
+      return this.contextPool.getContext(savedWorkingDir);
     }
 
-    this.activeRepository = repository;
-    this.activeResolutionProgress = resolutionProgress;
-    this.rerender();
+    return this.activeContext;
   }
 
-  refreshAtomGitRepository(repository) {
-    const repoPath = repository.getWorkingDirectoryPath();
-    const atomGitRepo = this.project.getRepositories().find(repo => {
-      return repo && path.normalize(repo.getWorkingDirectory()) === repoPath;
-    });
-    return atomGitRepo ? atomGitRepo.refreshStatus() : Promise.resolve();
+  setActiveContext(nextActiveContext) {
+    if (nextActiveContext !== this.activeContext) {
+      this.activeContext = nextActiveContext;
+      this.rerender(() => {
+        this.switchboard.didFinishContextChangeRender();
+        this.switchboard.didFinishActiveContextUpdate();
+      });
+    } else {
+      this.switchboard.didFinishActiveContextUpdate();
+    }
   }
 
-  projectPathForItemPath(filePath) {
-    if (!filePath) { return null; }
-    const realFilePath = new File(filePath).getRealPathSync();
-    const directory = this.project.getDirectories().find(projectDir => {
-      const fixedPath = projectDir.getRealPathSync() + path.sep;
-      return realFilePath.startsWith(fixedPath);
-    });
-    return directory ? directory.getRealPathSync() : null;
-  }
+  async updateActiveContext(savedState = {}) {
+    this.switchboard.didBeginActiveContextUpdate();
 
-  getRepositoryForWorkdirPath(workdirPath) {
-    const models = this.modelPromisesByProjectPath.get(workdirPath);
-    return models ? models.repositoryPromise : Promise.resolve(null);
+    const nextActiveContext = await this.getNextContext(savedState);
+    this.setActiveContext(nextActiveContext);
   }
 
-  getResolutionProgressForWorkdirPath(workdirPath) {
-    const models = this.modelPromisesByProjectPath.get(workdirPath);
-    return models ? models.resolutionProgressPromise : Promise.resolve(null);
+  refreshAtomGitRepository(workdir) {
+    const atomGitRepo = this.project.getRepositories().find(repo => {
+      return repo && path.normalize(repo.getWorkingDirectory()) === workdir;
+    });
+    return atomGitRepo ? atomGitRepo.refreshStatus() : Promise.resolve();
   }
+}
 
-  getChangeObserverForWorkdirPath(workdirPath) {
-    const models = this.modelPromisesByProjectPath.get(workdirPath);
-    return models ? models.changeObserverPromise : Promise.resolve(null);
+function pathForPaneItem(paneItem) {
+  if (!paneItem) {
+    return null;
   }
 
-  cacheModelsForPaths(addedPaths) {
-    const changeObserverPromises = [];
-    const modelsPromises = [];
-
-    const ready = Promise.all(addedPaths.map(async projectPath => {
-      const repository = await Repository.open(projectPath);
-      if (!repository) {
-        return;
-      }
-
-      const {modelPromise, changeObserverPromise} = this.addRepository(repository);
-      modelsPromises.push(modelPromise);
-      changeObserverPromises.push(changeObserverPromise);
-    }));
-
-    return {
-      changeObserversStartedPromise: ready.then(() => Promise.all(changeObserverPromises)),
-      modelsPromise: ready.then(() => Promise.all(modelsPromises)),
-    };
+  // Likely GitHub package provided pane item
+  if (typeof paneItem.getWorkingDirectory === 'function') {
+    return paneItem.getWorkingDirectory();
   }
 
-  addRepository(repository) {
-    const projectPath = repository.getWorkingDirectoryPath();
-    repository.setPromptCallback(query => this.controller.promptForCredentials(query));
-
-    // TODO Since we need to await the repositoryPromise to see if a promise is available or not anyway, other
-    // calls that are initialized with the promise aren't actually necessary anymore.
-    const repositoryPromise = Promise.resolve(repository);
-
-    const changeObserver = process.platform === 'linux'
-      ? new WorkspaceChangeObserver(window, this.workspace, repositoryPromise)
-      : new FileSystemChangeObserver(repositoryPromise);
-    this.subscriptions.add(
-      changeObserver.onDidChange(() => repository.refresh()),
-      changeObserver.onDidChangeWorkdirOrHead(() => this.refreshAtomGitRepository(repository)),
-    );
-    const changeObserverPromise = changeObserver.start();
-
-    const savedResolutionProgress = this.savedState.resolutionProgressByPath[projectPath] || {};
-    const resolutionProgressPromise = repository.getLastCommit()
-      .then(commit => new ResolutionProgress(commit.sha, savedResolutionProgress));
-
-    // Once they resolve, stash the models in modelsByProjectPath for synchronous access when they're needed.
-    const models = {
-      repository,
-      changeObserver: null,
-      resolutionProgress: null,
-    };
-    this.modelsByProjectPath.set(projectPath, models);
-    changeObserverPromise.then(() => {
-      models.changeObserver = changeObserver;
-    });
-    resolutionProgressPromise.then(rp => {
-      models.resolutionProgress = rp;
-    });
-
-    this.modelPromisesByProjectPath.set(projectPath, {
-      repositoryPromise,
-      changeObserverPromise,
-      resolutionProgressPromise,
-    });
-
-    return {modelPromise: resolutionProgressPromise, changeObserverPromise};
+  // TextEditor-like
+  if (typeof paneItem.getPath === 'function') {
+    return paneItem.getPath();
   }
 
-  destroyModelsForPaths(removedPaths) {
-    return Promise.all(
-      removedPaths.map(async projectPath => {
-        const repositoryPromise = this.getRepositoryForWorkdirPath(projectPath);
-        const changeObserverPromise = this.getChangeObserverForWorkdirPath(projectPath);
-        this.modelPromisesByProjectPath.delete(projectPath);
-
-        const repository = await repositoryPromise;
-        const changeObserver = await changeObserverPromise;
-        // repository and changeObserver may be null if the associated workdir was not a Git repo
-        repository && repository.destroy();
-        changeObserver && await changeObserver.destroy();
-      }),
-    );
-  }
+  // Oh well
+  return null;
 }
diff --git a/lib/helpers.js b/lib/helpers.js
index 9cdbdd5b41..09cd14d0d8 100644
--- a/lib/helpers.js
+++ b/lib/helpers.js
@@ -1,5 +1,6 @@
 import path from 'path';
 import fs from 'fs-extra';
+import temp from 'temp';
 import {ncp} from 'ncp';
 
 export function getPackageRoot() {
@@ -149,10 +150,15 @@ export function copyFile(source, target) {
   });
 }
 
-export function getTempDir(prefix) {
+export function getTempDir(prefix = '') {
   return new Promise((resolve, reject) => {
-    fs.mkdtemp(prefix, (err, folder) => {
-      if (err) { return reject(err); } else { return resolve(folder); }
+    temp.mkdir(prefix, (tempError, folder) => {
+      if (tempError) {
+        reject(tempError);
+        return;
+      }
+
+      fs.realpath(folder, (realError, rpath) => (realError ? reject(realError) : resolve(rpath)));
     });
   });
 }
@@ -170,6 +176,12 @@ export async function isFileExecutable(absoluteFilePath) {
   return stat.mode & fs.constants.S_IXUSR; // eslint-disable-line no-bitwise
 }
 
+export function mkdirs(directory) {
+  return new Promise((resolve, reject) => {
+    fs.mkdirs(directory, err => (err ? reject(err) : resolve()));
+  });
+}
+
 export function shortenSha(sha) {
   return sha.slice(0, 8);
 }
diff --git a/lib/index.js b/lib/index.js
index 4b0ed0033b..2387bc5b8b 100644
--- a/lib/index.js
+++ b/lib/index.js
@@ -5,7 +5,7 @@ const entry = {
   initialize() {
     pack = new GithubPackage(
       atom.workspace, atom.project, atom.commands, atom.notifications, atom.tooltips,
-      atom.styles, atom.config, atom.confirm.bind(atom),
+      atom.styles, atom.config, atom.confirm.bind(atom), atom.getLoadSettings.bind(atom),
     );
   },
 };
diff --git a/lib/models/branch.js b/lib/models/branch.js
new file mode 100644
index 0000000000..6f6493ad6f
--- /dev/null
+++ b/lib/models/branch.js
@@ -0,0 +1,38 @@
+const DETACHED = {};
+
+export default class Branch {
+  constructor(name, detached = null) {
+    this.name = name;
+    this.detached = detached === DETACHED;
+  }
+
+  static createDetached(describe) {
+    return new Branch(describe, DETACHED);
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  isDetached() {
+    return this.detached;
+  }
+
+  isPresent() {
+    return true;
+  }
+}
+
+export const nullBranch = {
+  getName() {
+    return '';
+  },
+
+  isDetached() {
+    return false;
+  },
+
+  isPresent() {
+    return false;
+  },
+};
diff --git a/lib/models/commit.js b/lib/models/commit.js
new file mode 100644
index 0000000000..f7398c5a8c
--- /dev/null
+++ b/lib/models/commit.js
@@ -0,0 +1,47 @@
+const UNBORN = {};
+
+export default class Commit {
+  static createUnborn() {
+    return new Commit('', '', UNBORN);
+  }
+
+  constructor(sha, message, unbornRef = null) {
+    this.sha = sha;
+    this.message = message.trim();
+    this.unbornRef = unbornRef === UNBORN;
+  }
+
+  getSha() {
+    return this.sha;
+  }
+
+  getMessage() {
+    return this.message;
+  }
+
+  isUnbornRef() {
+    return this.unbornRef;
+  }
+
+  isPresent() {
+    return true;
+  }
+}
+
+export const nullCommit = {
+  getSha() {
+    return '';
+  },
+
+  getMessage() {
+    return '';
+  },
+
+  isUnbornRef() {
+    return false;
+  },
+
+  isPresent() {
+    return false;
+  },
+};
diff --git a/lib/models/conflicts/resolution-progress.js b/lib/models/conflicts/resolution-progress.js
index d135cc7dc0..bfd7664d83 100644
--- a/lib/models/conflicts/resolution-progress.js
+++ b/lib/models/conflicts/resolution-progress.js
@@ -1,21 +1,29 @@
 import {Emitter} from 'event-kit';
 
 export default class ResolutionProgress {
-  static empty() {
-    return new ResolutionProgress('', {});
-  }
-
-  constructor(revision, savedState) {
+  constructor() {
     this.emitter = new Emitter();
 
-    this.revision = revision;
+    this.revision = '';
     this.markerCountByPath = new Map();
+    this.loaded = false;
+  }
+
+  load(revision, savedState) {
+    this.revision = revision;
 
     if (savedState.revision === this.revision) {
-      Object.keys(savedState.paths || {}).forEach(path => {
-        this.markerCountByPath.set(path, savedState.paths[path]);
+      const paths = Object.keys(savedState.paths || {});
+      paths.forEach(filePath => {
+        this.markerCountByPath.set(filePath, savedState.paths[filePath]);
       });
+
+      if (paths.length > 0) {
+        this.didUpdate();
+      }
     }
+
+    this.loaded = true;
   }
 
   didUpdate() {
diff --git a/lib/models/discard-history.js b/lib/models/discard-history.js
index 7c71687522..53ca3c2f6b 100644
--- a/lib/models/discard-history.js
+++ b/lib/models/discard-history.js
@@ -118,7 +118,7 @@ export default class DiscardHistory {
   }
 
   async expandBlobsToFilesInTempFolder(snapshots) {
-    const tempFolderPath = await getTempDir(path.join(os.tmpdir(), 'github-discard-history-'));
+    const tempFolderPath = await getTempDir('github-discard-history-');
     const pathPromises = snapshots.map(async ({filePath, beforeSha, afterSha}) => {
       const dir = path.dirname(path.join(tempFolderPath, filePath));
       await mkdirp(dir);
diff --git a/lib/models/file-system-change-observer.js b/lib/models/file-system-change-observer.js
index 43ef449e99..1a9624119d 100644
--- a/lib/models/file-system-change-observer.js
+++ b/lib/models/file-system-change-observer.js
@@ -6,15 +6,16 @@ import path from 'path';
 import EventLogger from './event-logger';
 
 export default class FileSystemChangeObserver {
-  constructor(repositoryPromise) {
+  constructor(repository) {
     this.emitter = new Emitter();
-    this.repositoryPromise = repositoryPromise;
+    this.repository = repository;
     this.logger = new EventLogger('FileSystemChangeObserver');
+    this.started = false;
   }
 
   async start() {
-    this.started = true;
     await this.watchRepository();
+    this.started = true;
     return this;
   }
 
@@ -24,6 +25,18 @@ export default class FileSystemChangeObserver {
     await this.stopCurrentFileWatcher();
   }
 
+  isStarted() {
+    return this.started;
+  }
+
+  didChange(payload) {
+    this.emitter.emit('did-change', payload);
+  }
+
+  didChangeWorkdirOrHead() {
+    this.emitter.emit('did-change-workdir-or-head');
+  }
+
   onDidChange(callback) {
     return this.emitter.on('did-change', callback);
   }
@@ -33,14 +46,13 @@ export default class FileSystemChangeObserver {
   }
 
   getRepository() {
-    return this.repositoryPromise;
+    return this.repository;
   }
 
   async watchRepository() {
-    const repository = await this.getRepository();
-    if (repository) {
+    if (this.repository) {
       this.currentFileWatcher = await nsfw(
-        repository.getWorkingDirectoryPath(),
+        this.repository.getWorkingDirectoryPath(),
         events => {
           const isNonGitFile = event => !event.directory.split(path.sep).includes('.git') && event.file !== '.git';
           const isWatchedGitFile = event => {
@@ -61,7 +73,7 @@ export default class FileSystemChangeObserver {
         {
           debounceMS: 100,
           errorCallback: errors => {
-            const workingDirectory = repository.getWorkingDirectoryPath();
+            const workingDirectory = this.repository.getWorkingDirectoryPath();
             // eslint-disable-next-line no-console
             console.warn(`Error in FileSystemChangeObserver in ${workingDirectory}:`, errors);
             this.stopCurrentFileWatcher();
@@ -69,7 +81,7 @@ export default class FileSystemChangeObserver {
         },
       );
       await this.currentFileWatcher.start();
-      this.logger.showStarted(repository.getWorkingDirectoryPath());
+      this.logger.showStarted(this.repository.getWorkingDirectoryPath());
     }
   }
 
diff --git a/lib/models/remote.js b/lib/models/remote.js
new file mode 100644
index 0000000000..e272d62767
--- /dev/null
+++ b/lib/models/remote.js
@@ -0,0 +1,96 @@
+export default class Remote {
+  constructor(name, url) {
+    this.name = name;
+    this.url = url;
+
+    const {isGithubRepo, owner, repo} = githubInfoFromRemote(url);
+    this.githubRepo = isGithubRepo;
+    this.owner = owner;
+    this.repo = repo;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  getUrl() {
+    return this.url;
+  }
+
+  isGithubRepo() {
+    return this.githubRepo;
+  }
+
+  getOwner() {
+    return this.owner;
+  }
+
+  getRepo() {
+    return this.repo;
+  }
+
+  getNameOr(fallback) {
+    return this.getName();
+  }
+
+  isPresent() {
+    return true;
+  }
+}
+
+function githubInfoFromRemote(remoteUrl) {
+  if (!remoteUrl) {
+    return {
+      isGithubRepo: false,
+      owner: null,
+      repo: null,
+    };
+  }
+
+  //             proto       login   domain         owner    repo
+  const regex = /(?:.+:\/\/)?(?:.+@)?github\.com[:/]([^/]+)\/(.+)/;
+  const match = remoteUrl.match(regex);
+  if (match) {
+    return {
+      isGithubRepo: true,
+      owner: match[1],
+      repo: match[2].replace(/\.git$/, ''),
+    };
+  } else {
+    return {
+      isGithubRepo: false,
+      owner: null,
+      repo: null,
+    };
+  }
+}
+
+export const nullRemote = {
+  getName() {
+    return '';
+  },
+
+  getUrl() {
+    return '';
+  },
+
+  isGithubRepo() {
+    return false;
+  },
+
+  getOwner() {
+    return null;
+  },
+
+  getRepo() {
+    return null;
+  },
+
+  getNameOr(fallback) {
+    return fallback;
+  },
+
+  isPresent() {
+    return false;
+  },
+};
diff --git a/lib/models/repository-states/README.md b/lib/models/repository-states/README.md
new file mode 100644
index 0000000000..24ceb38527
--- /dev/null
+++ b/lib/models/repository-states/README.md
@@ -0,0 +1,11 @@
+This directory contains the various states that a `Repository` model can assume. Each state subclasses [`State`](./state.js), which provides each state with:
+
+* Trivial implementations of the state-dependent Repository functionality that return "empty" results where possible; Promises that resolve to empty arrays, null-object `Remote` or `Branch` implementations, `false`. This allows the UI components to freely query the current Repository for data regardless of whether an actual git repository exists or not.
+* Action and transition methods that throw exceptions or reject Promises.
+* UI state probe methods to allow individual states to customize the way that certain UI components respond while each state is active. For example, if `showGitTabLoading` is overridden to return `false`, the `.is-loading` class is added to the Git tab DOM node to allow it to be styled differently.
+
+Here's the current state transition diagram:
+
+![state transition diagram](./repo-states.png)
+
+Only the initial states (`Absent`, `AbsentGuess`, `Loading`, and `LoadingGuess`) are exported from the directory module.
diff --git a/lib/models/repository-states/absent-guess.js b/lib/models/repository-states/absent-guess.js
new file mode 100644
index 0000000000..0f50b88082
--- /dev/null
+++ b/lib/models/repository-states/absent-guess.js
@@ -0,0 +1,29 @@
+import State from './state';
+
+/**
+ * Initial state to be used when we anticipate that the workspace will contain zero or many projects once bootstrapping
+ * has completed. Presents in the UI like the Absent state, but is "sticky" during the initial package activation.
+ */
+export default class AbsentGuess extends State {
+  isAbsentGuess() {
+    return true;
+  }
+
+  isUndetermined() {
+    return true;
+  }
+
+  showGitTabLoading() {
+    return false;
+  }
+
+  showGitTabInit() {
+    return true;
+  }
+
+  hasDirectory() {
+    return false;
+  }
+}
+
+State.register(AbsentGuess);
diff --git a/lib/models/repository-states/absent.js b/lib/models/repository-states/absent.js
new file mode 100644
index 0000000000..c282392e7a
--- /dev/null
+++ b/lib/models/repository-states/absent.js
@@ -0,0 +1,20 @@
+import State from './state';
+
+/**
+ * No working directory is available in the workspace.
+ */
+export default class Absent extends State {
+  isAbsent() {
+    return true;
+  }
+
+  showGitTabInit() {
+    return true;
+  }
+
+  hasDirectory() {
+    return false;
+  }
+}
+
+State.register(Absent);
diff --git a/lib/models/repository-states/cloning.js b/lib/models/repository-states/cloning.js
new file mode 100644
index 0000000000..8afe1c081a
--- /dev/null
+++ b/lib/models/repository-states/cloning.js
@@ -0,0 +1,26 @@
+import {mkdirs} from '../../helpers';
+
+import State from './state';
+
+/**
+ * Git is asynchronously cloning a repository into this working directory.
+ */
+export default class Cloning extends State {
+  constructor(repository, remoteUrl) {
+    super(repository);
+    this.remoteUrl = remoteUrl;
+  }
+
+  async start() {
+    await mkdirs(this.workdir());
+    await this.git().clone(this.remoteUrl, {recursive: true});
+
+    await this.transitionTo('Loading');
+  }
+
+  showGitTabLoading() {
+    return true;
+  }
+}
+
+State.register(Cloning);
diff --git a/lib/models/repository-states/destroyed.js b/lib/models/repository-states/destroyed.js
new file mode 100644
index 0000000000..0273989a9d
--- /dev/null
+++ b/lib/models/repository-states/destroyed.js
@@ -0,0 +1,21 @@
+import State from './state';
+
+/**
+ * The package is being cleaned up or the context is being disposed some other way.
+ */
+export default class Destroyed extends State {
+  start() {
+    this.didDestroy();
+    this.repository.emitter.dispose();
+  }
+
+  isDestroyed() {
+    return true;
+  }
+
+  destroy() {
+    // No-op to destroy twice
+  }
+}
+
+State.register(Destroyed);
diff --git a/lib/models/repository-states/empty.js b/lib/models/repository-states/empty.js
new file mode 100644
index 0000000000..116ceae31c
--- /dev/null
+++ b/lib/models/repository-states/empty.js
@@ -0,0 +1,24 @@
+import State from './state';
+
+/**
+ * The working directory exists, but contains no git repository yet.
+ */
+export default class Empty extends State {
+  isEmpty() {
+    return true;
+  }
+
+  init() {
+    return this.transitionTo('Initializing');
+  }
+
+  clone(remoteUrl) {
+    return this.transitionTo('Cloning', remoteUrl);
+  }
+
+  showGitTabInit() {
+    return true;
+  }
+}
+
+State.register(Empty);
diff --git a/lib/models/repository-states/index.js b/lib/models/repository-states/index.js
new file mode 100644
index 0000000000..7637057b16
--- /dev/null
+++ b/lib/models/repository-states/index.js
@@ -0,0 +1,14 @@
+export {expectedDelegates} from './state';
+
+// Load and export possible initial states
+export {default as Loading} from './loading';
+export {default as LoadingGuess} from './loading-guess';
+export {default as Absent} from './absent';
+export {default as AbsentGuess} from './absent-guess';
+
+// Load and register remaining states
+import './empty';
+import './initializing';
+import './cloning';
+import './present';
+import './destroyed';
diff --git a/lib/models/repository-states/initializing.js b/lib/models/repository-states/initializing.js
new file mode 100644
index 0000000000..385203d6ca
--- /dev/null
+++ b/lib/models/repository-states/initializing.js
@@ -0,0 +1,18 @@
+import State from './state';
+
+/**
+ * Git is asynchronously initializing a new repository in this working directory.
+ */
+export default class Initializing extends State {
+  async start() {
+    await this.git().init(this.workdir());
+
+    await this.transitionTo('Loading');
+  }
+
+  showGitTabLoading() {
+    return true;
+  }
+}
+
+State.register(Initializing);
diff --git a/lib/models/repository-states/loading-guess.js b/lib/models/repository-states/loading-guess.js
new file mode 100644
index 0000000000..a323ff7c07
--- /dev/null
+++ b/lib/models/repository-states/loading-guess.js
@@ -0,0 +1,29 @@
+import State from './state';
+
+/**
+ * Initial state to be used when we anticipate that the workspace will contain a single project once bootstrapping
+ * has completed. Presents in the UI like the Loading state.
+ */
+export default class LoadingGuess extends State {
+  isLoadingGuess() {
+    return true;
+  }
+
+  isUndetermined() {
+    return true;
+  }
+
+  showGitTabLoading() {
+    return true;
+  }
+
+  showGitTabInit() {
+    return false;
+  }
+
+  hasDirectory() {
+    return false;
+  }
+}
+
+State.register(LoadingGuess);
diff --git a/lib/models/repository-states/loading.js b/lib/models/repository-states/loading.js
new file mode 100644
index 0000000000..a70420f557
--- /dev/null
+++ b/lib/models/repository-states/loading.js
@@ -0,0 +1,36 @@
+import State from './state';
+
+/**
+ * Initial state to be used when it's uncertain whether or not a git repository is present in a working directory. If
+ * it is a git repository, transition to Present, otherwise transition to Empty.
+ */
+export default class Loading extends State {
+  async start() {
+    if (await this.git().isGitRepository()) {
+      const history = await this.loadHistoryPayload();
+      return this.transitionTo('Present', history);
+    } else {
+      return this.transitionTo('Empty');
+    }
+  }
+
+  isLoading() {
+    return true;
+  }
+
+  async init() {
+    await this.getLoadPromise();
+    await this.repository.init();
+  }
+
+  async clone(remoteUrl) {
+    await this.getLoadPromise();
+    await this.repository.clone(remoteUrl);
+  }
+
+  showGitTabLoading() {
+    return true;
+  }
+}
+
+State.register(Loading);
diff --git a/lib/models/repository-states/present.js b/lib/models/repository-states/present.js
new file mode 100644
index 0000000000..603a902af5
--- /dev/null
+++ b/lib/models/repository-states/present.js
@@ -0,0 +1,505 @@
+import path from 'path';
+
+import State from './state';
+
+import {deleteFileOrFolder} from '../../helpers';
+import FilePatch from '../file-patch';
+import Hunk from '../hunk';
+import HunkLine from '../hunk-line';
+import DiscardHistory from '../discard-history';
+import Branch from '../branch';
+import Remote from '../remote';
+import Commit from '../commit';
+
+class Cache {
+  constructor() {
+    this.storage = new Map();
+  }
+
+  getOrSet(key, operation) {
+    const existing = this.storage.get(key);
+    if (existing !== undefined) {
+      return existing;
+    }
+
+    const created = operation();
+    this.storage.set(key, created);
+    return created;
+  }
+
+  invalidate(...keys) {
+    for (let i = 0; i < keys.length; i++) {
+      this.storage.delete(keys[i]);
+    }
+  }
+
+  clear() {
+    this.storage.clear();
+  }
+}
+
+/**
+ * Decorator for an async method that invalidates the cache after execution (regardless of success or failure.)
+ */
+function invalidate() {
+  return function(target, name, descriptor) {
+    const original = descriptor.value;
+    descriptor.value = function(...args) {
+      return original.apply(this, args).then(
+        result => {
+          this.refresh();
+          return result;
+        },
+        err => {
+          this.refresh();
+          return Promise.reject(err);
+        },
+      );
+    };
+    return descriptor;
+  };
+}
+
+/**
+ * State used when the working directory contains a valid git repository and can be interacted with. Performs
+ * actual git operations, caching the results, and broadcasts `onDidUpdate` events when write actions are
+ * performed.
+ */
+export default class Present extends State {
+  constructor(repository, history) {
+    super(repository);
+
+    this.cache = new Cache();
+
+    this.discardHistory = new DiscardHistory(
+      this.createBlob.bind(this),
+      this.expandBlobToFile.bind(this),
+      this.mergeFile.bind(this),
+      this.workdir(),
+      {maxHistoryLength: 60},
+    );
+  }
+
+  isPresent() {
+    return true;
+  }
+
+  showStatusBarTiles() {
+    return true;
+  }
+
+  refresh() {
+    this.cache.clear();
+    this.didUpdate();
+  }
+
+  init() {
+    return super.init().catch(e => {
+      e.stdErr = 'This directory already contains a git repository';
+      return Promise.reject(e);
+    });
+  }
+
+  clone() {
+    return super.clone().catch(e => {
+      e.stdErr = 'This directory already contains a git repository';
+      return Promise.reject(e);
+    });
+  }
+
+  // Git operations ////////////////////////////////////////////////////////////////////////////////////////////////////
+
+  // Staging and unstaging
+
+  @invalidate()
+  stageFiles(paths) {
+    return this.git().stageFiles(paths);
+  }
+
+  @invalidate()
+  unstageFiles(paths) {
+    return this.git().unstageFiles(paths);
+  }
+
+  @invalidate()
+  stageFilesFromParentCommit(paths) {
+    return this.git().unstageFiles(paths, 'HEAD~');
+  }
+
+  @invalidate()
+  applyPatchToIndex(filePatch) {
+    const patchStr = filePatch.getHeaderString() + filePatch.toString();
+    return this.git().applyPatch(patchStr, {index: true});
+  }
+
+  @invalidate()
+  applyPatchToWorkdir(filePatch) {
+    const patchStr = filePatch.getHeaderString() + filePatch.toString();
+    return this.git().applyPatch(patchStr);
+  }
+
+  // Committing
+
+  @invalidate()
+  commit(message, options) {
+    return this.git().commit(formatCommitMessage(message), options);
+  }
+
+  // Merging
+
+  @invalidate()
+  merge(branchName) {
+    return this.git().merge(branchName);
+  }
+
+  @invalidate()
+  abortMerge() {
+    return this.git().abortMerge();
+  }
+
+  @invalidate()
+  checkoutSide(side, paths) {
+    return this.git().checkoutSide(side, paths);
+  }
+
+  @invalidate()
+  mergeFile(oursPath, commonBasePath, theirsPath, resultPath) {
+    return this.git().mergeFile(oursPath, commonBasePath, theirsPath, resultPath);
+  }
+
+  @invalidate()
+  writeMergeConflictToIndex(filePath, commonBaseSha, oursSha, theirsSha) {
+    return this.git().writeMergeConflictToIndex(filePath, commonBaseSha, oursSha, theirsSha);
+  }
+
+  // Checkout
+
+  @invalidate()
+  checkout(revision, options = {}) {
+    return this.git().checkout(revision, options);
+  }
+
+  @invalidate()
+  checkoutPathsAtRevision(paths, revision = 'HEAD') {
+    return this.git().checkoutFiles(paths, revision);
+  }
+
+  // Remote interactions
+
+  @invalidate()
+  async fetch(branchName) {
+    const remote = await this.getRemoteForBranch(branchName);
+    if (!remote.isPresent()) {
+      return;
+    }
+    await this.git().fetch(remote.getName(), branchName);
+  }
+
+  @invalidate()
+  async pull(branchName) {
+    const remote = await this.getRemoteForBranch(branchName);
+    if (!remote.isPresent()) {
+      return;
+    }
+    await this.git().pull(remote.getName(), branchName);
+  }
+
+  @invalidate()
+  async push(branchName, options) {
+    const remote = await this.getRemoteForBranch(branchName);
+    return this.git().push(remote.getNameOr('origin'), branchName, options);
+  }
+
+  // Configuration
+
+  @invalidate()
+  setConfig(option, value, options) {
+    return this.git().setConfig(option, value, options);
+  }
+
+  // Direct blob interactions
+
+  @invalidate()
+  createBlob(options) {
+    return this.git().createBlob(options);
+  }
+
+  expandBlobToFile(absFilePath, sha) {
+    return this.git().expandBlobToFile(absFilePath, sha);
+  }
+
+  // Discard history
+
+  createDiscardHistoryBlob() {
+    return this.discardHistory.createHistoryBlob();
+  }
+
+  async updateDiscardHistory() {
+    const history = await this.loadHistoryPayload();
+    this.discardHistory.updateHistory(history);
+  }
+
+  async storeBeforeAndAfterBlobs(filePaths, isSafe, destructiveAction, partialDiscardFilePath = null) {
+    const snapshots = await this.discardHistory.storeBeforeAndAfterBlobs(
+      filePaths,
+      isSafe,
+      destructiveAction,
+      partialDiscardFilePath,
+    );
+    if (snapshots) {
+      await this.saveDiscardHistory();
+    }
+    return snapshots;
+  }
+
+  restoreLastDiscardInTempFiles(isSafe, partialDiscardFilePath = null) {
+    return this.discardHistory.restoreLastDiscardInTempFiles(isSafe, partialDiscardFilePath);
+  }
+
+  async popDiscardHistory(partialDiscardFilePath = null) {
+    const removed = await this.discardHistory.popHistory(partialDiscardFilePath);
+    if (removed) {
+      await this.saveDiscardHistory();
+    }
+  }
+
+  clearDiscardHistory(partialDiscardFilePath = null) {
+    this.discardHistory.clearHistory(partialDiscardFilePath);
+    return this.saveDiscardHistory();
+  }
+
+  @invalidate()
+  async discardWorkDirChangesForPaths(paths) {
+    const untrackedFiles = await this.git().getUntrackedFiles();
+    const [filesToRemove, filesToCheckout] = partition(paths, f => untrackedFiles.includes(f));
+    await this.git().checkoutFiles(filesToCheckout);
+    await Promise.all(filesToRemove.map(filePath => {
+      const absPath = path.join(this.workdir(), filePath);
+      return deleteFileOrFolder(absPath);
+    }));
+  }
+
+  // Accessors /////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+  // Index queries
+
+  getStatusesForChangedFiles() {
+    return this.cache.getOrSet('changed-files', () => {
+      return this.git().getStatusesForChangedFiles();
+    });
+  }
+
+  getStagedChangesSinceParentCommit() {
+    return this.cache.getOrSet('staged-changes-since-parent-commit', async () => {
+      try {
+        const stagedFiles = await this.git().diffFileStatus({staged: true, target: 'HEAD~'});
+        return Object.keys(stagedFiles).map(filePath => ({filePath, status: stagedFiles[filePath]}));
+      } catch (e) {
+        if (e.message.includes('ambiguous argument \'HEAD~\'')) {
+          return [];
+        } else {
+          throw e;
+        }
+      }
+    });
+  }
+
+  isPartiallyStaged(fileName) {
+    return this.cache.getOrSet(`is-partially-staged:${fileName}`, () => {
+      return this.git().isPartiallyStaged(fileName);
+    });
+  }
+
+  getFilePatchForPath(filePath, {staged, amending} = {staged: false, amending: false}) {
+    let desc = '';
+    if (staged && amending) {
+      desc = 'p';
+    } else if (staged) {
+      desc = 's';
+    } else {
+      desc = 'u';
+    }
+
+    return this.cache.getOrSet(`file-patch:${desc}:${filePath}`, async () => {
+      const options = {staged, amending};
+      if (amending) {
+        options.baseCommit = 'HEAD~';
+      }
+
+      const rawDiff = await this.git().getDiffForFilePath(filePath, options);
+      if (rawDiff) {
+        const [filePatch] = buildFilePatchesFromRawDiffs([rawDiff]);
+        return filePatch;
+      } else {
+        return null;
+      }
+    });
+  }
+
+  readFileFromIndex(filePath) {
+    return this.cache.getOrSet(`index:${filePath}`, () => {
+      return this.git().readFileFromIndex(filePath);
+    });
+  }
+
+  // Commit access
+
+  getLastCommit() {
+    return this.cache.getOrSet('last-commit', async () => {
+      const {sha, message, unbornRef} = await this.git().getHeadCommit();
+      return unbornRef ? Commit.createUnborn() : new Commit(sha, message);
+    });
+  }
+
+  // Branches
+
+  getBranches() {
+    return this.cache.getOrSet('branches', async () => {
+      const branchNames = await this.git().getBranches();
+      return branchNames.map(branchName => new Branch(branchName));
+    });
+  }
+
+  getCurrentBranch() {
+    return this.cache.getOrSet('current-branch', async () => {
+      const {name, isDetached} = await this.git().getCurrentBranch();
+      return isDetached ? Branch.createDetached(name) : new Branch(name);
+    });
+  }
+
+  // Merging and rebasing status
+
+  isMerging() {
+    return this.git().isMerging();
+  }
+
+  isRebasing() {
+    return this.git().isRebasing();
+  }
+
+  // Remotes
+
+  getRemotes() {
+    return this.cache.getOrSet('remotes', async () => {
+      const remotesInfo = await this.git().getRemotes();
+      return remotesInfo.map(({name, url}) => new Remote(name, url));
+    });
+  }
+
+  getAheadCount(branchName) {
+    return this.cache.getOrSet(`ahead-count:${branchName}`, () => {
+      return this.git().getAheadCount(branchName);
+    });
+  }
+
+  getBehindCount(branchName) {
+    return this.cache.getOrSet(`behind-count:${branchName}`, () => {
+      return this.git().getBehindCount(branchName);
+    });
+  }
+
+  getConfig(option, {local} = {local: false}) {
+    const desc = local ? 'l' : '';
+    return this.cache.getOrSet(`config:${desc}:${option}`, () => {
+      return this.git().getConfig(option, {local});
+    });
+  }
+
+  // Direct blob access
+
+  getBlobContents(sha) {
+    return this.cache.getOrSet(`blob:${sha}`, () => {
+      return this.git().getBlobContents(sha);
+    });
+  }
+
+  // Discard history
+
+  hasDiscardHistory(partialDiscardFilePath = null) {
+    return this.discardHistory.hasHistory(partialDiscardFilePath);
+  }
+
+  getDiscardHistory(partialDiscardFilePath = null) {
+    return this.discardHistory.getHistory(partialDiscardFilePath);
+  }
+
+  getLastHistorySnapshots(partialDiscardFilePath = null) {
+    return this.discardHistory.getLastSnapshots(partialDiscardFilePath);
+  }
+}
+
+State.register(Present);
+
+function partition(array, predicate) {
+  const matches = [];
+  const nonmatches = [];
+  array.forEach(item => {
+    if (predicate(item)) {
+      matches.push(item);
+    } else {
+      nonmatches.push(item);
+    }
+  });
+  return [matches, nonmatches];
+}
+
+function formatCommitMessage(message) {
+  // strip out comments
+  const messageWithoutComments = message.replace(/^#.*$/mg, '').trim();
+
+  // hard wrap message (except for first line) at 72 characters
+  let results = [];
+  messageWithoutComments.split('\n').forEach((line, index) => {
+    if (line.length <= 72 || index === 0) {
+      results.push(line);
+    } else {
+      const matches = line.match(/.{1,72}(\s|$)|\S+?(\s|$)/g)
+        .map(match => {
+          return match.endsWith('\n') ? match.substr(0, match.length - 1) : match;
+        });
+      results = results.concat(matches);
+    }
+  });
+
+  return results.join('\n');
+}
+
+function buildFilePatchesFromRawDiffs(rawDiffs) {
+  let diffLineNumber = 0;
+  return rawDiffs.map(patch => {
+    const hunks = patch.hunks.map(hunk => {
+      let oldLineNumber = hunk.oldStartLine;
+      let newLineNumber = hunk.newStartLine;
+      const hunkLines = hunk.lines.map(line => {
+        const status = HunkLine.statusMap[line[0]];
+        const text = line.slice(1);
+        let hunkLine;
+        if (status === 'unchanged') {
+          hunkLine = new HunkLine(text, status, oldLineNumber, newLineNumber, diffLineNumber++);
+          oldLineNumber++;
+          newLineNumber++;
+        } else if (status === 'added') {
+          hunkLine = new HunkLine(text, status, -1, newLineNumber, diffLineNumber++);
+          newLineNumber++;
+        } else if (status === 'deleted') {
+          hunkLine = new HunkLine(text, status, oldLineNumber, -1, diffLineNumber++);
+          oldLineNumber++;
+        } else if (status === 'nonewline') {
+          hunkLine = new HunkLine(text.substr(1), status, -1, -1, diffLineNumber++);
+        } else {
+          throw new Error(`unknow status type: ${status}`);
+        }
+        return hunkLine;
+      });
+      return new Hunk(
+        hunk.oldStartLine,
+        hunk.newStartLine,
+        hunk.oldLineCount,
+        hunk.newLineCount,
+        hunk.heading,
+        hunkLines,
+      );
+    });
+    return new FilePatch(patch.oldPath, patch.newPath, patch.status, hunks);
+  });
+}
diff --git a/lib/models/repository-states/repo-states.png b/lib/models/repository-states/repo-states.png
new file mode 100644
index 0000000000..d31b310514
Binary files /dev/null and b/lib/models/repository-states/repo-states.png differ
diff --git a/lib/models/repository-states/state.js b/lib/models/repository-states/state.js
new file mode 100644
index 0000000000..95a8dd743c
--- /dev/null
+++ b/lib/models/repository-states/state.js
@@ -0,0 +1,476 @@
+import {nullCommit} from '../commit';
+import {nullBranch} from '../branch';
+
+export const expectedDelegates = [];
+
+/**
+ * Map of registered subclasses to allow states to transition to one another without circular dependencies.
+ * Subclasses of State should call `State.register` to add themselves here.
+ */
+const stateConstructors = new Map();
+
+/**
+ * Methods marked with this decorator on State should be delegated from a Repository to its current state. This will
+ * be verified by a unit test in `repository.test.js`.
+ */
+function shouldDelegate(target, name, descriptor) {
+  expectedDelegates.push(name);
+  return descriptor;
+}
+
+/**
+ * Base class for Repository states. Implements default "null" behavior.
+ */
+export default class State {
+  constructor(repository) {
+    this.repository = repository;
+  }
+
+  static register(Subclass) {
+    stateConstructors.set(Subclass.name, Subclass);
+  }
+
+  // This state has just been entered. Perform any asynchronous initialization that needs to occur.
+  start() {
+    return Promise.resolve();
+  }
+
+  // State probe predicates ////////////////////////////////////////////////////////////////////////////////////////////
+  // Allow external callers to identify which state a Repository is in if necessary.
+
+  @shouldDelegate
+  isLoadingGuess() {
+    return false;
+  }
+
+  @shouldDelegate
+  isAbsentGuess() {
+    return false;
+  }
+
+  @shouldDelegate
+  isAbsent() {
+    return false;
+  }
+
+  @shouldDelegate
+  isLoading() {
+    return false;
+  }
+
+  @shouldDelegate
+  isEmpty() {
+    return false;
+  }
+
+  @shouldDelegate
+  isPresent() {
+    return false;
+  }
+
+  @shouldDelegate
+  isDestroyed() {
+    return false;
+  }
+
+  // Behavior probe predicates /////////////////////////////////////////////////////////////////////////////////////////
+  // Determine specific rendering behavior based on the current state.
+
+  @shouldDelegate
+  isUndetermined() {
+    return false;
+  }
+
+  @shouldDelegate
+  showGitTabInit() {
+    return false;
+  }
+
+  @shouldDelegate
+  showGitTabInitInProgress() {
+    return false;
+  }
+
+  @shouldDelegate
+  showGitTabLoading() {
+    return false;
+  }
+
+  @shouldDelegate
+  showStatusBarTiles() {
+    return false;
+  }
+
+  @shouldDelegate
+  hasDirectory() {
+    return true;
+  }
+
+  // Lifecycle actions /////////////////////////////////////////////////////////////////////////////////////////////////
+  // These generally default to rejecting a Promise with an error.
+
+  @shouldDelegate
+  init() {
+    return unsupportedOperationPromise(this, 'init');
+  }
+
+  @shouldDelegate
+  clone(remoteUrl) {
+    return unsupportedOperationPromise(this, 'clone');
+  }
+
+  @shouldDelegate
+  destroy() {
+    return this.transitionTo('Destroyed');
+  }
+
+  @shouldDelegate
+  refresh() {
+    // No-op
+  }
+
+  @shouldDelegate
+  observeFilesystemChange() {
+    this.repository.refresh();
+  }
+
+  // Git operations ////////////////////////////////////////////////////////////////////////////////////////////////////
+  // These default to rejecting a Promise with an error stating that the operation is not supported in the current
+  // state.
+
+  // Staging and unstaging
+
+  @shouldDelegate
+  stageFiles(paths) {
+    return unsupportedOperationPromise(this, 'stageFiles');
+  }
+
+  @shouldDelegate
+  unstageFiles(paths) {
+    return unsupportedOperationPromise(this, 'unstageFiles');
+  }
+
+  @shouldDelegate
+  stageFilesFromParentCommit(paths) {
+    return unsupportedOperationPromise(this, 'stageFilesFromParentCommit');
+  }
+
+  @shouldDelegate
+  applyPatchToIndex(patch) {
+    return unsupportedOperationPromise(this, 'applyPatchToIndex');
+  }
+
+  @shouldDelegate
+  applyPatchToWorkdir(patch) {
+    return unsupportedOperationPromise(this, 'applyPatchToWorkdir');
+  }
+
+  // Committing
+
+  @shouldDelegate
+  commit(message, options) {
+    return unsupportedOperationPromise(this, 'commit');
+  }
+
+  // Merging
+
+  @shouldDelegate
+  merge(branchName) {
+    return unsupportedOperationPromise(this, 'merge');
+  }
+
+  @shouldDelegate
+  abortMerge() {
+    return unsupportedOperationPromise(this, 'abortMerge');
+  }
+
+  @shouldDelegate
+  checkoutSide(side, paths) {
+    return unsupportedOperationPromise(this, 'checkoutSide');
+  }
+
+  @shouldDelegate
+  mergeFile(oursPath, commonBasePath, theirsPath, resultPath) {
+    return unsupportedOperationPromise(this, 'mergeFile');
+  }
+
+  @shouldDelegate
+  writeMergeConflictToIndex(filePath, commonBaseSha, oursSha, theirsSha) {
+    return unsupportedOperationPromise(this, 'writeMergeConflictToIndex');
+  }
+
+  // Checkout
+
+  @shouldDelegate
+  checkout(revision, options = {}) {
+    return unsupportedOperationPromise(this, 'checkout');
+  }
+
+  @shouldDelegate
+  checkoutPathsAtRevision(paths, revision = 'HEAD') {
+    return unsupportedOperationPromise(this, 'checkoutPathsAtRevision');
+  }
+
+  // Remote interactions
+
+  @shouldDelegate
+  fetch(branchName) {
+    return unsupportedOperationPromise(this, 'fetch');
+  }
+
+  @shouldDelegate
+  pull(branchName) {
+    return unsupportedOperationPromise(this, 'pull');
+  }
+
+  @shouldDelegate
+  push(branchName) {
+    return unsupportedOperationPromise(this, 'push');
+  }
+
+  // Configuration
+
+  @shouldDelegate
+  setConfig(option, value, {replaceAll} = {}) {
+    return unsupportedOperationPromise(this, 'setConfig');
+  }
+
+  // Direct blob interactions
+
+  @shouldDelegate
+  createBlob({filePath, stdin} = {}) {
+    return unsupportedOperationPromise(this, 'createBlob');
+  }
+
+  @shouldDelegate
+  expandBlobToFile(absFilePath, sha) {
+    return unsupportedOperationPromise(this, 'expandBlobToFile');
+  }
+
+  // Discard history
+
+  @shouldDelegate
+  createDiscardHistoryBlob() {
+    return unsupportedOperationPromise(this, 'createDiscardHistoryBlob');
+  }
+
+  @shouldDelegate
+  updateDiscardHistory() {
+    return unsupportedOperationPromise(this, 'updateDiscardHistory');
+  }
+
+  @shouldDelegate
+  storeBeforeAndAfterBlobs(filePaths, isSafe, destructiveAction, partialDiscardFilePath = null) {
+    return unsupportedOperationPromise(this, 'storeBeforeAndAfterBlobs');
+  }
+
+  @shouldDelegate
+  restoreLastDiscardInTempFiles(isSafe, partialDiscardFilePath = null) {
+    return unsupportedOperationPromise(this, 'restoreLastDiscardInTempFiles');
+  }
+
+  @shouldDelegate
+  popDiscardHistory(partialDiscardFilePath = null) {
+    return unsupportedOperationPromise(this, 'popDiscardHistory');
+  }
+
+  @shouldDelegate
+  clearDiscardHistory(partialDiscardFilePath = null) {
+    return unsupportedOperationPromise(this, 'clearDiscardHistory');
+  }
+
+  @shouldDelegate
+  discardWorkDirChangesForPaths(paths) {
+    return unsupportedOperationPromise(this, 'discardWorkDirChangesForPaths');
+  }
+
+  // Accessors /////////////////////////////////////////////////////////////////////////////////////////////////////////
+  // When possible, these default to "empty" results when invoked in states that don't have information available, or
+  // fail in a way that's consistent with the requested information not being found.
+
+  // Index queries
+
+  @shouldDelegate
+  getStatusesForChangedFiles() {
+    return Promise.resolve({
+      stagedFiles: [],
+      unstagedFiles: [],
+      mergeConflictFiles: [],
+    });
+  }
+
+  @shouldDelegate
+  getStagedChangesSinceParentCommit() {
+    return Promise.resolve([]);
+  }
+
+  @shouldDelegate
+  isPartiallyStaged(fileName) {
+    return Promise.resolve(false);
+  }
+
+  @shouldDelegate
+  getFilePatchForPath(filePath, options = {}) {
+    return Promise.resolve(null);
+  }
+
+  @shouldDelegate
+  readFileFromIndex(filePath) {
+    return Promise.reject(new Error(`fatal: Path ${filePath} does not exist (neither on disk nor in the index).`));
+  }
+
+  // Commit access
+
+  @shouldDelegate
+  getLastCommit() {
+    return Promise.resolve(nullCommit);
+  }
+
+  // Branches
+
+  @shouldDelegate
+  getBranches() {
+    return Promise.resolve([]);
+  }
+
+  @shouldDelegate
+  getCurrentBranch() {
+    return Promise.resolve(nullBranch);
+  }
+
+  // Merging and rebasing status
+
+  @shouldDelegate
+  isMerging() {
+    return Promise.resolve(false);
+  }
+
+  @shouldDelegate
+  isRebasing() {
+    return Promise.resolve(false);
+  }
+
+  // Remotes
+
+  @shouldDelegate
+  getRemotes() {
+    return Promise.resolve([]);
+  }
+
+  @shouldDelegate
+  getAheadCount(branchName) {
+    return Promise.resolve(null);
+  }
+
+  @shouldDelegate
+  getBehindCount(branchName) {
+    return Promise.resolve(null);
+  }
+
+  @shouldDelegate
+  getConfig(option, {local} = {}) {
+    return Promise.resolve(null);
+  }
+
+  // Direct blob access
+
+  @shouldDelegate
+  getBlobContents(sha) {
+    return Promise.reject(new Error(`fatal: Not a valid object name ${sha}`));
+  }
+
+  // Discard history
+
+  @shouldDelegate
+  hasDiscardHistory(partialDiscardFilePath = null) {
+    return false;
+  }
+
+  @shouldDelegate
+  getDiscardHistory(partialDiscardFilePath = null) {
+    return [];
+  }
+
+  @shouldDelegate
+  getLastHistorySnapshots(partialDiscardFilePath = null) {
+    return null;
+  }
+
+  // Internal //////////////////////////////////////////////////////////////////////////////////////////////////////////
+  // Non-delegated methods that provide subclasses with convenient access to Repository properties.
+
+  git() {
+    return this.repository.git;
+  }
+
+  workdir() {
+    return this.repository.getWorkingDirectoryPath();
+  }
+
+  // Return a Promise that will resolve once the state transitions from Loading.
+  getLoadPromise() {
+    return this.repository.getLoadPromise();
+  }
+
+  getRemoteForBranch(branchName) {
+    return this.repository.getRemoteForBranch(branchName);
+  }
+
+  saveDiscardHistory() {
+    return this.repository.saveDiscardHistory();
+  }
+
+  // Initiate a transition to another state.
+  transitionTo(stateName, ...payload) {
+    const StateConstructor = stateConstructors.get(stateName);
+    if (StateConstructor === undefined) {
+      throw new Error(`Attempt to transition to unrecognized state ${stateName}`);
+    }
+    return this.repository.transition(this, StateConstructor, ...payload);
+  }
+
+  // Event broadcast
+
+  didDestroy() {
+    return this.repository.emitter.emit('did-destroy');
+  }
+
+  didUpdate() {
+    return this.repository.emitter.emit('did-update');
+  }
+
+  // Parse a DiscardHistory payload from the SHA recorded in config.
+  async loadHistoryPayload() {
+    const historySha = await this.git().getConfig('atomGithub.historySha');
+    if (!historySha) {
+      return {};
+    }
+
+    let blob;
+    try {
+      blob = await this.git().getBlobContents(historySha);
+    } catch (e) {
+      if (/Not a valid object name/.test(e.stdErr)) {
+        return {};
+      }
+
+      throw e;
+    }
+
+    try {
+      return JSON.parse(blob);
+    } catch (e) {
+      return {};
+    }
+  }
+
+  // Debugging assistance.
+
+  toString() {
+    return this.constructor.name;
+  }
+}
+
+function unsupportedOperationPromise(self, opName) {
+  return Promise.reject(new Error(`${opName} is not available in ${self} state`));
+}
diff --git a/lib/models/repository.js b/lib/models/repository.js
index 6b4a0dc137..e3f8d340a7 100644
--- a/lib/models/repository.js
+++ b/lib/models/repository.js
@@ -1,54 +1,16 @@
-import fs from 'fs-extra';
 import path from 'path';
 
-import {Emitter, Disposable} from 'event-kit';
-import {autobind} from 'core-decorators';
+import {Emitter} from 'event-kit';
 
 import CompositeGitStrategy from '../composite-git-strategy';
-import FilePatch from './file-patch';
-import Hunk from './hunk';
-import HunkLine from './hunk-line';
-import DiscardHistory from './discard-history';
-import {readFile, deleteFileOrFolder} from '../helpers';
+import {readFile} from '../helpers';
+import Remote, {nullRemote} from './remote';
+import {Loading, Absent, LoadingGuess, AbsentGuess} from './repository-states';
 
 const MERGE_MARKER_REGEX = /^(>|<){7} \S+$/m;
 
-function partition(array, predicate) {
-  const matches = [];
-  const nonmatches = [];
-  array.forEach(item => {
-    if (predicate(item)) {
-      matches.push(item);
-    } else {
-      nonmatches.push(item);
-    }
-  });
-  return [matches, nonmatches];
-}
-
-async function loadHistoryPayload(git) {
-  const historySha = await git.getConfig('atomGithub.historySha');
-  if (!historySha) {
-    return {};
-  }
-
-  let blob;
-  try {
-    blob = await git.getBlobContents(historySha);
-  } catch (e) {
-    if (/Not a valid object name/.test(e.stdErr)) {
-      return {};
-    }
-
-    throw e;
-  }
-
-  try {
-    return JSON.parse(blob);
-  } catch (e) {
-    return {};
-  }
-}
+// Internal option keys used to designate the desired initial state of a Repository.
+const initialStateSym = Symbol('initialState');
 
 export class AbortMergeError extends Error {
   constructor(code, filePath) {
@@ -70,281 +32,81 @@ export class CommitError extends Error {
 }
 
 export default class Repository {
-  static async open(workingDirectoryPath, gitStrategy) {
-    const strategy = gitStrategy || CompositeGitStrategy.create(workingDirectoryPath);
-    if (await strategy.isGitRepository()) {
-      const history = await loadHistoryPayload(strategy);
-      return new Repository(workingDirectoryPath, strategy, history);
-    } else {
-      return null;
-    }
-  }
+  constructor(workingDirectoryPath, gitStrategy = null, options = {}) {
+    this.workingDirectoryPath = workingDirectoryPath;
+    this.git = gitStrategy || CompositeGitStrategy.create(workingDirectoryPath);
 
-  static async init(workingDirectoryPath, gitStrategy) {
-    const strategy = gitStrategy || CompositeGitStrategy.create(workingDirectoryPath);
-    await strategy.init(workingDirectoryPath);
-    return this.open(workingDirectoryPath, strategy);
-  }
+    this.emitter = new Emitter();
 
-  static async clone(remoteUrl, destDirectory, gitStrategy) {
-    await new Promise((resolve, reject) => {
-      fs.mkdirs(destDirectory, err => (err ? reject(err) : resolve()));
+    this.loadPromise = new Promise(resolve => {
+      const sub = this.onDidChangeState(() => {
+        if (!this.isLoading()) {
+          resolve();
+          sub.dispose();
+        } else if (this.isDestroyed()) {
+          sub.dispose();
+        }
+      });
     });
 
-    const strategy = gitStrategy || CompositeGitStrategy.create(destDirectory);
-    await strategy.clone(remoteUrl, {recursive: true});
-    return this.open(destDirectory, strategy);
+    this.transitionTo(options[initialStateSym] || Loading);
   }
 
-  static githubInfoFromRemote(remote) {
-    //             proto       login   domain         owner    repo
-    const regex = /(?:.+:\/\/)?(?:.+@)?github\.com[:/]([^/]+)\/(.+)/;
-    const match = remote.match(regex);
-    if (match) {
-      return {
-        githubRepo: true,
-        owner: match[1],
-        name: match[2].replace(/\.git$/, ''),
-      };
-    } else {
-      return {
-        githubRepo: false,
-        owner: null,
-        name: null,
-      };
-    }
+  static absent() {
+    return new Repository(null, null, {[initialStateSym]: Absent});
   }
 
-  constructor(workingDirectoryPath, gitStrategy, history) {
-    this.workingDirectoryPath = workingDirectoryPath;
-    this.emitter = new Emitter();
-    this.stagedFilePatchesByPath = new Map();
-    this.stagedFilePatchesSinceParentCommitByPath = new Map();
-    this.unstagedFilePatchesByPath = new Map();
-    this.git = gitStrategy;
-    this.destroyed = false;
-    this.discardHistory = new DiscardHistory(
-      this.createBlob,
-      this.expandBlobToFile,
-      this.mergeFile,
-      this.workingDirectoryPath,
-      {maxHistoryLength: 60},
-    );
-    if (history) { this.discardHistory.updateHistory(history); }
-    const onWindowFocus = () => this.updateDiscardHistory();
-    window.addEventListener('focus', onWindowFocus);
-    this.windowFocusDisposable = new Disposable(() => window.removeEventListener('focus', onWindowFocus));
+  static loadingGuess() {
+    return new Repository(null, null, {[initialStateSym]: LoadingGuess});
   }
 
-  /*
-   * Use `callback` to request user input from all git strategies.
-   */
-  setPromptCallback(callback) {
-    this.git.getImplementers().forEach(strategy => strategy.setPromptCallback(callback));
-  }
-
-  destroy() {
-    this.destroyed = true;
-    this.emitter.emit('did-destroy');
-    this.emitter.dispose();
-    this.windowFocusDisposable.dispose();
+  static absentGuess() {
+    return new Repository(null, null, {[initialStateSym]: AbsentGuess});
   }
 
-  isDestroyed() {
-    return this.destroyed;
-  }
+  // State management //////////////////////////////////////////////////////////////////////////////////////////////////
 
-  onDidDestroy(callback) {
-    return this.emitter.on('did-destroy', callback);
-  }
+  transition(currentState, StateConstructor, ...payload) {
+    const nextState = new StateConstructor(this, ...payload);
+    this.state = nextState;
 
-  onDidUpdate(callback) {
-    return this.emitter.on('did-update', callback);
-  }
-
-  didUpdate() {
+    this.emitter.emit('did-change-state', {from: currentState, to: this.state});
     this.emitter.emit('did-update');
-  }
 
-  getWorkingDirectoryPath() {
-    return this.workingDirectoryPath;
+    return this.state.start();
   }
 
-  getGitDirectoryPath() {
-    return path.join(this.getWorkingDirectoryPath(), '.git');
-  }
-
-  refresh() {
-    /* eslint-disable no-console */
-    this.clearCachedFilePatches();
-    this.fileStatusesPromise = null;
-    this.stagedChangesSinceParentCommitPromise = null;
-    this.didUpdate();
-    /* eslint-enable no-console */
-  }
-
-  isGitRepository() {
-    return this.git.isGitRepository();
-  }
-
-  fetchStatusesForChangedFiles() {
-    return this.git.getStatusesForChangedFiles();
-  }
-
-  getStatusesForChangedFiles() {
-    if (!this.fileStatusesPromise) {
-      this.fileStatusesPromise = this.fetchStatusesForChangedFiles();
-    }
-    return this.fileStatusesPromise;
-  }
-
-  async getUnstagedChanges() {
-    const {unstagedFiles} = await this.getStatusesForChangedFiles();
-    return Object.keys(unstagedFiles).map(filePath => { return {filePath, status: unstagedFiles[filePath]}; });
-  }
-
-  async getStagedChanges() {
-    const {stagedFiles} = await this.getStatusesForChangedFiles();
-    return Object.keys(stagedFiles).map(filePath => { return {filePath, status: stagedFiles[filePath]}; });
-  }
-
-  async getMergeConflicts() {
-    const {mergeConflictFiles} = await this.getStatusesForChangedFiles();
-    return Object.keys(mergeConflictFiles).map(filePath => {
-      return {filePath, status: mergeConflictFiles[filePath]};
-    });
-  }
-
-  async fetchStagedChangesSinceParentCommit() {
-    try {
-      const stagedFiles = await this.git.diffFileStatus({staged: true, target: 'HEAD~'});
-      return Object.keys(stagedFiles).map(filePath => { return {filePath, status: stagedFiles[filePath]}; });
-    } catch (e) {
-      if (e.message.includes('ambiguous argument \'HEAD~\'')) {
-        return [];
-      } else {
-        throw e;
-      }
-    }
-  }
-
-  getStagedChangesSinceParentCommit() {
-    if (!this.stagedChangesSinceParentCommitPromise) {
-      this.stagedChangesSinceParentCommitPromise = this.fetchStagedChangesSinceParentCommit();
-    }
-    return this.stagedChangesSinceParentCommitPromise;
-  }
-
-  clearCachedFilePatches() {
-    this.stagedFilePatchesByPath = new Map();
-    this.stagedFilePatchesSinceParentCommitByPath = new Map();
-    this.unstagedFilePatchesByPath = new Map();
-  }
-
-  isPartiallyStaged(filePath) {
-    return this.git.isPartiallyStaged(filePath);
-  }
-
-  getCachedFilePatchForPath(filePath, {staged, amending} = {}) {
-    if (staged && amending) {
-      return this.stagedFilePatchesSinceParentCommitByPath.get(filePath);
-    } else if (staged) {
-      return this.stagedFilePatchesByPath.get(filePath);
-    } else {
-      return this.unstagedFilePatchesByPath.get(filePath);
-    }
-  }
-
-  cacheFilePatchForPath(filePath, filePatch, {staged, amending} = {}) {
-    if (staged && amending) {
-      this.stagedFilePatchesSinceParentCommitByPath.set(filePath, filePatch);
-    } else if (staged) {
-      this.stagedFilePatchesByPath.set(filePath, filePatch);
-    } else {
-      this.unstagedFilePatchesByPath.set(filePath, filePatch);
-    }
-  }
-
-  async getFilePatchForPath(filePath, options = {}) {
-    const cachedFilePatch = this.getCachedFilePatchForPath(filePath, options);
-    if (cachedFilePatch) { return cachedFilePatch; }
-
-    if (options.amending) { options.baseCommit = 'HEAD~'; }
-    const rawDiff = await this.git.getDiffForFilePath(filePath, options);
-    if (rawDiff) {
-      const [filePatch] = this.buildFilePatchesFromRawDiffs([rawDiff]);
-      this.cacheFilePatchForPath(filePath, filePatch, options);
-      return filePatch;
-    } else {
-      return null;
-    }
+  transitionTo(StateConstructor, ...payload) {
+    return this.transition(this.state, StateConstructor, ...payload);
   }
 
-  buildFilePatchesFromRawDiffs(rawDiffs) {
-    let diffLineNumber = 0;
-    return rawDiffs.map(patch => {
-      const hunks = patch.hunks.map(hunk => {
-        let oldLineNumber = hunk.oldStartLine;
-        let newLineNumber = hunk.newStartLine;
-        const hunkLines = hunk.lines.map(line => {
-          const status = HunkLine.statusMap[line[0]];
-          const text = line.slice(1);
-          let hunkLine;
-          if (status === 'unchanged') {
-            hunkLine = new HunkLine(text, status, oldLineNumber, newLineNumber, diffLineNumber++);
-            oldLineNumber++;
-            newLineNumber++;
-          } else if (status === 'added') {
-            hunkLine = new HunkLine(text, status, -1, newLineNumber, diffLineNumber++);
-            newLineNumber++;
-          } else if (status === 'deleted') {
-            hunkLine = new HunkLine(text, status, oldLineNumber, -1, diffLineNumber++);
-            oldLineNumber++;
-          } else if (status === 'nonewline') {
-            hunkLine = new HunkLine(text.substr(1), status, -1, -1, diffLineNumber++);
-          } else {
-            throw new Error(`unknow status type: ${status}`);
-          }
-          return hunkLine;
-        });
-        return new Hunk(
-          hunk.oldStartLine,
-          hunk.newStartLine,
-          hunk.oldLineCount,
-          hunk.newLineCount,
-          hunk.heading,
-          hunkLines,
-        );
-      });
-      return new FilePatch(patch.oldPath, patch.newPath, patch.status, hunks);
-    });
+  getLoadPromise() {
+    return this.isAbsent() ? Promise.reject(new Error('An absent repository will never load')) : this.loadPromise;
   }
 
-  async stageFiles(paths) {
-    await this.git.stageFiles(paths);
+  /*
+   * Use `callback` to request user input from all git strategies.
+   */
+  setPromptCallback(callback) {
+    this.git.getImplementers().forEach(strategy => strategy.setPromptCallback(callback));
   }
 
-  async unstageFiles(paths) {
-    await this.git.unstageFiles(paths);
-  }
+  // Event subscription ////////////////////////////////////////////////////////////////////////////////////////////////
 
-  async stageFilesFromParentCommit(paths) {
-    await this.git.unstageFiles(paths, 'HEAD~');
+  onDidDestroy(callback) {
+    return this.emitter.on('did-destroy', callback);
   }
 
-  async applyPatchToIndex(filePatch) {
-    const patchStr = filePatch.getHeaderString() + filePatch.toString();
-    await this.git.applyPatch(patchStr, {index: true});
+  onDidChangeState(callback) {
+    return this.emitter.on('did-change-state', callback);
   }
 
-  async applyPatchToWorkdir(filePatch) {
-    const patchStr = filePatch.getHeaderString() + filePatch.toString();
-    await this.git.applyPatch(patchStr);
+  onDidUpdate(callback) {
+    return this.emitter.on('did-update', callback);
   }
 
-  async checkoutPathsAtRevision(paths, revision = 'HEAD') {
-    await this.git.checkoutFiles(paths, revision);
-  }
+  // State-independent actions /////////////////////////////////////////////////////////////////////////////////////////
+  // Actions that use direct filesystem access or otherwise don't need `this.git` to be available.
 
   async pathHasMergeMarkers(relativePath) {
     try {
@@ -355,10 +117,6 @@ export default class Repository {
     }
   }
 
-  getMergeHead() {
-    return this.git.getMergeHead();
-  }
-
   async getMergeMessage() {
     try {
       const contents = await readFile(path.join(this.getWorkingDirectoryPath(), '.git', 'MERGE_MSG'), 'utf8');
@@ -368,200 +126,154 @@ export default class Repository {
     }
   }
 
-  async abortMerge() {
-    await this.git.abortMerge();
-    return this.refresh();
-  }
-
-  checkoutSide(side, paths) {
-    return this.git.checkoutSide(side, paths);
-  }
-
-  isMerging() {
-    return this.git.isMerging();
-  }
-
-  isRebasing() {
-    return this.git.isRebasing();
-  }
-
-  async commit(message, options) {
-    await this.git.commit(this.formatCommitMessage(message), options);
-    this.stagedChangesPromise = null;
-    this.stagedChangesSinceParentCommitPromise = null;
-  }
-
-  getLastCommit() {
-    return this.git.getHeadCommit();
-  }
-
-  formatCommitMessage(message) {
-    // strip out comments
-    const messageWithoutComments = message.replace(/^#.*$/mg, '').trim();
-
-    // hard wrap message (except for first line) at 72 characters
-    let results = [];
-    messageWithoutComments.split('\n').forEach((line, index) => {
-      if (line.length <= 72 || index === 0) {
-        results.push(line);
-      } else {
-        const matches = line.match(/.{1,72}(\s|$)|\S+?(\s|$)/g)
-          .map(match => {
-            return match.endsWith('\n') ? match.substr(0, match.length - 1) : match;
-          });
-        results = results.concat(matches);
-      }
-    });
-
-    return results.join('\n');
-  }
-
-  readFileFromIndex(filePath) {
-    return this.git.readFileFromIndex(filePath);
-  }
-
-  push(branchName, options) {
-    return this.git.push(branchName, options);
-  }
-
-  fetch(branchName) {
-    return this.git.fetch(branchName);
-  }
-
-  pull(branchName) {
-    return this.git.pull(branchName);
-  }
-
-  getAheadCount(branchName) {
-    return this.git.getAheadCount(branchName);
-  }
-
-  getBehindCount(branchName) {
-    return this.git.getBehindCount(branchName);
-  }
-
-  getRemoteForBranch(branchName) {
-    return this.git.getRemoteForBranch(branchName);
-  }
+  // State-independent accessors ///////////////////////////////////////////////////////////////////////////////////////
 
-  getCurrentBranch() {
-    return this.git.getCurrentBranch();
-  }
-
-  getBranches() {
-    return this.git.getBranches();
-  }
-
-  getRemotes() {
-    return this.git.getRemotes();
-  }
-
-  getConfig(configOption, options) {
-    return this.git.getConfig(configOption, options);
-  }
-
-  @autobind
-  setConfig(configOption, configValue, options) {
-    return this.git.setConfig(configOption, configValue, options);
-  }
-
-  async checkout(branchName, options) {
-    await this.git.checkout(branchName, options);
+  getWorkingDirectoryPath() {
+    return this.workingDirectoryPath;
   }
 
-  setCommitState(state) {
-    this.commitState = state;
+  getGitDirectoryPath() {
+    return path.join(this.getWorkingDirectoryPath(), '.git');
   }
 
-  getCommitState() {
-    return this.commitState;
+  isInState(stateName) {
+    return this.state.constructor.name === stateName;
   }
 
-  @autobind
-  createBlob(options = {}) {
-    return this.git.createBlob(options);
+  toString() {
+    return `Repository(state=${this.state.constructor.name}, workdir="${this.getWorkingDirectoryPath()}")`;
   }
 
-  @autobind
-  expandBlobToFile(absFilePath, sha) {
-    return this.git.expandBlobToFile(absFilePath, sha);
-  }
+  // Compound Getters //////////////////////////////////////////////////////////////////////////////////////////////////
+  // Accessor methods for data derived from other, state-provided getters.
 
-  @autobind
-  getBlobContents(sha) {
-    return this.git.getBlobContents(sha);
+  async getUnstagedChanges() {
+    const {unstagedFiles} = await this.getStatusesForChangedFiles();
+    return Object.keys(unstagedFiles).map(filePath => { return {filePath, status: unstagedFiles[filePath]}; });
   }
 
-  @autobind
-  mergeFile(oursPath, commonBasePath, theirsPath, resultPath) {
-    return this.git.mergeFile(oursPath, commonBasePath, theirsPath, resultPath);
+  async getStagedChanges() {
+    const {stagedFiles} = await this.getStatusesForChangedFiles();
+    return Object.keys(stagedFiles).map(filePath => { return {filePath, status: stagedFiles[filePath]}; });
   }
 
-  writeMergeConflictToIndex(filePath, commonBaseSha, oursSha, theirsSha) {
-    return this.git.writeMergeConflictToIndex(filePath, commonBaseSha, oursSha, theirsSha);
+  async getMergeConflicts() {
+    const {mergeConflictFiles} = await this.getStatusesForChangedFiles();
+    return Object.keys(mergeConflictFiles).map(filePath => {
+      return {filePath, status: mergeConflictFiles[filePath]};
+    });
   }
 
-  async createDiscardHistoryBlob() {
-    return await this.discardHistory.createHistoryBlob();
+  async getRemoteForBranch(branchName) {
+    const name = await this.getConfig(`branch.${branchName}.remote`);
+    if (name === null) {
+      return nullRemote;
+    } else {
+      return new Remote(name);
+    }
   }
 
   async saveDiscardHistory() {
     const historySha = await this.createDiscardHistoryBlob();
     await this.setConfig('atomGithub.historySha', historySha);
   }
+}
 
-  async updateDiscardHistory() {
-    const history = await loadHistoryPayload(this.git);
-    this.discardHistory.updateHistory(history);
-  }
-
-  async storeBeforeAndAfterBlobs(filePaths, isSafe, destructiveAction, partialDiscardFilePath = null) {
-    const snapshots = await this.discardHistory.storeBeforeAndAfterBlobs(
-      filePaths,
-      isSafe,
-      destructiveAction,
-      partialDiscardFilePath,
-    );
-    if (snapshots) { await this.saveDiscardHistory(); }
-    return snapshots;
-  }
-
-  async restoreLastDiscardInTempFiles(isSafe, partialDiscardFilePath = null) {
-    return await this.discardHistory.restoreLastDiscardInTempFiles(isSafe, partialDiscardFilePath);
-  }
-
-  async popDiscardHistory(partialDiscardFilePath = null) {
-    const removed = await this.discardHistory.popHistory(partialDiscardFilePath);
-    if (removed) { await this.saveDiscardHistory(); }
-  }
-
-  async clearDiscardHistory(partialDiscardFilePath = null) {
-    this.discardHistory.clearHistory(partialDiscardFilePath);
-    await this.saveDiscardHistory();
-  }
-
-  hasDiscardHistory(partialDiscardFilePath = null) {
-    return this.discardHistory.hasHistory(partialDiscardFilePath);
-  }
-
-  @autobind
-  getDiscardHistory(partialDiscardFilePath = null) {
-    return this.discardHistory.getHistory(partialDiscardFilePath);
-  }
-
-  @autobind
-  getLastHistorySnapshots(partialDiscardFilePath = null) {
-    return this.discardHistory.getLastSnapshots(partialDiscardFilePath);
-  }
-
-  @autobind
-  async discardWorkDirChangesForPaths(paths) {
-    const untrackedFiles = await this.git.getUntrackedFiles();
-    const [filesToRemove, filesToCheckout] = partition(paths, f => untrackedFiles.includes(f));
-    await this.git.checkoutFiles(filesToCheckout);
-    await Promise.all(filesToRemove.map(filePath => {
-      const absPath = path.join(this.getWorkingDirectoryPath(), filePath);
-      return deleteFileOrFolder(absPath);
-    }));
-  }
+// The methods named here will be delegated to the current State.
+//
+// This list should match the methods decorated with @shouldDelegate in `lib/models/repository-states/state.js`. A test
+// case in `test/models/repository.test.js` ensures that these sets match.
+//
+// Duplicated here rather than just using `expectedDelegates` directly so that this file is grep-friendly for answering
+// the question of "what all can a Repository do exactly".
+const delegates = [
+  'isLoadingGuess',
+  'isAbsentGuess',
+  'isAbsent',
+  'isLoading',
+  'isEmpty',
+  'isPresent',
+  'isDestroyed',
+
+  'isUndetermined',
+  'showGitTabInit',
+  'showGitTabInitInProgress',
+  'showGitTabLoading',
+  'showStatusBarTiles',
+  'hasDirectory',
+
+  'init',
+  'clone',
+  'destroy',
+  'refresh',
+  'observeFilesystemChange',
+
+  'stageFiles',
+  'unstageFiles',
+  'stageFilesFromParentCommit',
+  'applyPatchToIndex',
+  'applyPatchToWorkdir',
+
+  'commit',
+
+  'merge',
+  'abortMerge',
+  'checkoutSide',
+  'mergeFile',
+  'writeMergeConflictToIndex',
+
+  'checkout',
+  'checkoutPathsAtRevision',
+
+  'fetch',
+  'pull',
+  'push',
+
+  'setConfig',
+
+  'createBlob',
+  'expandBlobToFile',
+
+  'createDiscardHistoryBlob',
+  'updateDiscardHistory',
+  'storeBeforeAndAfterBlobs',
+  'restoreLastDiscardInTempFiles',
+  'popDiscardHistory',
+  'clearDiscardHistory',
+  'discardWorkDirChangesForPaths',
+
+  'getStatusesForChangedFiles',
+  'getStagedChangesSinceParentCommit',
+  'isPartiallyStaged',
+  'getFilePatchForPath',
+  'readFileFromIndex',
+
+  'getLastCommit',
+
+  'getBranches',
+  'getCurrentBranch',
+
+  'isMerging',
+  'isRebasing',
+
+  'getRemotes',
+
+  'getAheadCount',
+  'getBehindCount',
+
+  'getConfig',
+
+  'getBlobContents',
+
+  'hasDiscardHistory',
+  'getDiscardHistory',
+  'getLastHistorySnapshots',
+];
+
+for (let i = 0; i < delegates.length; i++) {
+  const delegate = delegates[i];
+
+  Repository.prototype[delegate] = function(...args) {
+    return this.state[delegate](...args);
+  };
 }
diff --git a/lib/models/workdir-cache.js b/lib/models/workdir-cache.js
new file mode 100644
index 0000000000..3c0c7b1c77
--- /dev/null
+++ b/lib/models/workdir-cache.js
@@ -0,0 +1,92 @@
+import path from 'path';
+import fs from 'fs';
+
+/**
+ * Locate the nearest git working directory above a given starting point, caching results.
+ */
+export default class WorkdirCache {
+  constructor(maxSize = 1000) {
+    this.maxSize = maxSize;
+    this.known = new Map();
+  }
+
+  async find(startDir) {
+    try {
+      const resolvedDir = await this.resolvePath(startDir);
+      const cached = this.known.get(resolvedDir);
+      if (cached !== undefined) {
+        return cached;
+      }
+
+      const workDir = await this.walkToRoot(resolvedDir);
+
+      if (this.known.size >= this.maxSize) {
+        this.known.clear();
+      }
+      this.known.set(resolvedDir, workDir);
+      return workDir;
+    } catch (e) {
+      if (e.code === 'ENOENT') {
+        return null;
+      }
+
+      throw e;
+    }
+  }
+
+  async invalidate(baseDir) {
+    const resolvedBase = await this.resolvePath(baseDir);
+    for (const cachedPath of this.known.keys()) {
+      if (cachedPath.startsWith(resolvedBase)) {
+        this.known.delete(cachedPath);
+      }
+    }
+  }
+
+  resolvePath(unresolvedPath) {
+    return new Promise((resolve, reject) => {
+      fs.realpath(unresolvedPath, (err, resolved) => (err ? reject(err) : resolve(resolved)));
+    });
+  }
+
+  walkToRoot(initialDir) {
+    return new Promise((resolve, reject) => {
+      let currentDir = initialDir;
+
+      const check = () => {
+        const dotGit = path.join(currentDir, '.git');
+        fs.stat(dotGit, (statError, stat) => {
+          if (statError) {
+            if (statError.code === 'ENOENT' || statError.code === 'ENOTDIR') {
+              // File not found. This is not the directory we're looking for. Continue walking.
+              return walk();
+            }
+
+            return reject(statError);
+          }
+
+          if (!stat.isDirectory()) {
+            // A file called ".git". Probably not a good idea, but still not a git working directory.
+            return walk();
+          }
+
+          // .git directory found! Mission accomplished.
+          return resolve(currentDir);
+        });
+      };
+
+      const walk = () => {
+        const parentDir = path.resolve(currentDir, '..');
+        if (parentDir === currentDir) {
+          // Root directory. Traversal done, no working directory found.
+          resolve(null);
+        }
+
+        currentDir = parentDir;
+        check();
+      };
+
+      check();
+    });
+  }
+}
diff --git a/lib/models/workdir-context-pool.js b/lib/models/workdir-context-pool.js
new file mode 100644
index 0000000000..278e532722
--- /dev/null
+++ b/lib/models/workdir-context-pool.js
@@ -0,0 +1,127 @@
+import compareSets from 'compare-sets';
+
+import {Emitter, CompositeDisposable} from 'event-kit';
+import WorkdirContext, {absentWorkdirContext} from './workdir-context';
+
+/**
+ * Manage a WorkdirContext for each open directory.
+ */
+export default class WorkdirContextPool {
+
+  /**
+   * Options will be passed to each `WorkdirContext` as it is created.
+   */
+  constructor(options = {}) {
+    this.options = options;
+
+    this.contexts = new Map();
+    this.emitter = new Emitter();
+  }
+
+  size() {
+    return this.contexts.size;
+  }
+
+  /**
+   * Access the context mapped to a known directory.
+   */
+  getContext(directory) {
+    return this.contexts.get(directory) || absentWorkdirContext;
+  }
+
+  add(directory, options = {}) {
+    if (this.contexts.has(directory)) {
+      return this.getContext(directory);
+    }
+
+    let savedResolutionProgress = {};
+    if (options.resolutionProgressByPath) {
+      savedResolutionProgress = options.resolutionProgressByPath[directory] || {};
+    }
+
+    const context = new WorkdirContext(directory, {savedResolutionProgress, ...this.options, ...options});
+    this.contexts.set(directory, context);
+
+    const disposable = new CompositeDisposable();
+
+    const forwardEvent = (subMethod, emitEventName) => {
+      const emit = () => this.emitter.emit(emitEventName, context);
+      disposable.add(context[subMethod](emit));
+    };
+
+    forwardEvent('onDidStartObserver', 'did-start-observer');
+    forwardEvent('onDidChangeWorkdirOrHead', 'did-change-workdir-or-head');
+    forwardEvent('onDidChangeRepositoryState', 'did-change-repository-state');
+    forwardEvent('onDidUpdateRepository', 'did-update-repository');
+    forwardEvent('onDidDestroyRepository', 'did-destroy-repository');
+
+    disposable.add(this.onDidRemoveContext(removed => {
+      if (removed === context) {
+        disposable.dispose();
+      }
+    }));
+
+    return context;
+  }
+
+  replace(directory, options = {}) {
+    this.remove(directory);
+    this.add(directory, options);
+  }
+
+  remove(directory) {
+    const existing = this.contexts.get(directory);
+    this.contexts.delete(directory);
+
+    if (existing) {
+      this.emitter.emit('did-remove-context', existing);
+      existing.destroy();
+    }
+  }
+
+  set(directories, options = {}) {
+    const previous = new Set(this.contexts.keys());
+    const {added, removed} = compareSets(previous, directories);
+
+    for (const directory of added) {
+      this.add(directory, options);
+    }
+    for (const directory of removed) {
+      this.remove(directory);
+    }
+  }
+
+  withResidentContexts(callback) {
+    for (const [workdir, context] of this.contexts) {
+      callback(workdir, context);
+    }
+  }
+
+  onDidStartObserver(callback) {
+    return this.emitter.on('did-start-observer', callback);
+  }
+
+  onDidChangeWorkdirOrHead(callback) {
+    return this.emitter.on('did-change-workdir-or-head', callback);
+  }
+
+  onDidRemoveContext(callback) {
+    return this.emitter.on('did-remove-context', callback);
+  }
+
+  onDidChangeRepositoryState(callback) {
+    return this.emitter.on('did-change-repository-state', callback);
+  }
+
+  onDidUpdateRepository(callback) {
+    return this.emitter.on('did-update-repository', callback);
+  }
+
+  onDidDestroyRepository(callback) {
+    return this.emitter.on('did-destroy-repository', callback);
+  }
+
+  clear() {
+    this.withResidentContexts(workdir => this.remove(workdir));
+  }
+}
diff --git a/lib/models/workdir-context.js b/lib/models/workdir-context.js
new file mode 100644
index 0000000000..3d796a7829
--- /dev/null
+++ b/lib/models/workdir-context.js
@@ -0,0 +1,197 @@
+import {Emitter, CompositeDisposable} from 'event-kit';
+import {autobind} from 'core-decorators';
+
+import Repository from './repository';
+import ResolutionProgress from './conflicts/resolution-progress';
+import FileSystemChangeObserver from './file-system-change-observer';
+import WorkspaceChangeObserver from './workspace-change-observer';
+
+const createRepoSym = Symbol('createRepo');
+
+/*
+ * Bundle of model objects associated with a git working directory.
+ *
+ * Provides synchronous access to each model in the form of a getter method that returns the model or `null` if it
+ * has not yet been initialized, and asynchronous access in the form of a Promise generation method that will resolve
+ * once the model is available. Initializes the platform-appropriate change observer and proxies select filesystem
+ * change events.
+ */
+export default class WorkdirContext {
+
+  /*
+   * Available options:
+   * - `options.savedResolutionProgress`: Serialized state used to initialize the ResolutionProgress.
+   * - `options.window`: Browser window global, used on Linux by the WorkspaceChangeObserver.
+   * - `options.workspace`: Atom's workspace singleton, used on Linux by the WorkspaceChangeObserver.
+   * - `options.promptCallback`: Callback used to collect information interactively through Atom.
+   */
+  constructor(directory, options = {}) {
+    this.directory = directory;
+    this.repository = (options[createRepoSym] || (() => new Repository(directory)))();
+
+    const {window: theWindow, workspace, promptCallback} = options;
+    this.savedResolutionProgress = options.savedResolutionProgress || {};
+
+    this.destroyed = false;
+    this.emitter = new Emitter();
+    this.subs = new CompositeDisposable();
+
+    this.observer = process.platform === 'linux'
+      ? new WorkspaceChangeObserver(theWindow, workspace, this.repository)
+      : new FileSystemChangeObserver(this.repository);
+    this.resolutionProgress = new ResolutionProgress();
+
+    if (promptCallback) {
+      this.repository.setPromptCallback(promptCallback);
+    }
+
+    // Wire up event forwarding among models
+    this.subs.add(this.repository.onDidChangeState(this.repositoryChangedState));
+    this.subs.add(this.observer.onDidChange(payload => this.repository.observeFilesystemChange(payload)));
+    this.subs.add(this.observer.onDidChangeWorkdirOrHead(() => this.emitter.emit('did-change-workdir-or-head')));
+
+    // If a pre-loaded Repository was provided, broadcast an initial state change event.
+    this.repositoryChangedState({from: null, to: this.repository.state});
+  }
+
+  static guess(options) {
+    const projectPathCount = options.projectPathCount || 0;
+    const initPathCount = options.initPathCount || 0;
+
+    const createRepo = (projectPathCount === 1 || (projectPathCount === 0 && initPathCount === 1)) ?
+      () => Repository.loadingGuess() :
+      () => Repository.absentGuess();
+
+    return new WorkdirContext(null, {[createRepoSym]: createRepo});
+  }
+
+  /**
+   * Respond to changes in `Repository` state. Load resolution progress and start the change observer when it becomes
+   * present. Stop the change observer when it is destroyed. Re-broadcast the event to context subscribers
+   * regardless.
+   *
+   * The ResolutionProgress will be loaded before the change event is re-broadcast, but change observer modifications
+   * will not be complete.
+   */
+  @autobind
+  async repositoryChangedState(payload) {
+    if (this.destroyed) {
+      return;
+    }
+
+    if (this.repository.isPresent()) {
+      this.observer.start().then(() => this.emitter.emit('did-start-observer'));
+
+      const head = await this.repository.getLastCommit();
+      this.resolutionProgress.load(head.getSha(), this.savedResolutionProgress);
+    } else if (this.repository.isDestroyed()) {
+      this.emitter.emit('did-destroy-repository');
+
+      this.observer.destroy();
+    }
+
+    this.emitter.emit('did-change-repository-state', payload);
+  }
+
+  isPresent() {
+    return true;
+  }
+
+  isDestroyed() {
+    return this.destroyed;
+  }
+
+  // Event subscriptions
+
+  onDidStartObserver(callback) {
+    return this.emitter.on('did-start-observer', callback);
+  }
+
+  onDidChangeWorkdirOrHead(callback) {
+    return this.emitter.on('did-change-workdir-or-head', callback);
+  }
+
+  onDidChangeRepositoryState(callback) {
+    return this.emitter.on('did-change-repository-state', callback);
+  }
+
+  onDidUpdateRepository(callback) {
+    return this.emitter.on('did-update-repository', callback);
+  }
+
+  onDidDestroyRepository(callback) {
+    return this.emitter.on('did-destroy-repository', callback);
+  }
+
+  /**
+   * Return a Promise that will resolve the next time that a Repository transitions to the requested state. Most
+   * useful for test cases; most callers should prefer subscribing to `onDidChangeRepositoryState`.
+   */
+  getRepositoryStatePromise(stateName) {
+    return new Promise(resolve => {
+      const sub = this.onDidChangeRepositoryState(() => {
+        if (this.repository.isInState(stateName)) {
+          resolve();
+          sub.dispose();
+        }
+      });
+    });
+  }
+
+  /**
+   * Return a Promise that will resolve the next time that a ChangeObserver successfully starts. Most useful for
+   * test cases.
+   */
+  getObserverStartedPromise() {
+    return new Promise(resolve => {
+      const sub = this.onDidStartObserver(() => {
+        resolve();
+        sub.dispose();
+      });
+    });
+  }
+
+  getWorkingDirectory() {
+    return this.directory;
+  }
+
+  getRepository() {
+    return this.repository;
+  }
+
+  getChangeObserver() {
+    return this.observer;
+  }
+
+  getResolutionProgress() {
+    return this.resolutionProgress;
+  }
+
+  /*
+   * Cleanly destroy any models that need to be cleaned, including stopping the filesystem watcher.
+   */
+  async destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    this.destroyed = true;
+
+    this.repository.destroy();
+    this.subs.dispose();
+    this.emitter.dispose();
+
+    await this.observer.destroy();
+  }
+}
+
+class AbsentWorkdirContext extends WorkdirContext {
+  constructor() {
+    super(null, {[createRepoSym]: () => Repository.absent()});
+  }
+
+  isPresent() {
+    return false;
+  }
+}
+
+export const absentWorkdirContext = new AbsentWorkdirContext();
diff --git a/lib/models/workspace-change-observer.js b/lib/models/workspace-change-observer.js
index 645ea391f0..b920d0e74e 100644
--- a/lib/models/workspace-change-observer.js
+++ b/lib/models/workspace-change-observer.js
@@ -6,30 +6,31 @@ import {autobind} from 'core-decorators';
 import EventLogger from './event-logger';
 
 export default class WorkspaceChangeObserver {
-  constructor(window, workspace, repositoryPromise) {
+  constructor(window, workspace, repository) {
     this.window = window;
-    this.repositoryPromise = repositoryPromise;
+    this.repository = repository;
     this.workspace = workspace;
     this.observedBuffers = new WeakSet();
     this.emitter = new Emitter();
+    this.disposables = new CompositeDisposable();
     this.logger = new EventLogger('WorkspaceChangeObserver');
+    this.started = false;
   }
 
   async start() {
-    this.started = true;
-    const focusHandler = async event => {
-      if (await this.repositoryPromise) {
+    const focusHandler = event => {
+      if (this.repository) {
         this.logger.showEvents([event]);
         this.emitter.emit('did-change');
       }
     };
     this.window.addEventListener('focus', focusHandler);
-    this.disposables = new CompositeDisposable();
     this.disposables.add(
       this.workspace.observeTextEditors(this.observeTextEditor),
       new Disposable(() => this.window.removeEventListener('focus', focusHandler)),
     );
     await this.watchActiveRepositoryGitDirectory();
+    this.started = true;
     return this;
   }
 
@@ -41,6 +42,18 @@ export default class WorkspaceChangeObserver {
     await this.stopCurrentFileWatcher();
   }
 
+  isStarted() {
+    return this.started;
+  }
+
+  didChange(payload) {
+    this.emitter.emit('did-change', payload);
+  }
+
+  didChangeWorkdirOrHead() {
+    this.emitter.emit('did-change-workdir-or-head');
+  }
+
   onDidChange(callback) {
     return this.emitter.on('did-change', callback);
   }
@@ -50,12 +63,12 @@ export default class WorkspaceChangeObserver {
   }
 
   getRepository() {
-    return this.repositoryPromise;
+    return this.repository;
   }
 
   async watchActiveRepositoryGitDirectory() {
-    const repository = await this.getRepository();
-    const gitDirectoryPath = await repository.getGitDirectoryPath();
+    const repository = this.getRepository();
+    const gitDirectoryPath = repository.getGitDirectoryPath();
     if (repository) {
       this.currentFileWatcher = await nsfw(
         gitDirectoryPath,
@@ -96,8 +109,8 @@ export default class WorkspaceChangeObserver {
     }
   }
 
-  async activeRepositoryContainsPath(path) {
-    const repository = await this.getRepository();
+  activeRepositoryContainsPath(path) {
+    const repository = this.getRepository();
     if (repository) {
       return path.indexOf(repository.getWorkingDirectoryPath()) !== -1;
     } else {
@@ -111,8 +124,8 @@ export default class WorkspaceChangeObserver {
     if (!this.observedBuffers.has(buffer)) {
       this.observedBuffers.add(buffer);
       const disposables = new CompositeDisposable(
-        buffer.onDidSave(async () => {
-          if (await this.activeRepositoryContainsPath(buffer.getPath())) {
+        buffer.onDidSave(() => {
+          if (this.activeRepositoryContainsPath(buffer.getPath())) {
             this.logger.showEvents([{
               handler: 'onDidSave',
               path: buffer.getPath(),
@@ -120,8 +133,8 @@ export default class WorkspaceChangeObserver {
             this.emitter.emit('did-change');
           }
         }),
-        buffer.onDidReload(async () => {
-          if (await this.activeRepositoryContainsPath(buffer.getPath())) {
+        buffer.onDidReload(() => {
+          if (this.activeRepositoryContainsPath(buffer.getPath())) {
             this.logger.showEvents([{
               handler: 'onDidReload',
               path: buffer.getPath(),
@@ -129,8 +142,8 @@ export default class WorkspaceChangeObserver {
             this.emitter.emit('did-change');
           }
         }),
-        buffer.onDidDestroy(async () => {
-          if (await this.activeRepositoryContainsPath(buffer.getPath())) {
+        buffer.onDidDestroy(() => {
+          if (this.activeRepositoryContainsPath(buffer.getPath())) {
             this.logger.showEvents([{
               handler: 'onDidDestroy',
               path: buffer.getPath(),
diff --git a/lib/prop-types.js b/lib/prop-types.js
index f95338d935..bce4df5ed5 100644
--- a/lib/prop-types.js
+++ b/lib/prop-types.js
@@ -11,16 +11,22 @@ export const DOMNodePropType = (props, propName, componentName) => {
 };
 
 export const RemotePropType = PropTypes.shape({
-  name: PropTypes.string,
-  url: PropTypes.string,
-  info: PropTypes.shape({
-    githubRepo: PropTypes.bool.isRequired,
-    owner: PropTypes.string,
-    name: PropTypes.string,
-  }).isRequired,
+  getName: PropTypes.func.isRequired,
+  getUrl: PropTypes.func.isRequired,
+  isGithubRepo: PropTypes.func.isRequired,
+  getOwner: PropTypes.func.isRequired,
+  getRepo: PropTypes.func.isRequired,
 });
 
 export const BranchPropType = PropTypes.shape({
-  name: PropTypes.string.isRequired,
-  isDetached: PropTypes.bool.isRequired,
+  getName: PropTypes.func.isRequired,
+  isDetached: PropTypes.func.isRequired,
+  isPresent: PropTypes.func.isRequired,
+});
+
+export const CommitPropType = PropTypes.shape({
+  getSha: PropTypes.func.isRequired,
+  getMessage: PropTypes.func.isRequired,
+  isUnbornRef: PropTypes.func.isRequired,
+  isPresent: PropTypes.func.isRequired,
 });
diff --git a/lib/switchboard.js b/lib/switchboard.js
index 50c4e2d27d..45a66603b6 100644
--- a/lib/switchboard.js
+++ b/lib/switchboard.js
@@ -1,4 +1,4 @@
-import {Emitter} from 'atom'; // FIXME import from event-kit instead
+import {Emitter} from 'event-kit';
 
 /*
  * Register callbacks and construct Promises to wait for the next occurrence of specific events that occur throughout
@@ -58,7 +58,11 @@ export default class Switchboard {
   'BeginStageOperation',
   'FinishStageOperation',
   'ChangePatch',
+  'ScheduleActiveContextUpdate',
+  'BeginActiveContextUpdate',
+  'FinishActiveContextUpdate',
   'FinishRender',
+  'FinishContextChangeRender',
 ].forEach(eventName => {
   Switchboard.prototype[`did${eventName}`] = function(payload) {
     this.did(eventName, payload);
diff --git a/lib/views/branch-menu-view.js b/lib/views/branch-menu-view.js
index 18c6ddecfd..3a8326ab68 100644
--- a/lib/views/branch-menu-view.js
+++ b/lib/views/branch-menu-view.js
@@ -11,17 +11,12 @@ export default class BranchMenuView extends React.Component {
     workspace: PropTypes.object.isRequired,
     commandRegistry: PropTypes.object.isRequired,
     notificationManager: PropTypes.object.isRequired,
-    branches: PropTypes.arrayOf(PropTypes.string),
-    currentBranch: BranchPropType,
+    branches: PropTypes.arrayOf(BranchPropType).isRequired,
+    currentBranch: BranchPropType.isRequired,
     checkout: PropTypes.func,
   }
 
   static defaultProps = {
-    branches: [],
-    currentBranch: {
-      name: '',
-      isDetached: true,
-    },
     checkout: () => Promise.resolve(),
   }
 
@@ -35,10 +30,10 @@ export default class BranchMenuView extends React.Component {
   }
 
   render() {
-    const currentBranchName = this.state.checkingOutBranch || this.props.currentBranch.name;
-    const branches = this.props.branches;
-    if (this.state.checkingOutBranch && this.props.branches.indexOf(this.state.checkingOutBranch) === -1) {
-      branches.push(this.state.checkingOutBranch);
+    const currentBranchName = this.state.checkingOutBranch || this.props.currentBranch.getName();
+    const branchNames = this.props.branches.map(branch => branch.getName());
+    if (this.state.checkingOutBranch && branchNames.indexOf(this.state.checkingOutBranch) === -1) {
+      branchNames.push(this.state.checkingOutBranch);
     }
 
     const newBranchEditor = (
@@ -60,11 +55,11 @@ export default class BranchMenuView extends React.Component {
         className="github-BranchMenuView-item github-BranchMenuView-select input-select"
         onChange={this.didSelectItem}
         value={currentBranchName}>
-        {this.props.currentBranch.isDetached &&
-          <option key="detached" value="detached" disabled>{this.props.currentBranch.name}</option>
+        {this.props.currentBranch.isDetached() &&
+          <option key="detached" value="detached" disabled>{this.props.currentBranch.getName()}</option>
         }
-        {branches.map(branch => {
-          return <option key={branch} value={branch}>{branch}</option>;
+        {branchNames.map(branchName => {
+          return <option key={branchName} value={branchName}>{branchName}</option>;
         })}
       </select>
     );
diff --git a/lib/views/branch-view.js b/lib/views/branch-view.js
index 06d70a96b4..e624e4dd49 100644
--- a/lib/views/branch-view.js
+++ b/lib/views/branch-view.js
@@ -5,18 +5,18 @@ import {BranchPropType} from '../prop-types';
 
 export default class BranchView extends React.Component {
   static propTypes = {
-    currentBranch: BranchPropType,
+    currentBranch: BranchPropType.isRequired,
   }
 
   render() {
     const classNames = cx(
-      'github-branch', 'inline-block', {'github-branch-detached': this.props.currentBranch.isDetached},
+      'github-branch', 'inline-block', {'github-branch-detached': this.props.currentBranch.isDetached()},
     );
 
     return (
       <div className={classNames} ref={e => { this.element = e; }}>
         <span className="icon icon-git-branch" />
-        <span className="branch-label">{this.props.currentBranch.name}</span>
+        <span className="branch-label">{this.props.currentBranch.getName()}</span>
       </div>
     );
   }
diff --git a/lib/views/changed-files-count-view.js b/lib/views/changed-files-count-view.js
index 543855ea27..61eabe822f 100644
--- a/lib/views/changed-files-count-view.js
+++ b/lib/views/changed-files-count-view.js
@@ -3,8 +3,8 @@ import PropTypes from 'prop-types';
 
 export default class ChangedFilesCountView extends React.Component {
   static propTypes = {
-    changedFilesCount: PropTypes.number,
-    didClick: PropTypes.func,
+    changedFilesCount: PropTypes.number.isRequired,
+    didClick: PropTypes.func.isRequired,
   }
 
   static defaultProps = {
diff --git a/lib/views/commit-view.js b/lib/views/commit-view.js
index eb57d54cef..70591951d5 100644
--- a/lib/views/commit-view.js
+++ b/lib/views/commit-view.js
@@ -50,7 +50,11 @@ export default class CommitView {
     }
 
     const showAbortMergeButton = this.props.isMerging || null;
-    const showAmendBox = (!this.props.isMerging && !this.props.lastCommit.unbornRef) || null;
+    const showAmendBox = (
+      !this.props.isMerging &&
+      this.props.lastCommit.isPresent() &&
+      !this.props.lastCommit.isUnbornRef()
+    ) || null;
 
     return (
       <div className="github-CommitView" ref="CommitView">
@@ -106,7 +110,7 @@ export default class CommitView {
   @autobind
   async commit() {
     if (await this.props.prepareToCommit() && this.isCommitButtonEnabled()) {
-      this.props.commit(this.editor.getText());
+      await this.props.commit(this.editor.getText());
     } else {
       this.focus();
     }
@@ -127,13 +131,14 @@ export default class CommitView {
   isCommitButtonEnabled() {
     return this.props.stagedChangesExist &&
       !this.props.mergeConflictsExist &&
+      this.props.lastCommit.isPresent() &&
       this.editor &&
       this.editor.getText().length !== 0;
   }
 
   commitButtonText() {
     if (this.props.isAmending) {
-      return `Amend commit (${shortenSha(this.props.lastCommit.sha)})`;
+      return `Amend commit (${shortenSha(this.props.lastCommit.getSha())})`;
     } else {
       if (this.props.branchName) {
         return `Commit to ${this.props.branchName}`;
diff --git a/lib/views/git-tab-view.js b/lib/views/git-tab-view.js
index b39d7b697b..4e11e30d61 100644
--- a/lib/views/git-tab-view.js
+++ b/lib/views/git-tab-view.js
@@ -5,6 +5,7 @@ import {Disposable, CompositeDisposable} from 'event-kit';
 
 import etch from 'etch';
 import {autobind} from 'core-decorators';
+import cx from 'classnames';
 
 import StagingView from './staging-view';
 import GitLogo from './git-logo';
@@ -14,7 +15,6 @@ export default class GitTabView {
   constructor(props) {
     this.props = props;
     etch.initialize(this);
-    this.repoCreationInProgress = false;
 
     this.element.addEventListener('focusin', this.rememberLastFocus);
 
@@ -34,29 +34,30 @@ export default class GitTabView {
   }
 
   render() {
-    if (!this.props.repository) {
+    if (this.props.repository.showGitTabInit()) {
+      const inProgress = this.props.repository.showGitTabInitInProgress();
+      const message = this.props.repository.hasDirectory() ?
+        'Initialize this project directory with a git repository' :
+        'Initialize a new project directory with a git repository';
+
       return (
-        <div className="github-Panel" tabIndex="-1">
+        <div className="github-Panel is-empty" tabIndex="-1">
           <div ref="noRepoMessage" className="github-Panel no-repository">
             <div className="large-icon">
               <GitLogo />
             </div>
-            <div className="initialize-repo-description">Initialize this project directory with a Git repository</div>
-            <button onclick={this.initializeRepo} disabled={this.repoCreationInProgress} className="btn btn-primary">
-              {this.repoCreationInProgress ? 'Creating repository...' : 'Create repository'}
+            <div className="initialize-repo-description">{message}</div>
+            <button onclick={this.initializeRepo} disabled={inProgress} className="btn btn-primary">
+              {inProgress ? 'Creating repository...' : 'Create repository'}
             </button>
           </div>
         </div>
       );
-    } else if (this.props.fetchInProgress) {
-      return (
-        <div className="github-Panel" tabIndex="-1">
-          <div ref="repoLoadingMessage" className="github-Panel is-loading">Fetching repository data</div>
-        </div>
-      );
     } else {
+      const isLoading = this.props.fetchInProgress || this.props.repository.showGitTabLoading();
+
       return (
-        <div className="github-Panel" tabIndex="-1">
+        <div className={cx('github-Panel', {'is-loading': isLoading})} tabIndex="-1">
           <StagingView
             ref="stagingView"
             commandRegistry={this.props.commandRegistry}
@@ -78,6 +79,7 @@ export default class GitTabView {
             resolveAsOurs={this.props.resolveAsOurs}
             resolveAsTheirs={this.props.resolveAsTheirs}
             lastCommit={this.props.lastCommit}
+            isLoading={this.props.isLoading}
             isAmending={this.props.isAmending}
             hasUndoHistory={this.props.hasUndoHistory}
             isMerging={this.props.isMerging}
@@ -96,6 +98,7 @@ export default class GitTabView {
             mergeMessage={this.props.mergeMessage}
             isMerging={this.props.isMerging}
             isAmending={this.props.isAmending}
+            isLoading={this.props.isLoading}
             lastCommit={this.props.lastCommit}
             repository={this.props.repository}
           />
@@ -112,14 +115,7 @@ export default class GitTabView {
   @autobind
   async initializeRepo(event) {
     event.preventDefault();
-    this.repoCreationInProgress = true;
-    etch.update(this);
-    try {
-      await this.props.initializeRepo();
-    } finally {
-      this.repoCreationInProgress = false;
-      etch.update(this);
-    }
+    await this.props.initializeRepo();
   }
 
   @autobind
diff --git a/lib/views/init-dialog.js b/lib/views/init-dialog.js
new file mode 100644
index 0000000000..39a445c1d2
--- /dev/null
+++ b/lib/views/init-dialog.js
@@ -0,0 +1,121 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import {autobind} from 'core-decorators';
+import {CompositeDisposable} from 'event-kit';
+
+import Commands, {Command} from './commands';
+
+export default class InitDialog extends React.Component {
+  static propTypes = {
+    config: PropTypes.object.isRequired,
+    commandRegistry: PropTypes.object.isRequired,
+    didAccept: PropTypes.func,
+    didCancel: PropTypes.func,
+  }
+
+  static defaultProps = {
+    didAccept: () => {},
+    didCancel: () => {},
+  }
+
+  constructor(props, context) {
+    super(props, context);
+
+    this.state = {
+      initDisabled: false,
+    };
+
+    this.projectHome = this.props.config.get('core.projectHome');
+    this.subs = new CompositeDisposable();
+  }
+
+  componentDidMount() {
+    if (this.projectPathEditor) {
+      this.projectPathEditor.setText(this.props.config.get('core.projectHome'));
+      this.projectPathModified = false;
+    }
+
+    if (this.projectPathElement) {
+      setTimeout(() => this.projectPathElement.focus());
+    }
+  }
+
+  render() {
+    return (
+      <div className="github-Dialog github-Init modal">
+        <Commands registry={this.props.commandRegistry} target=".github-Init">
+          <Command command="core:cancel" callback={this.cancel} />
+          <Command command="core:confirm" callback={this.init} />
+        </Commands>
+        <main className="github-DialogInputs">
+          <label className="github-DialogLabel github-ProjectPath">
+            Initialize git repository in directory
+            <atom-text-editor mini={true} ref={this.editorRef()} tabIndex="2" />
+          </label>
+        </main>
+        <div className="github-DialogButtons">
+          <button className="btn github-CancelButton" onClick={this.cancel} tabIndex="3">
+            Cancel
+          </button>
+          <button
+            className="btn btn-primary icon icon-repo-create"
+            onClick={this.init}
+            disabled={this.state.initDisabled}
+            tabIndex="4">
+            Clone
+          </button>
+        </div>
+      </div>
+    );
+  }
+
+  @autobind
+  init() {
+    if (this.getProjectPath().length === 0) {
+      return;
+    }
+
+    this.props.didAccept(this.getProjectPath());
+  }
+
+  @autobind
+  cancel() {
+    this.props.didCancel();
+  }
+
+  @autobind
+  editorRef() {
+    return element => {
+      if (!element) {
+        return;
+      }
+
+      this.projectPathElement = element;
+      const editor = element.getModel();
+      if (this.projectPathEditor !== editor) {
+        this.projectPathEditor = editor;
+
+        if (this.projectPathSubs) {
+          this.projectPathSubs.dispose();
+          this.subs.remove(this.projectPathSubs);
+        }
+
+        this.projectPathSubs = editor.onDidChange(this.setInitEnablement);
+        this.subs.add(this.projectPathSubs);
+      }
+    };
+  }
+
+  getProjectPath() {
+    return this.projectPathEditor ? this.projectPathEditor.getText() : '';
+  }
+
+  getRemoteUrl() {
+    return this.remoteUrlEditor ? this.remoteUrlEditor.getText() : '';
+  }
+
+  @autobind
+  setInitEnablement() {
+    this.setState({initDisabled: this.getProjectPath().length === 0});
+  }
+}
diff --git a/lib/views/push-pull-menu-view.js b/lib/views/push-pull-menu-view.js
index 417ebb2e26..79430e887c 100644
--- a/lib/views/push-pull-menu-view.js
+++ b/lib/views/push-pull-menu-view.js
@@ -3,28 +3,24 @@ import PropTypes from 'prop-types';
 import {autobind} from 'core-decorators';
 
 import {GitError} from '../git-shell-out-strategy';
-import {BranchPropType} from '../prop-types';
+import {BranchPropType, RemotePropType} from '../prop-types';
 
 export default class PushPullMenuView extends React.Component {
   static propTypes = {
+    notificationManager: PropTypes.object.isRequired,
+    currentBranch: BranchPropType.isRequired,
+    currentRemote: RemotePropType.isRequired,
     inProgress: PropTypes.bool,
-    currentBranch: BranchPropType,
-    remoteName: PropTypes.string,
     aheadCount: PropTypes.number,
     behindCount: PropTypes.number,
-    notificationManager: PropTypes.object,
-    onMarkSpecialClick: PropTypes.func,
-    fetch: PropTypes.func,
-    push: PropTypes.func,
-    pull: PropTypes.func,
+    onMarkSpecialClick: PropTypes.func.isRequired,
+    fetch: PropTypes.func.isRequired,
+    push: PropTypes.func.isRequired,
+    pull: PropTypes.func.isRequired,
   }
 
   static defaultProps = {
     inProgress: false,
-    currentBranch: {
-      name: '',
-      isDetached: false,
-    },
     onMarkSpecialClick: () => {},
   }
 
@@ -62,9 +58,13 @@ export default class PushPullMenuView extends React.Component {
 
   render() {
     const errorMessage = this.getErrorMessage();
-    const fetchDisabled = !this.props.remoteName || this.props.inProgress;
-    const pullDisabled = !this.props.remoteName || this.props.currentBranch.isDetached || this.props.inProgress;
-    const pushDisabled = this.props.currentBranch.isDetached || this.props.inProgress;
+    const fetchDisabled = !this.props.currentRemote.isPresent()
+      || this.props.inProgress;
+    const pullDisabled = !this.props.currentRemote.isPresent()
+      || this.props.currentBranch.isDetached()
+      || this.props.inProgress;
+    const pushDisabled = this.props.currentBranch.isDetached()
+      || this.props.inProgress;
 
     return (
       <div className={'github-PushPullMenuView' + (this.props.inProgress ? ' in-progress' : '')}>
@@ -101,12 +101,12 @@ export default class PushPullMenuView extends React.Component {
       return this.state.errorMessage;
     }
 
-    if (this.props.currentBranch.isDetached) {
+    if (this.props.currentBranch.isDetached()) {
       return 'Note: you are not on a branch. Please create one if you wish to push your work anywhere.';
     }
 
-    if (!this.props.remoteName) {
-      return `Note: No remote detected for branch ${this.props.currentBranch.name}. ` +
+    if (!this.props.currentRemote.isPresent()) {
+      return `Note: No remote detected for branch ${this.props.currentBranch.getName()}. ` +
         'Pushing will set up a remote tracking branch on remote repo "origin"';
     }
 
@@ -171,7 +171,7 @@ export default class PushPullMenuView extends React.Component {
   @autobind
   async push() {
     await this.attemptGitOperation(
-      () => this.props.push({force: this.state.force, setUpstream: !this.props.remoteName}),
+      () => this.props.push({force: this.state.force, setUpstream: !this.props.currentRemote.isPresent()}),
       description => {
         if (/rejected[\s\S]*failed to push/.test(description)) {
           return {
diff --git a/lib/views/staging-view.js b/lib/views/staging-view.js
index 06e53b354b..cc4205f8ef 100644
--- a/lib/views/staging-view.js
+++ b/lib/views/staging-view.js
@@ -82,7 +82,7 @@ export default class StagingView {
     this.subscriptions.add(this.props.commandRegistry.add('atom-workspace', {
       'github:stage-all': () => this.stageAll(),
       'github:unstage-all': () => this.unstageAll(),
-      'github:undo-last-discard-in-git-panel': () => this.props.hasUndoHistory && this.undoLastDiscard(),
+      'github:undo-last-discard-in-git-tab': () => this.props.hasUndoHistory && this.undoLastDiscard(),
     }));
     this.subscriptions.add(this.props.commandRegistry.add(this.refs.unstagedChanges, {
       'github:discard-changes-in-selected-files': () => this.discardChanges(),
@@ -411,7 +411,7 @@ export default class StagingView {
               Staged Changes
               {
                 this.props.isAmending
-                  ? ` (amending ${shortenSha(this.props.lastCommit.sha)})`
+                  ? ` (amending ${shortenSha(this.props.lastCommit.getSha())})`
                   : ''
               }
             </span>
@@ -443,7 +443,7 @@ export default class StagingView {
 
     if (mergeConflicts && mergeConflicts.length > 0) {
       const selectedItems = this.selection.getSelectedItems();
-      const resolutionProgress = this.resolutionProgressObserver.getActiveModel() || ResolutionProgress.empty();
+      const resolutionProgress = this.resolutionProgressObserver.getActiveModel() || new ResolutionProgress();
       const anyUnresolved = mergeConflicts
         .map(conflict => path.join(this.props.workingDirectoryPath, conflict.filePath))
         .some(conflictPath => resolutionProgress.getRemaining(conflictPath) !== 0);
diff --git a/menus/git.cson b/menus/git.cson
index 0c45c8628a..38334340ea 100644
--- a/menus/git.cson
+++ b/menus/git.cson
@@ -4,7 +4,7 @@
     'submenu': [
       {
         'label': 'Toggle Git Panel'
-        'command': 'github:toggle-git-panel'
+        'command': 'github:toggle-git-tab'
       }
     ]
   }
@@ -16,7 +16,7 @@
         'submenu': [
           {
             'label': 'Toggle'
-            'command': 'github:toggle-git-panel'
+            'command': 'github:toggle-git-tab'
           }
         ]
       }
diff --git a/styles/git-panel.less b/styles/git-panel.less
index a2e8947b0f..bc77be7457 100644
--- a/styles/git-panel.less
+++ b/styles/git-panel.less
@@ -22,13 +22,12 @@
   -webkit-user-select: none;
   cursor: default;
 
-  &.is-loading, &.no-repository {
+  &.no-repository {
     padding: @component-padding * 3;
     text-align: center;
   }
 
   &.is-loading {
-    font-style: italic;
     color: @text-color-subtle;
   }
 
diff --git a/test/controllers/commit-view-controller.test.js b/test/controllers/commit-view-controller.test.js
index e29206c8bd..32b00d12df 100644
--- a/test/controllers/commit-view-controller.test.js
+++ b/test/controllers/commit-view-controller.test.js
@@ -1,3 +1,5 @@
+import Commit from '../../lib/models/commit';
+
 import CommitViewController from '../../lib/controllers/commit-view-controller';
 import {cloneRepository, buildRepository} from '../helpers';
 
@@ -8,7 +10,7 @@ describe('CommitViewController', function() {
     atomEnvironment = global.buildAtomEnvironment();
     commandRegistry = atomEnvironment.commands;
 
-    lastCommit = {sha: 'a1e23fd45', message: 'last commit message', unbornRef: false};
+    lastCommit = new Commit('a1e23fd45', 'last commit message');
   });
 
   afterEach(function() {
diff --git a/test/controllers/editor-conflict-controller.test.js b/test/controllers/editor-conflict-controller.test.js
index e245834558..70c82f9b93 100644
--- a/test/controllers/editor-conflict-controller.test.js
+++ b/test/controllers/editor-conflict-controller.test.js
@@ -41,7 +41,7 @@ describe('EditorConflictController', function() {
     commandRegistry = atomEnv.commands;
 
     refreshResolutionProgress = sinon.spy();
-    resolutionProgress = ResolutionProgress.empty();
+    resolutionProgress = new ResolutionProgress();
   });
 
   afterEach(function() {
diff --git a/test/controllers/file-patch-controller.test.js b/test/controllers/file-patch-controller.test.js
index 96012fcbef..3641e36546 100644
--- a/test/controllers/file-patch-controller.test.js
+++ b/test/controllers/file-patch-controller.test.js
@@ -9,6 +9,8 @@ import FilePatch from '../../lib/models/file-patch';
 import FilePatchController from '../../lib/controllers/file-patch-controller';
 import Hunk from '../../lib/models/hunk';
 import HunkLine from '../../lib/models/hunk-line';
+import Repository from '../../lib/models/repository';
+import ResolutionProgress from '../../lib/models/conflicts/resolution-progress';
 import Switchboard from '../../lib/switchboard';
 
 describe('FilePatchController', function() {
@@ -30,10 +32,14 @@ describe('FilePatchController', function() {
     openFiles = sinon.spy();
 
     const filePatch = new FilePatch('a.txt', 'a.txt', 'modified', [new Hunk(1, 1, 1, 3, '', [])]);
+    const repository = Repository.absent();
+    const resolutionProgress = new ResolutionProgress();
 
     component = (
       <FilePatchController
         commandRegistry={commandRegistry}
+        repository={repository}
+        resolutionProgress={resolutionProgress}
         filePatch={filePatch}
         stagingStatus="unstaged"
         isPartiallyStaged={false}
@@ -124,22 +130,6 @@ describe('FilePatchController', function() {
     assert.isTrue(didSurfaceFile.calledWith('a.txt', 'unstaged'));
   });
 
-  it('ignores being passed a null repository', async function() {
-    const workdirPath = await cloneRepository('multi-line-file');
-    const repository = await buildRepository(workdirPath);
-    const filePatch = new FilePatch('a.txt', 'a.txt', 'modified', [new Hunk(1, 1, 1, 3, '', [])]);
-
-    const wrapper = shallow(React.cloneElement(component, {
-      filePatch,
-      repository,
-    }));
-
-    assert.equal(wrapper.instance().props.repository, repository);
-    // This is mostly ensuring that the render here doesn't throw.
-    wrapper.setProps({repository: null});
-    assert.isNull(wrapper.instance().props.repository);
-  });
-
   describe('integration tests', function() {
     it('stages and unstages hunks when the stage button is clicked on hunk views with no individual lines selected', async function() {
       const workdirPath = await cloneRepository('multi-line-file');
diff --git a/test/controllers/git-tab-controller.test.js b/test/controllers/git-tab-controller.test.js
index 6a408e8471..93b578dbb3 100644
--- a/test/controllers/git-tab-controller.test.js
+++ b/test/controllers/git-tab-controller.test.js
@@ -8,7 +8,7 @@ import until from 'test-until';
 import GitTabController from '../../lib/controllers/git-tab-controller';
 
 import {cloneRepository, buildRepository} from '../helpers';
-import {AbortMergeError, CommitError} from '../../lib/models/repository';
+import Repository, {AbortMergeError, CommitError} from '../../lib/models/repository';
 import ResolutionProgress from '../../lib/models/conflicts/resolution-progress';
 
 describe('GitTabController', function() {
@@ -23,7 +23,7 @@ describe('GitTabController', function() {
 
     workspaceElement = atomEnvironment.views.getView(workspace);
 
-    resolutionProgress = ResolutionProgress.empty();
+    resolutionProgress = new ResolutionProgress();
     refreshResolutionProgress = sinon.spy();
   });
 
@@ -32,26 +32,28 @@ describe('GitTabController', function() {
     atom.confirm.restore && atom.confirm.restore();
   });
 
-  it('displays loading message in GitTabView while data is being fetched', async function() {
+  it('displays a loading message in GitTabView while data is being fetched', async function() {
     const workdirPath = await cloneRepository('three-files');
-    const repository = await buildRepository(workdirPath);
     fs.writeFileSync(path.join(workdirPath, 'a.txt'), 'a change\n');
     fs.unlinkSync(path.join(workdirPath, 'b.txt'));
+    const repository = new Repository(workdirPath);
+    assert.isTrue(repository.isLoading());
+
     const controller = new GitTabController({
       workspace, commandRegistry, repository,
       resolutionProgress, refreshResolutionProgress,
     });
 
-    assert.equal(controller.getActiveRepository(), repository);
-    assert.isDefined(controller.refs.gitPanel.refs.repoLoadingMessage);
-    assert.isUndefined(controller.refs.gitPanel.refs.stagingView);
-    assert.isUndefined(controller.refs.gitPanel.refs.commitView);
+    assert.strictEqual(controller.getActiveRepository(), repository);
+    assert.isTrue(controller.element.classList.contains('is-loading'));
+    assert.lengthOf(controller.element.querySelectorAll('.github-StagingView'), 1);
+    assert.lengthOf(controller.element.querySelectorAll('.github-CommitView'), 1);
 
-    await controller.getLastModelDataRefreshPromise();
-    assert.equal(controller.getActiveRepository(), repository);
-    await assert.async.isUndefined(controller.refs.gitPanel.refs.repoLoadingMessage);
-    await assert.async.isDefined(controller.refs.gitPanel.refs.stagingView);
-    await assert.async.isDefined(controller.refs.gitPanel.refs.commitViewController);
+    await repository.getLoadPromise();
+
+    await assert.async.isFalse(controller.element.classList.contains('is-loading'));
+    assert.lengthOf(controller.element.querySelectorAll('.github-StagingView'), 1);
+    assert.lengthOf(controller.element.querySelectorAll('.github-CommitView'), 1);
   });
 
   it('keeps the state of the GitTabView in sync with the assigned repository', async function() {
@@ -59,55 +61,56 @@ describe('GitTabController', function() {
     const repository1 = await buildRepository(workdirPath1);
     const workdirPath2 = await cloneRepository('three-files');
     const repository2 = await buildRepository(workdirPath2);
+
     fs.writeFileSync(path.join(workdirPath1, 'a.txt'), 'a change\n');
     fs.unlinkSync(path.join(workdirPath1, 'b.txt'));
     const controller = new GitTabController({
       workspace, commandRegistry, resolutionProgress, refreshResolutionProgress,
-      repository: null,
+      repository: Repository.absent(),
     });
 
     // Renders empty GitTabView when there is no active repository
-    assert.isDefined(controller.refs.gitPanel);
-    assert.isNull(controller.getActiveRepository());
-    assert.isDefined(controller.refs.gitPanel.refs.noRepoMessage);
+    assert.isDefined(controller.refs.gitTab);
+    assert.isTrue(controller.getActiveRepository().isAbsent());
+    assert.isDefined(controller.refs.gitTab.refs.noRepoMessage);
 
     // Fetches data when a new repository is assigned
     // Does not update repository instance variable until that data is fetched
     await controller.update({repository: repository1});
     assert.equal(controller.getActiveRepository(), repository1);
-    assert.deepEqual(controller.refs.gitPanel.props.unstagedChanges, await repository1.getUnstagedChanges());
+    assert.deepEqual(controller.refs.gitTab.props.unstagedChanges, await repository1.getUnstagedChanges());
 
     await controller.update({repository: repository2});
     assert.equal(controller.getActiveRepository(), repository2);
-    assert.deepEqual(controller.refs.gitPanel.props.unstagedChanges, await repository2.getUnstagedChanges());
+    assert.deepEqual(controller.refs.gitTab.props.unstagedChanges, await repository2.getUnstagedChanges());
 
     // Fetches data and updates child view when the repository is mutated
     fs.writeFileSync(path.join(workdirPath2, 'a.txt'), 'a change\n');
     fs.unlinkSync(path.join(workdirPath2, 'b.txt'));
     repository2.refresh();
     await controller.getLastModelDataRefreshPromise();
-    await assert.async.deepEqual(controller.refs.gitPanel.props.unstagedChanges, await repository2.getUnstagedChanges());
+    await assert.async.deepEqual(controller.refs.gitTab.props.unstagedChanges, await repository2.getUnstagedChanges());
   });
 
   it('displays the staged changes since the parent commit when amending', async function() {
     const didChangeAmending = sinon.spy();
     const workdirPath = await cloneRepository('multiple-commits');
     const repository = await buildRepository(workdirPath);
-    const ensureGitPanel = () => Promise.resolve(false);
+    const ensureGitTab = () => Promise.resolve(false);
     const controller = new GitTabController({
-      workspace, commandRegistry, repository, didChangeAmending, ensureGitPanel,
+      workspace, commandRegistry, repository, didChangeAmending, ensureGitTab,
       resolutionProgress, refreshResolutionProgress,
       isAmending: false,
     });
     await controller.getLastModelDataRefreshPromise();
-    await assert.async.deepEqual(controller.refs.gitPanel.props.stagedChanges, []);
+    await assert.async.deepEqual(controller.refs.gitTab.props.stagedChanges, []);
     assert.equal(didChangeAmending.callCount, 0);
 
     await controller.setAmending(true);
     assert.equal(didChangeAmending.callCount, 1);
     await controller.update({isAmending: true});
     assert.deepEqual(
-      controller.refs.gitPanel.props.stagedChanges,
+      controller.refs.gitTab.props.stagedChanges,
       await controller.getActiveRepository().getStagedChangesSinceParentCommit(),
     );
 
@@ -120,7 +123,7 @@ describe('GitTabController', function() {
     const repository = await buildRepository(workdirPath);
     await assert.isRejected(repository.git.merge('origin/branch'));
 
-    const rp = ResolutionProgress.empty();
+    const rp = new ResolutionProgress();
     rp.reportMarkerCount(path.join(workdirPath, 'added-to-both.txt'), 5);
 
     const controller = new GitTabController({
@@ -156,9 +159,7 @@ describe('GitTabController', function() {
       const workdirPath = await cloneRepository('merge-conflict');
       const repository = await buildRepository(workdirPath);
 
-      await repository.git.merge('origin/branch')
-        .then(() => { throw new Error('Expected merge to throw an error'); })
-        .catch(() => true);
+      await assert.isRejected(repository.git.merge('origin/branch'));
 
       const controller = new GitTabController({
         workspace, commandRegistry, repository,
@@ -187,9 +188,9 @@ describe('GitTabController', function() {
       const workdirPath = await cloneRepository('three-files');
       const repository = await buildRepository(workdirPath);
 
-      const ensureGitPanel = () => Promise.resolve(true);
+      const ensureGitTab = () => Promise.resolve(true);
       const controller = new GitTabController({
-        workspace, commandRegistry, repository, ensureGitPanel,
+        workspace, commandRegistry, repository, ensureGitTab,
         resolutionProgress, refreshResolutionProgress,
       });
 
@@ -200,9 +201,9 @@ describe('GitTabController', function() {
       const workdirPath = await cloneRepository('three-files');
       const repository = await buildRepository(workdirPath);
 
-      const ensureGitPanel = () => Promise.resolve(false);
+      const ensureGitTab = () => Promise.resolve(false);
       const controller = new GitTabController({
-        workspace, commandRegistry, repository, ensureGitPanel,
+        workspace, commandRegistry, repository, ensureGitTab,
         resolutionProgress, refreshResolutionProgress,
       });
 
@@ -259,8 +260,8 @@ describe('GitTabController', function() {
     await controller.getLastModelDataRefreshPromise();
     await etch.getScheduler().getNextUpdatePromise();
 
-    const gitPanel = controller.refs.gitPanel;
-    const stagingView = gitPanel.refs.stagingView;
+    const gitTab = controller.refs.gitTab;
+    const stagingView = gitTab.refs.stagingView;
 
     sinon.spy(stagingView, 'focus');
 
@@ -274,12 +275,12 @@ describe('GitTabController', function() {
   });
 
   describe('keyboard navigation commands', function() {
-    let controller, gitPanel, stagingView, commitView, commitViewController, focusElement;
+    let controller, gitTab, stagingView, commitView, commitViewController, focusElement;
 
     const extractReferences = () => {
-      gitPanel = controller.refs.gitPanel;
-      stagingView = gitPanel.refs.stagingView;
-      commitViewController = gitPanel.refs.commitViewController;
+      gitTab = controller.refs.gitTab;
+      stagingView = gitTab.refs.stagingView;
+      commitViewController = gitTab.refs.commitViewController;
       commitView = commitViewController.refs.commitView;
       focusElement = stagingView;
 
@@ -382,10 +383,10 @@ describe('GitTabController', function() {
 
         const didChangeAmending = () => {};
         const prepareToCommit = () => Promise.resolve(true);
-        const ensureGitPanel = () => Promise.resolve(false);
+        const ensureGitTab = () => Promise.resolve(false);
 
         controller = new GitTabController({
-          workspace, commandRegistry, repository, didChangeAmending, prepareToCommit, ensureGitPanel,
+          workspace, commandRegistry, repository, didChangeAmending, prepareToCommit, ensureGitTab,
           resolutionProgress, refreshResolutionProgress,
         });
         await controller.getLastModelDataRefreshPromise();
@@ -423,105 +424,90 @@ describe('GitTabController', function() {
       const repository = await buildRepository(workdirPath);
       fs.writeFileSync(path.join(workdirPath, 'a.txt'), 'a change\n');
       fs.unlinkSync(path.join(workdirPath, 'b.txt'));
-      const ensureGitPanel = () => Promise.resolve(false);
+      const ensureGitTab = () => Promise.resolve(false);
       const controller = new GitTabController({
-        workspace, commandRegistry, repository, ensureGitPanel, didChangeAmending: sinon.stub(),
+        workspace, commandRegistry, repository, ensureGitTab, didChangeAmending: sinon.stub(),
         resolutionProgress, refreshResolutionProgress,
       });
       await controller.getLastModelDataRefreshPromise();
       await etch.getScheduler().getNextUpdatePromise();
-      const stagingView = controller.refs.gitPanel.refs.stagingView;
-      const commitView = controller.refs.gitPanel.refs.commitViewController.refs.commitView;
+      const stagingView = controller.refs.gitTab.refs.stagingView;
+      const commitView = controller.refs.gitTab.refs.commitViewController.refs.commitView;
 
-      assert.equal(stagingView.props.unstagedChanges.length, 2);
-      assert.equal(stagingView.props.stagedChanges.length, 0);
-      await stagingView.dblclickOnItem({}, stagingView.props.unstagedChanges[0]).stageOperationPromise;
-      repository.refresh();
-      await controller.getLastModelDataRefreshPromise();
-      await etch.getScheduler().getNextUpdatePromise();
-      await stagingView.dblclickOnItem({}, stagingView.props.unstagedChanges[0]).stageOperationPromise;
-      repository.refresh();
-      await controller.getLastModelDataRefreshPromise();
-      await etch.getScheduler().getNextUpdatePromise();
-      assert.equal(stagingView.props.unstagedChanges.length, 0);
-      assert.equal(stagingView.props.stagedChanges.length, 2);
-      await stagingView.dblclickOnItem({}, stagingView.props.stagedChanges[1]).stageOperationPromise;
-      repository.refresh();
-      await controller.getLastModelDataRefreshPromise();
-      await etch.getScheduler().getNextUpdatePromise();
-      assert.equal(stagingView.props.unstagedChanges.length, 1);
-      assert.equal(stagingView.props.stagedChanges.length, 1);
+      assert.lengthOf(stagingView.props.unstagedChanges, 2);
+      assert.lengthOf(stagingView.props.stagedChanges, 0);
+
+      stagingView.dblclickOnItem({}, stagingView.props.unstagedChanges[0]);
+
+      await assert.async.lengthOf(stagingView.props.unstagedChanges, 1);
+      assert.lengthOf(stagingView.props.stagedChanges, 1);
+
+      stagingView.dblclickOnItem({}, stagingView.props.unstagedChanges[0]);
+
+      await assert.async.lengthOf(stagingView.props.unstagedChanges, 0);
+      assert.lengthOf(stagingView.props.stagedChanges, 2);
+
+      stagingView.dblclickOnItem({}, stagingView.props.stagedChanges[1]);
+
+      await assert.async.lengthOf(stagingView.props.unstagedChanges, 1);
+      assert.lengthOf(stagingView.props.stagedChanges, 1);
 
       commitView.refs.editor.setText('Make it so');
       await commitView.commit();
-      await controller.getLastModelDataRefreshPromise();
 
-      assert.equal((await repository.getLastCommit()).message, 'Make it so');
+      assert.equal((await repository.getLastCommit()).getMessage(), 'Make it so');
     });
 
     it('can stage merge conflict files', async function() {
       const workdirPath = await cloneRepository('merge-conflict');
       const repository = await buildRepository(workdirPath);
 
-      try {
-        await repository.git.merge('origin/branch');
-      } catch (e) {
-        // expected
-      }
+      await assert.isRejected(repository.git.merge('origin/branch'));
 
       const controller = new GitTabController({
         workspace, commandRegistry, repository,
         resolutionProgress, refreshResolutionProgress,
       });
-      await controller.getLastModelDataRefreshPromise();
-      await etch.getScheduler().getNextUpdatePromise();
+      await assert.async.isDefined(controller.refs.gitTab.refs.stagingView);
+      const stagingView = controller.refs.gitTab.refs.stagingView;
 
-      const stagingView = controller.refs.gitPanel.refs.stagingView;
-      assert.equal(stagingView.props.mergeConflicts.length, 5);
+      await assert.async.equal(stagingView.props.mergeConflicts.length, 5);
       assert.equal(stagingView.props.stagedChanges.length, 0);
 
       const conflict1 = stagingView.props.mergeConflicts.filter(c => c.filePath === 'modified-on-both-ours.txt')[0];
       const contentsWithMarkers = fs.readFileSync(path.join(workdirPath, conflict1.filePath), 'utf8');
-      assert(contentsWithMarkers.includes('>>>>>>>'));
-      assert(contentsWithMarkers.includes('<<<<<<<'));
+      assert.include(contentsWithMarkers, '>>>>>>>');
+      assert.include(contentsWithMarkers, '<<<<<<<');
 
       let choice;
-      sinon.stub(atom, 'confirm', () => {
-        return choice;
-      });
+      sinon.stub(atom, 'confirm', () => choice);
 
       // click Cancel
       choice = 1;
-      await stagingView.dblclickOnItem({}, conflict1).stageOperationPromise;
-      repository.refresh();
-      await controller.getLastModelDataRefreshPromise();
-      await etch.getScheduler().getNextUpdatePromise();
-      assert.equal(atom.confirm.calledOnce, true);
-      assert.equal(stagingView.props.mergeConflicts.length, 5);
-      assert.equal(stagingView.props.stagedChanges.length, 0);
+      await stagingView.dblclickOnItem({}, conflict1).selectionUpdatePromise;
+
+      await assert.async.lengthOf(stagingView.props.mergeConflicts, 5);
+      assert.lengthOf(stagingView.props.stagedChanges, 0);
+      assert.isTrue(atom.confirm.calledOnce);
 
       // click Stage
       choice = 0;
       atom.confirm.reset();
-      await stagingView.dblclickOnItem({}, conflict1).stageOperationPromise;
-      repository.refresh();
-      await controller.getLastModelDataRefreshPromise();
-      await etch.getScheduler().getNextUpdatePromise();
-      assert.equal(atom.confirm.calledOnce, true);
-      assert.equal(stagingView.props.mergeConflicts.length, 4);
-      assert.equal(stagingView.props.stagedChanges.length, 1);
+      await stagingView.dblclickOnItem({}, conflict1).selectionUpdatePromise;
+
+      await assert.async.lengthOf(stagingView.props.mergeConflicts, 4);
+      assert.lengthOf(stagingView.props.stagedChanges, 1);
+      assert.isTrue(atom.confirm.calledOnce);
 
       // clear merge markers
       const conflict2 = stagingView.props.mergeConflicts.filter(c => c.filePath === 'modified-on-both-theirs.txt')[0];
       atom.confirm.reset();
       fs.writeFileSync(path.join(workdirPath, conflict2.filePath), 'text with no merge markers');
-      await stagingView.dblclickOnItem({}, conflict2).stageOperationPromise;
-      repository.refresh();
-      await controller.getLastModelDataRefreshPromise();
-      await etch.getScheduler().getNextUpdatePromise();
-      assert.equal(atom.confirm.called, false);
-      assert.equal(stagingView.props.mergeConflicts.length, 3);
-      assert.equal(stagingView.props.stagedChanges.length, 2);
+      stagingView.dblclickOnItem({}, conflict2);
+
+      await assert.async.lengthOf(stagingView.props.mergeConflicts, 3);
+      assert.lengthOf(stagingView.props.stagedChanges, 2);
+      assert.isFalse(atom.confirm.called);
     });
 
     it('avoids conflicts with pending file staging operations', async function() {
@@ -532,11 +518,11 @@ describe('GitTabController', function() {
       const controller = new GitTabController({
         workspace, commandRegistry, repository, resolutionProgress, refreshResolutionProgress,
       });
-      await controller.getLastModelDataRefreshPromise();
-      await etch.getScheduler().getNextUpdatePromise();
-      const stagingView = controller.refs.gitPanel.refs.stagingView;
 
-      assert.equal(stagingView.props.unstagedChanges.length, 2);
+      await assert.async.isDefined(controller.refs.gitTab.refs.stagingView);
+      const stagingView = controller.refs.gitTab.refs.stagingView;
+
+      await assert.async.lengthOf(stagingView.props.unstagedChanges, 2);
 
       // ensure staging the same file twice does not cause issues
       // second stage action is a no-op since the first staging operation is in flight
@@ -544,15 +530,15 @@ describe('GitTabController', function() {
       stagingView.confirmSelectedItems();
 
       await file1StagingPromises.stageOperationPromise;
-      repository.refresh();
       await file1StagingPromises.selectionUpdatePromise;
-      assert.equal(stagingView.props.unstagedChanges.length, 1);
+
+      await assert.async.lengthOf(stagingView.props.unstagedChanges, 1);
 
       const file2StagingPromises = stagingView.confirmSelectedItems();
       await file2StagingPromises.stageOperationPromise;
-      repository.refresh();
       await file2StagingPromises.selectionUpdatePromise;
-      assert.equal(stagingView.props.unstagedChanges.length, 0);
+
+      await assert.async.lengthOf(stagingView.props.unstagedChanges, 0);
     });
 
     it('updates file status and paths when changed', async function() {
@@ -565,7 +551,7 @@ describe('GitTabController', function() {
       });
       await controller.getLastModelDataRefreshPromise();
       await etch.getScheduler().getNextUpdatePromise();
-      const stagingView = controller.refs.gitPanel.refs.stagingView;
+      const stagingView = controller.refs.gitTab.refs.stagingView;
 
       const [addedFilePatch] = stagingView.props.unstagedChanges;
       assert.equal(addedFilePatch.filePath, 'new-file.txt');
diff --git a/test/controllers/root-controller.test.js b/test/controllers/root-controller.test.js
index 31ea490ada..bc9170c60a 100644
--- a/test/controllers/root-controller.test.js
+++ b/test/controllers/root-controller.test.js
@@ -8,6 +8,8 @@ import dedent from 'dedent-js';
 import {cloneRepository, buildRepository} from '../helpers';
 import {writeFile} from '../../lib/helpers';
 import {GitError} from '../../lib/git-shell-out-strategy';
+import Repository from '../../lib/models/repository';
+import ResolutionProgress from '../../lib/models/conflicts/resolution-progress';
 
 import RootController from '../../lib/controllers/root-controller';
 
@@ -25,6 +27,9 @@ describe('RootController', function() {
 
     workspaceElement = atomEnv.views.getView(workspace);
 
+    const absentRepository = Repository.absent();
+    const emptyResolutionProgress = new ResolutionProgress();
+
     confirm = sinon.stub(atomEnv, 'confirm');
     app = (
       <RootController
@@ -34,6 +39,8 @@ describe('RootController', function() {
         tooltips={tooltips}
         config={config}
         confirm={confirm}
+        repository={absentRepository}
+        resolutionProgress={emptyResolutionProgress}
         useLegacyPanels={true}
       />
     );
@@ -269,7 +276,7 @@ describe('RootController', function() {
     });
   });
 
-  describe('when the StatusBarTileController calls toggleGitPanel', function() {
+  describe('when the StatusBarTileController calls toggleGitTab', function() {
     it('toggles the git panel', async function() {
       const workdirPath = await cloneRepository('multiple-commits');
       const repository = await buildRepository(workdirPath);
@@ -278,14 +285,14 @@ describe('RootController', function() {
       const wrapper = shallow(app);
 
       assert.isFalse(wrapper.find('Panel').prop('visible'));
-      wrapper.find('ObserveModelDecorator(StatusBarTileController)').prop('toggleGitPanel')();
+      wrapper.find('ObserveModelDecorator(StatusBarTileController)').prop('toggleGitTab')();
       assert.isTrue(wrapper.find('Panel').prop('visible'));
-      wrapper.find('ObserveModelDecorator(StatusBarTileController)').prop('toggleGitPanel')();
+      wrapper.find('ObserveModelDecorator(StatusBarTileController)').prop('toggleGitTab')();
       assert.isFalse(wrapper.find('Panel').prop('visible'));
     });
   });
 
-  describe('toggleGitPanel()', function() {
+  describe('toggleGitTab()', function() {
     it('toggles the visibility of the Git panel', async function() {
       const workdirPath = await cloneRepository('multiple-commits');
       const repository = await buildRepository(workdirPath);
@@ -294,14 +301,14 @@ describe('RootController', function() {
       const wrapper = shallow(app);
 
       assert.isFalse(wrapper.find('Panel').prop('visible'));
-      wrapper.instance().toggleGitPanel();
+      wrapper.instance().toggleGitTab();
       assert.isTrue(wrapper.find('Panel').prop('visible'));
-      wrapper.instance().toggleGitPanel();
+      wrapper.instance().toggleGitTab();
       assert.isFalse(wrapper.find('Panel').prop('visible'));
     });
   });
 
-  describe('toggleGitPanelFocus()', function() {
+  describe('toggleGitTabFocus()', function() {
     let wrapper;
 
     beforeEach(async function() {
@@ -311,48 +318,125 @@ describe('RootController', function() {
       app = React.cloneElement(app, {repository});
       wrapper = shallow(app);
 
-      sinon.stub(wrapper.instance(), 'focusGitPanel');
+      sinon.stub(wrapper.instance(), 'focusGitTab');
       sinon.spy(workspace.getActivePane(), 'activate');
     });
 
     it('opens and focuses the Git panel when it is initially closed', function() {
       assert.isFalse(wrapper.find('Panel').prop('visible'));
-      sinon.stub(wrapper.instance(), 'gitPanelHasFocus').returns(false);
+      sinon.stub(wrapper.instance(), 'gitTabHasFocus').returns(false);
 
-      wrapper.instance().toggleGitPanelFocus();
+      wrapper.instance().toggleGitTabFocus();
 
       assert.isTrue(wrapper.find('Panel').prop('visible'));
-      assert.equal(wrapper.instance().focusGitPanel.callCount, 1);
+      assert.equal(wrapper.instance().focusGitTab.callCount, 1);
       assert.isFalse(workspace.getActivePane().activate.called);
     });
 
     it('focuses the Git panel when it is already open, but blurred', function() {
-      wrapper.instance().toggleGitPanel();
-      sinon.stub(wrapper.instance(), 'gitPanelHasFocus').returns(false);
+      wrapper.instance().toggleGitTab();
+      sinon.stub(wrapper.instance(), 'gitTabHasFocus').returns(false);
 
       assert.isTrue(wrapper.find('Panel').prop('visible'));
 
-      wrapper.instance().toggleGitPanelFocus();
+      wrapper.instance().toggleGitTabFocus();
 
       assert.isTrue(wrapper.find('Panel').prop('visible'));
-      assert.equal(wrapper.instance().focusGitPanel.callCount, 1);
+      assert.equal(wrapper.instance().focusGitTab.callCount, 1);
       assert.isFalse(workspace.getActivePane().activate.called);
     });
 
     it('blurs the Git panel when it is already open and focused', function() {
-      wrapper.instance().toggleGitPanel();
-      sinon.stub(wrapper.instance(), 'gitPanelHasFocus').returns(true);
+      wrapper.instance().toggleGitTab();
+      sinon.stub(wrapper.instance(), 'gitTabHasFocus').returns(true);
 
       assert.isTrue(wrapper.find('Panel').prop('visible'));
 
-      wrapper.instance().toggleGitPanelFocus();
+      wrapper.instance().toggleGitTabFocus();
 
       assert.isTrue(wrapper.find('Panel').prop('visible'));
-      assert.equal(wrapper.instance().focusGitPanel.callCount, 0);
+      assert.equal(wrapper.instance().focusGitTab.callCount, 0);
       assert.isTrue(workspace.getActivePane().activate.called);
     });
   });
 
+  describe('initializeRepo', function() {
+    let createRepositoryForProjectPath, resolveInit, rejectInit;
+
+    beforeEach(function() {
+      createRepositoryForProjectPath = sinon.stub().returns(new Promise((resolve, reject) => {
+        resolveInit = resolve;
+        rejectInit = reject;
+      }));
+    });
+
+    it('initializes the current working directory if there is one', function() {
+      app = React.cloneElement(app, {
+        createRepositoryForProjectPath,
+        activeWorkingDirectory: '/some/workdir',
+      });
+      const wrapper = shallow(app);
+
+      wrapper.instance().initializeRepo();
+      resolveInit();
+
+      assert.isTrue(createRepositoryForProjectPath.calledWith('/some/workdir'));
+    });
+
+    it('renders the modal init panel', function() {
+      app = React.cloneElement(app, {createRepositoryForProjectPath});
+      const wrapper = shallow(app);
+
+      wrapper.instance().initializeRepo();
+
+      assert.lengthOf(wrapper.find('Panel').find({location: 'modal'}).find('InitDialog'), 1);
+    });
+
+    it('triggers the init callback on accept', function() {
+      app = React.cloneElement(app, {createRepositoryForProjectPath});
+      const wrapper = shallow(app);
+
+      wrapper.instance().initializeRepo();
+      const dialog = wrapper.find('InitDialog');
+      dialog.prop('didAccept')('/a/path');
+      resolveInit();
+
+      assert.isTrue(createRepositoryForProjectPath.calledWith('/a/path'));
+    });
+
+    it('dismisses the init callback on cancel', function() {
+      app = React.cloneElement(app, {createRepositoryForProjectPath});
+      const wrapper = shallow(app);
+
+      wrapper.instance().initializeRepo();
+      const dialog = wrapper.find('InitDialog');
+      dialog.prop('didCancel')();
+
+      assert.isFalse(wrapper.find('InitDialog').exists());
+    });
+
+    it('creates a notification if the init fails', async function() {
+      sinon.stub(notificationManager, 'addError');
+
+      app = React.cloneElement(app, {createRepositoryForProjectPath});
+      const wrapper = shallow(app);
+
+      wrapper.instance().initializeRepo();
+      const dialog = wrapper.find('InitDialog');
+      const acceptPromise = dialog.prop('didAccept')('/a/path');
+      const err = new GitError('git init exited with status 1');
+      err.stdErr = 'this is stderr';
+      rejectInit(err);
+      await acceptPromise;
+
+      assert.isFalse(wrapper.find('InitDialog').exists());
+      assert.isTrue(notificationManager.addError.calledWith(
+        'Unable to initialize git repository in /a/path',
+        sinon.match({detail: sinon.match(/this is stderr/)}),
+      ));
+    });
+  });
+
   describe('github:clone', function() {
     let wrapper, cloneRepositoryForProjectPath, resolveClone, rejectClone;
 
@@ -472,7 +556,7 @@ describe('RootController', function() {
     });
   });
 
-  describe('ensureGitPanel()', function() {
+  describe('ensureGitTab()', function() {
     let wrapper;
 
     beforeEach(async function() {
@@ -485,13 +569,13 @@ describe('RootController', function() {
 
     it('opens the Git panel when it is initially closed', async function() {
       assert.isFalse(wrapper.find('Panel').prop('visible'));
-      assert.isTrue(await wrapper.instance().ensureGitPanel());
+      assert.isTrue(await wrapper.instance().ensureGitTab());
     });
 
     it('does nothing when the Git panel is already open', async function() {
-      wrapper.instance().toggleGitPanel();
+      wrapper.instance().toggleGitTab();
       assert.isTrue(wrapper.find('Panel').prop('visible'));
-      assert.isFalse(await wrapper.instance().ensureGitPanel());
+      assert.isFalse(await wrapper.instance().ensureGitTab());
       assert.isTrue(wrapper.find('Panel').prop('visible'));
     });
   });
@@ -637,6 +721,7 @@ describe('RootController', function() {
           const contents2 = fs.readFileSync(absFilePath, 'utf8');
           assert.notEqual(contents1, contents2);
           await repository.refresh();
+
           unstagedFilePatch = await repository.getFilePatchForPath('sample.js');
           wrapper.setState({filePatch: unstagedFilePatch});
           await wrapper.instance().discardLines(new Set(unstagedFilePatch.getHunks()[0].getLines().slice(2, 4)));
diff --git a/test/controllers/status-bar-tile-controller.test.js b/test/controllers/status-bar-tile-controller.test.js
index ef7e8f43e9..81b2a0631c 100644
--- a/test/controllers/status-bar-tile-controller.test.js
+++ b/test/controllers/status-bar-tile-controller.test.js
@@ -6,6 +6,8 @@ import until from 'test-until';
 import {mount} from 'enzyme';
 
 import {cloneRepository, buildRepository, setUpLocalAndRemoteRepositories} from '../helpers';
+import {getTempDir} from '../../lib/helpers';
+import Repository from '../../lib/models/repository';
 import StatusBarTileController from '../../lib/controllers/status-bar-tile-controller';
 import BranchView from '../../lib/views/branch-view';
 import PushPullView from '../../lib/views/push-pull-view';
@@ -97,17 +99,27 @@ describe('StatusBarTileController', function() {
           const branches = Array.from(tip.getElementsByTagName('option'), e => e.innerHTML);
           assert.deepEqual(branches, ['branch', 'master']);
 
-          assert.deepEqual(await repository.getCurrentBranch(), {name: 'master', isDetached: false});
+          const branch0 = await repository.getCurrentBranch();
+          assert.equal(branch0.getName(), 'master');
+          assert.isFalse(branch0.isDetached());
           assert.equal(tip.querySelector('select').value, 'master');
 
           selectOption(tip, 'branch');
-          assert.deepEqual(await repository.getCurrentBranch(), {name: 'branch', isDetached: false});
+          await assert.async.isFalse(wrapper.instance().getWrappedComponentInstance().state.inProgress);
+
+          const branch1 = await repository.getCurrentBranch();
+          assert.equal(branch1.getName(), 'branch');
+          assert.isFalse(branch1.isDetached());
           assert.equal(tip.querySelector('select').value, 'branch');
           await wrapper.instance().refreshModelData();
           assert.equal(tip.querySelector('select').value, 'branch');
 
           selectOption(tip, 'master');
-          assert.deepEqual(await repository.getCurrentBranch(), {name: 'master', isDetached: false});
+          await assert.async.isFalse(wrapper.instance().getWrappedComponentInstance().state.inProgress);
+
+          const branch2 = await repository.getCurrentBranch();
+          assert.equal(branch2.getName(), 'master');
+          assert.isFalse(branch2.isDetached());
           assert.equal(tip.querySelector('select').value, 'master');
           await wrapper.instance().refreshModelData();
           assert.equal(tip.querySelector('select').value, 'master');
@@ -130,7 +142,9 @@ describe('StatusBarTileController', function() {
 
           const tip = getTooltipNode(wrapper, BranchView);
 
-          assert.deepEqual(await repository.getCurrentBranch(), {name: 'branch', isDetached: false});
+          const branch0 = await repository.getCurrentBranch();
+          assert.equal(branch0.getName(), 'branch');
+          assert.isFalse(branch0.isDetached());
           assert.equal(tip.querySelector('select').value, 'branch');
 
           sinon.stub(notificationManager, 'addError');
@@ -162,7 +176,9 @@ describe('StatusBarTileController', function() {
 
           const branches = Array.from(tip.querySelectorAll('option'), option => option.value);
           assert.deepEqual(branches, ['master']);
-          assert.deepEqual(await repository.getCurrentBranch(), {name: 'master', isDetached: false});
+          const branch0 = await repository.getCurrentBranch();
+          assert.equal(branch0.getName(), 'master');
+          assert.isFalse(branch0.isDetached());
           assert.equal(tip.querySelector('select').value, 'master');
 
           tip.querySelector('button').click();
@@ -179,7 +195,9 @@ describe('StatusBarTileController', function() {
           });
 
           assert.equal(tip.querySelector('select').value, 'new-branch');
-          assert.deepEqual(await repository.getCurrentBranch(), {name: 'new-branch', isDetached: false});
+          const branch1 = await repository.getCurrentBranch();
+          assert.equal(branch1.getName(), 'new-branch');
+          assert.isFalse(branch1.isDetached());
 
           assert.lengthOf(tip.querySelectorAll('.github-BranchMenuView-editor'), 0);
           assert.lengthOf(tip.querySelectorAll('select'), 1);
@@ -198,7 +216,9 @@ describe('StatusBarTileController', function() {
 
           const branches = Array.from(tip.getElementsByTagName('option'), option => option.value);
           assert.deepEqual(branches, ['branch', 'master']);
-          assert.deepEqual(await repository.getCurrentBranch(), {name: 'branch', isDetached: false});
+          const branch0 = await repository.getCurrentBranch();
+          assert.equal(branch0.getName(), 'branch');
+          assert.isFalse(branch0.isDetached());
           assert.equal(tip.querySelector('select').value, 'branch');
 
           tip.querySelector('button').click();
@@ -210,7 +230,9 @@ describe('StatusBarTileController', function() {
           assert.equal(notificationArgs[0], 'Cannot create branch');
           assert.match(notificationArgs[1].description, /already exists/);
 
-          assert.deepEqual(await repository.getCurrentBranch(), {name: 'branch', isDetached: false});
+          const branch1 = await repository.getCurrentBranch();
+          assert.equal(branch1.getName(), 'branch');
+          assert.isFalse(branch1.isDetached());
           assert.equal(tip.querySelector('select').value, 'branch');
         });
       });
@@ -445,9 +467,9 @@ describe('StatusBarTileController', function() {
       const workdirPath = await cloneRepository('three-files');
       const repository = await buildRepository(workdirPath);
 
-      const toggleGitPanel = sinon.spy();
+      const toggleGitTab = sinon.spy();
 
-      const wrapper = mount(React.cloneElement(component, {repository, toggleGitPanel}));
+      const wrapper = mount(React.cloneElement(component, {repository, toggleGitTab}));
       await wrapper.instance().refreshModelData();
 
       assert.equal(wrapper.find('.github-ChangedFilesCount').render().text(), '0 files');
@@ -465,13 +487,29 @@ describe('StatusBarTileController', function() {
       const workdirPath = await cloneRepository('three-files');
       const repository = await buildRepository(workdirPath);
 
-      const toggleGitPanel = sinon.spy();
+      const toggleGitTab = sinon.spy();
 
-      const wrapper = mount(React.cloneElement(component, {repository, toggleGitPanel}));
+      const wrapper = mount(React.cloneElement(component, {repository, toggleGitTab}));
       await wrapper.instance().refreshModelData();
 
       wrapper.find(ChangedFilesCountView).simulate('click');
-      assert(toggleGitPanel.calledOnce);
+      assert(toggleGitTab.calledOnce);
+    });
+  });
+
+  describe('while the repository is not present', function() {
+    it('does not display the branch or push-pull tiles', async function() {
+      const workdirPath = await getTempDir();
+      const repository = new Repository(workdirPath);
+      assert.isFalse(repository.isPresent());
+
+      const wrapper = mount(React.cloneElement(component, {repository}));
+
+      assert.isFalse(wrapper.find('BranchView').exists());
+      assert.isFalse(wrapper.find('BranchMenuView').exists());
+      assert.isFalse(wrapper.find('PushPullView').exists());
+      assert.isFalse(wrapper.find('PushPullMenuView').exists());
+      assert.isTrue(wrapper.find('ChangedFilesCountView').exists());
     });
   });
 });
diff --git a/test/git-strategies.test.js b/test/git-strategies.test.js
index a577956183..3b2022e7c5 100644
--- a/test/git-strategies.test.js
+++ b/test/git-strategies.test.js
@@ -468,7 +468,7 @@ import {fsStat} from '../lib/helpers';
         await git.exec(['config', 'push.default', 'upstream']);
         assert.equal(await git.getBehindCount('master'), 0);
         assert.equal(await git.getAheadCount('master'), 0);
-        await git.fetch('master');
+        await git.fetch('origin', 'master');
         assert.equal(await git.getBehindCount('master'), 1);
         assert.equal(await git.getAheadCount('master'), 0);
         await git.commit('new commit', {allowEmpty: true});
@@ -542,18 +542,6 @@ import {fsStat} from '../lib/helpers';
       });
     });
 
-    describe('getRemoteForBranch(branchName)', function() {
-      it('returns the name of the remote associated with the branch, and null if none exists', async function() {
-        const workingDirPath = await cloneRepository('three-files');
-        const git = createTestStrategy(workingDirPath);
-        assert.equal(await git.getRemoteForBranch('master'), 'origin');
-        await git.exec(['remote', 'rename', 'origin', 'foo']);
-        assert.equal(await git.getRemoteForBranch('master'), 'foo');
-        await git.exec(['remote', 'rm', 'foo']);
-        assert.isNull(await git.getRemoteForBranch('master'));
-      });
-    });
-
     describe('getBranches()', function() {
       it('returns an array of all branches', async function() {
         const workingDirPath = await cloneRepository('three-files');
@@ -626,7 +614,6 @@ import {fsStat} from '../lib/helpers';
       beforeEach(async function() {
         const workingDirPath = await cloneRepository('multiple-commits');
         git = createTestStrategy(workingDirPath);
-        sinon.stub(git, 'getRemoteForBranch').returns(Promise.resolve('origin'));
       });
 
       const operations = [
@@ -646,7 +633,7 @@ import {fsStat} from '../lib/helpers';
           command: 'pull',
           progressiveTense: 'pulling',
           usesPromptServerAlready: true,
-          action: () => git.pull('some-branch'),
+          action: () => git.pull('origin', 'some-branch'),
         },
       ];
 
@@ -701,8 +688,6 @@ import {fsStat} from '../lib/helpers';
           prompt: Promise.resolve(''),
         });
 
-        sinon.stub(git, 'getRemoteForBranch').returns(Promise.resolve('origin'));
-
         originalEnv = {};
         ['PATH', 'DISPLAY', 'GIT_ASKPASS', 'SSH_ASKPASS', 'GIT_SSH_COMMAND'].forEach(varName => {
           originalEnv[varName] = process.env[varName];
@@ -719,17 +704,17 @@ import {fsStat} from '../lib/helpers';
         {
           command: 'fetch',
           progressiveTense: 'fetching',
-          action: () => git.fetch('some-branch'),
+          action: () => git.fetch('origin', 'some-branch'),
         },
         {
           command: 'pull',
           progressiveTense: 'pulling',
-          action: () => git.pull('some-branch'),
+          action: () => git.pull('origin', 'some-branch'),
         },
         {
           command: 'push',
           progressiveTense: 'pushing',
-          action: () => git.push('some-branch'),
+          action: () => git.push('origin', 'some-branch'),
         },
       ];
 
diff --git a/test/github-package.test.js b/test/github-package.test.js
index 9d9ccfb67b..bd42fbbfd9 100644
--- a/test/github-package.test.js
+++ b/test/github-package.test.js
@@ -1,16 +1,16 @@
-import {Directory} from 'atom';
-
 import fs from 'fs';
 import path from 'path';
 import temp from 'temp';
 import until from 'test-until';
 
 import {cloneRepository} from './helpers';
+import {writeFile, getTempDir} from '../lib/helpers';
 import GithubPackage from '../lib/github-package';
 
 describe('GithubPackage', function() {
   let atomEnv, workspace, project, commandRegistry, notificationManager, config, confirm, tooltips, styles;
-  let githubPackage;
+  let getLoadSettings;
+  let githubPackage, contextPool;
 
   beforeEach(function() {
     atomEnv = global.buildAtomEnvironment();
@@ -22,9 +22,13 @@ describe('GithubPackage', function() {
     config = atomEnv.config;
     confirm = atomEnv.confirm.bind(atomEnv);
     styles = atomEnv.styles;
+    getLoadSettings = atomEnv.getLoadSettings.bind(atomEnv);
+
     githubPackage = new GithubPackage(
-      workspace, project, commandRegistry, notificationManager, tooltips, styles, config, confirm,
+      workspace, project, commandRegistry, notificationManager, tooltips, styles, config, confirm, getLoadSettings,
     );
+
+    contextPool = githubPackage.getContextPool();
   });
 
   afterEach(async function() {
@@ -32,170 +36,203 @@ describe('GithubPackage', function() {
     atomEnv.destroy();
   });
 
-  describe('activate()', function() {
-    it('updates the active repository', async function() {
-      await githubPackage.activate();
-      const workdirPath1 = await cloneRepository('three-files');
-      const workdirPath2 = await cloneRepository('three-files');
-      project.setPaths([workdirPath1, workdirPath2]);
-      fs.writeFileSync(path.join(workdirPath1, 'a.txt'), 'change 1', 'utf8');
-      fs.writeFileSync(path.join(workdirPath1, 'b.txt'), 'change 2', 'utf8');
+  function contextUpdateAfter(chunk) {
+    const updatePromise = githubPackage.getSwitchboard().getFinishActiveContextUpdatePromise();
+    chunk();
+    return updatePromise;
+  }
+
+  describe('construction', function() {
+    let githubPackage1;
 
-      await workspace.open(path.join(workdirPath1, 'a.txt'));
-      const repository = await githubPackage.getRepositoryForWorkdirPath(workdirPath1);
-      await until(() => githubPackage.getActiveRepository() === repository);
+    afterEach(async function() {
+      if (githubPackage1) {
+        await githubPackage1.deactivate();
+      }
     });
-  });
 
-  describe('changing the project paths', function() {
-    it('updates the active repository and project path', async function() {
-      const workdirPath1 = await cloneRepository('three-files');
-      const workdirPath2 = await cloneRepository('three-files');
-      const nonRepositoryPath = fs.realpathSync(temp.mkdirSync());
-      fs.writeFileSync(path.join(nonRepositoryPath, 'c.txt'));
-      project.setPaths([workdirPath1, workdirPath2, nonRepositoryPath]);
-      fs.writeFileSync(path.join(workdirPath1, 'a.txt'), 'change 1', 'utf8');
-      await githubPackage.activate();
+    async function constructWith(projectPaths, initialPaths) {
+      const realProjectPaths = await Promise.all(
+        projectPaths.map(projectPath => getTempDir(projectPath)),
+      );
 
-      sinon.spy(githubPackage, 'rerender');
-      await workspace.open(path.join(workdirPath1, 'a.txt'));
-      const repository1 = await githubPackage.getRepositoryForWorkdirPath(workdirPath1);
-      await assert.async.strictEqual(githubPackage.getActiveRepository(), repository1);
-      await assert.async.equal(githubPackage.getActiveProjectPath(), workdirPath1);
-      await assert.async.equal(githubPackage.rerender.callCount, 1);
+      project.setPaths(realProjectPaths);
+      const getLoadSettings1 = () => ({initialPaths});
 
-      // Remove repository for open file
-      project.setPaths([workdirPath2, nonRepositoryPath]);
-      await assert.async.equal(githubPackage.getActiveProjectPath(), workdirPath1);
-      await assert.async.isNull(githubPackage.getActiveRepository());
-      await assert.async.equal(githubPackage.rerender.callCount, 2);
+      githubPackage1 = new GithubPackage(
+        workspace, project, commandRegistry, notificationManager, tooltips, styles, config, confirm, getLoadSettings1,
+      );
+    }
 
-      await workspace.open(path.join(workdirPath2, 'b.txt'));
-      const repository2 = await githubPackage.getRepositoryForWorkdirPath(workdirPath2);
-      await assert.async.strictEqual(githubPackage.getActiveRepository(), repository2);
-      await assert.async.equal(githubPackage.getActiveProjectPath(), workdirPath2);
-      await assert.async.equal(githubPackage.rerender.callCount, 3);
+    function assertAbsentLike() {
+      const repository = githubPackage1.getActiveRepository();
+      assert.isTrue(repository.isUndetermined());
+      assert.isFalse(repository.showGitTabLoading());
+      assert.isTrue(repository.showGitTabInit());
+    }
 
-      await workspace.open(path.join(nonRepositoryPath, 'c.txt'));
-      await assert.async.isNull(githubPackage.getActiveRepository());
-      await assert.async.equal(githubPackage.getActiveProjectPath(), nonRepositoryPath);
-      await assert.async.equal(githubPackage.rerender.callCount, 4);
+    function assertLoadingLike() {
+      const repository = githubPackage1.getActiveRepository();
+      assert.isTrue(repository.isUndetermined());
+      assert.isTrue(repository.showGitTabLoading());
+      assert.isFalse(repository.showGitTabInit());
+    }
+
+    it('with no projects or initial paths begins with an absent-like undetermined context', async function() {
+      await constructWith([], []);
+      assertAbsentLike();
     });
 
-    it('destroys all the repositories associated with the removed project folders', async function() {
-      const workdirPath1 = await cloneRepository('three-files');
-      const workdirPath2 = await cloneRepository('three-files');
-      const workdirPath3 = await cloneRepository('three-files');
-      project.setPaths([workdirPath1, workdirPath2, workdirPath3]);
-      await githubPackage.activate();
-      await githubPackage.getInitialModelsPromise();
+    it('with one existing project begins with a loading-like undetermined context', async function() {
+      await constructWith(['one'], []);
+      assertLoadingLike();
+    });
 
-      const repository1 = await githubPackage.getRepositoryForWorkdirPath(workdirPath1);
-      const repository2 = await githubPackage.getRepositoryForWorkdirPath(workdirPath2);
-      const repository3 = await githubPackage.getRepositoryForWorkdirPath(workdirPath3);
-      assert.isOk(repository1);
-      assert.isOk(repository2);
-      assert.isOk(repository3);
+    it('with several existing projects begins with an absent-like undetermined context', async function() {
+      await constructWith(['one', 'two'], []);
+      assertAbsentLike();
+    });
 
-      sinon.stub(repository1, 'destroy');
-      sinon.stub(repository2, 'destroy');
-      sinon.stub(repository3, 'destroy');
+    it('with no projects but one initial path begins with a loading-like undetermined context', async function() {
+      await constructWith([], ['one']);
+      assertLoadingLike();
+    });
 
-      project.removePath(workdirPath1);
-      project.removePath(workdirPath3);
+    it('with no projects and several initial paths begins with an absent-like undetermined context', async function() {
+      await constructWith([], ['one', 'two']);
+      assertAbsentLike();
+    });
 
-      await until(() => repository1.destroy.callCount === 1, 'repository1 is destroyed');
-      await until(() => repository3.destroy.callCount === 1, 'repository3 is destroyed');
-      assert.equal(repository2.destroy.callCount, 0);
-      assert.notEqual(await githubPackage.getRepositoryForWorkdirPath(repository1.getWorkingDirectoryPath()), repository1);
-      assert.notEqual(await githubPackage.getRepositoryForWorkdirPath(repository3.getWorkingDirectoryPath()), repository3);
-      assert.equal(await githubPackage.getRepositoryForWorkdirPath(repository2.getWorkingDirectoryPath()), repository2);
+    it('with one project and initial paths begins with a loading-like undetermined context', async function() {
+      await constructWith(['one'], ['two', 'three']);
+      assertLoadingLike();
     });
-  });
 
-  describe('didChangeActivePaneItem()', function() {
-    it('updates the active repository', async function() {
-      const workdirPath1 = await cloneRepository('three-files');
-      const workdirPath2 = await cloneRepository('three-files');
-      project.setPaths([workdirPath1, workdirPath2]);
-      fs.writeFileSync(path.join(workdirPath1, 'a.txt'), 'change 1', 'utf8');
-      fs.writeFileSync(path.join(workdirPath2, 'b.txt'), 'change 2', 'utf8');
+    it('with several projects and an initial path begins with an absent-like undetermined context', async function() {
+      await constructWith(['one', 'two'], ['three']);
+      assertAbsentLike();
+    });
+  });
 
-      await workspace.open(path.join(workdirPath1, 'a.txt'));
-      githubPackage.didChangeActivePaneItem();
-      assert.equal(githubPackage.getActiveRepository(), await githubPackage.getRepositoryForWorkdirPath(workdirPath1));
+  describe('activate()', function() {
+    it('begins with an undetermined repository context', async function() {
+      await githubPackage.activate();
+      await githubPackage.getSwitchboard().getFinishActiveContextUpdatePromise();
 
-      await workspace.open(path.join(workdirPath2, 'b.txt'));
-      githubPackage.didChangeActivePaneItem();
-      assert.equal(githubPackage.getActiveRepository(), await githubPackage.getRepositoryForWorkdirPath(workdirPath2));
+      assert.isTrue(githubPackage.getActiveRepository().isUndetermined());
     });
-  });
 
-  describe('updateActiveModels()', function() {
-    it('updates the active repository based on the active item, setting it to null when the active item is not in a project repository', async function() {
-      const workdirPath1 = await cloneRepository('three-files');
-      const workdirPath2 = await cloneRepository('three-files');
-      const nonRepositoryPath = fs.realpathSync(temp.mkdirSync());
-      fs.writeFileSync(path.join(nonRepositoryPath, 'c.txt'));
+    it('uses models from preexisting projects', async function() {
+      const [workdirPath1, workdirPath2, nonRepositoryPath] = await Promise.all([
+        cloneRepository('three-files'),
+        cloneRepository('three-files'),
+        getTempDir(),
+      ]);
       project.setPaths([workdirPath1, workdirPath2, nonRepositoryPath]);
+
       await githubPackage.activate();
+      await githubPackage.getSwitchboard().getFinishActiveContextUpdatePromise();
 
-      await workspace.open(path.join(workdirPath1, 'a.txt'));
-      await workspace.open(path.join(workdirPath2, 'b.txt'));
+      assert.isTrue(contextPool.getContext(workdirPath1).isPresent());
+      assert.isTrue(contextPool.getContext(workdirPath2).isPresent());
+      assert.isTrue(contextPool.getContext(nonRepositoryPath).isPresent());
 
-      await githubPackage.updateActiveModels();
-      assert.isNotNull(githubPackage.getActiveRepository());
-      assert.equal(githubPackage.getActiveProjectPath(), workdirPath2);
-      assert.equal(githubPackage.getActiveRepository(), await githubPackage.getRepositoryForWorkdirPath(workdirPath2));
+      assert.isTrue(githubPackage.getActiveRepository().isUndetermined());
+    });
 
-      await workspace.open(path.join(nonRepositoryPath, 'c.txt'));
-      await githubPackage.updateActiveModels();
-      assert.equal(githubPackage.getActiveProjectPath(), nonRepositoryPath);
-      assert.isNull(githubPackage.getActiveRepository());
+    it('uses an active model from a single preexisting project', async function() {
+      const workdirPath = await cloneRepository('three-files');
+      project.setPaths([workdirPath]);
 
-      await workspace.open(path.join(workdirPath1, 'a.txt'));
-      await githubPackage.updateActiveModels();
-      assert.equal(githubPackage.getActiveProjectPath(), workdirPath1);
-      assert.equal(githubPackage.getActiveRepository(), await githubPackage.getRepositoryForWorkdirPath(workdirPath1));
+      await githubPackage.activate();
+      await githubPackage.getSwitchboard().getFinishActiveContextUpdatePromise();
 
-      workspace.getActivePane().activateItem({}); // such as when find & replace results pane is focused
-      await githubPackage.updateActiveModels();
-      assert.equal(githubPackage.getActiveProjectPath(), workdirPath1);
-      assert.equal(githubPackage.getActiveRepository(), await githubPackage.getRepositoryForWorkdirPath(workdirPath1));
+      const context = contextPool.getContext(workdirPath);
+      assert.isTrue(context.isPresent());
 
-      await workspace.open(path.join(workdirPath2, 'b.txt'));
-      await githubPackage.updateActiveModels();
-      assert.equal(githubPackage.getActiveProjectPath(), workdirPath2);
-      assert.equal(githubPackage.getActiveRepository(), await githubPackage.getRepositoryForWorkdirPath(workdirPath2));
+      assert.strictEqual(context.getRepository(), githubPackage.getActiveRepository());
+      assert.strictEqual(context.getResolutionProgress(), githubPackage.getActiveResolutionProgress());
+      assert.equal(githubPackage.getActiveWorkdir(), workdirPath);
+    });
 
-      project.removePath(workdirPath2);
-      await githubPackage.updateActiveModels();
-      assert.isNull(githubPackage.getActiveProjectPath());
-      assert.isNull(githubPackage.getActiveRepository());
+    it('uses an active model from a preexisting active pane item', async function() {
+      const [workdirPath1, workdirPath2] = await Promise.all([
+        cloneRepository('three-files'),
+        cloneRepository('three-files'),
+      ]);
+      project.setPaths([workdirPath1, workdirPath2]);
+      await workspace.open(path.join(workdirPath2, 'a.txt'));
 
-      project.removePath(workdirPath1);
-      await githubPackage.updateActiveModels();
-      assert.isNull(githubPackage.getActiveProjectPath());
-      assert.isNull(githubPackage.getActiveRepository());
+      await githubPackage.activate();
+      await githubPackage.getSwitchboard().getFinishActiveContextUpdatePromise();
 
-      await workspace.open(path.join(workdirPath1, 'a.txt'));
-      await githubPackage.updateActiveModels();
-      assert.isNull(githubPackage.getActiveProjectPath());
-      assert.isNull(githubPackage.getActiveRepository());
+      const context = contextPool.getContext(workdirPath2);
+      assert.isTrue(context.isPresent());
+      assert.strictEqual(context.getRepository(), githubPackage.getActiveRepository());
+      assert.strictEqual(context.getResolutionProgress(), githubPackage.getActiveResolutionProgress());
+      assert.equal(githubPackage.getActiveWorkdir(), workdirPath2);
     });
 
-    it('defaults to a single repository even without an active pane item', async function() {
-      const workdirPath = await cloneRepository('three-files');
-      project.setPaths([workdirPath]);
-      await githubPackage.activate();
+    it('uses an active model from serialized state', async function() {
+      const [workdirPath1, workdirPath2, workdirPath3] = await Promise.all([
+        cloneRepository('three-files'),
+        cloneRepository('three-files'),
+        cloneRepository('three-files'),
+      ]);
+      project.setPaths([workdirPath1, workdirPath2, workdirPath3]);
+
+      await githubPackage.activate({
+        activeRepositoryPath: workdirPath2,
+      });
+      await githubPackage.getSwitchboard().getFinishActiveContextUpdatePromise();
+
+      const context = contextPool.getContext(workdirPath2);
+      assert.isTrue(context.isPresent());
+      assert.strictEqual(context.getRepository(), githubPackage.getActiveRepository());
+      assert.strictEqual(context.getResolutionProgress(), githubPackage.getActiveResolutionProgress());
+      assert.equal(githubPackage.getActiveWorkdir(), workdirPath2);
+    });
+
+    it('prefers the active model from an active pane item to serialized state', async function() {
+      const [workdirPath1, workdirPath2] = await Promise.all([
+        cloneRepository('three-files'),
+        cloneRepository('three-files'),
+      ]);
+      project.setPaths([workdirPath1, workdirPath2]);
+      await workspace.open(path.join(workdirPath2, 'b.txt'));
+
+      await githubPackage.activate({
+        activeRepositoryPath: workdirPath1,
+      });
+      await githubPackage.getSwitchboard().getFinishActiveContextUpdatePromise();
 
-      await githubPackage.updateActiveModels();
+      const context = contextPool.getContext(workdirPath2);
+      assert.isTrue(context.isPresent());
+      assert.strictEqual(context.getRepository(), githubPackage.getActiveRepository());
+      assert.strictEqual(context.getResolutionProgress(), githubPackage.getActiveResolutionProgress());
+      assert.equal(githubPackage.getActiveWorkdir(), workdirPath2);
+    });
+
+    it('prefers the active model from a single project to serialized state', async function() {
+      const [workdirPath1, workdirPath2] = await Promise.all([
+        cloneRepository('three-files'),
+        cloneRepository('three-files'),
+      ]);
+      project.setPaths([workdirPath1]);
+
+      await githubPackage.activate({
+        activeRepositoryPath: workdirPath2,
+      });
+      await githubPackage.getSwitchboard().getFinishActiveContextUpdatePromise();
 
-      const repository = await githubPackage.getRepositoryForWorkdirPath(workdirPath);
-      await assert.async.strictEqual(githubPackage.getActiveRepository(), repository);
+      const context = contextPool.getContext(workdirPath1);
+      assert.isTrue(context.isPresent());
+      assert.strictEqual(context.getRepository(), githubPackage.getActiveRepository());
+      assert.strictEqual(context.getResolutionProgress(), githubPackage.getActiveResolutionProgress());
+      assert.equal(githubPackage.getActiveWorkdir(), workdirPath1);
     });
 
-    it('updates the active resolution progress', async function() {
+    it('restores the active resolution progress', async function() {
       // Repository with a merge conflict, repository without a merge conflict, path without a repository
       const workdirMergeConflict = await cloneRepository('merge-conflict');
       const workdirNoConflict = await cloneRepository('three-files');
@@ -204,13 +241,13 @@ describe('GithubPackage', function() {
 
       project.setPaths([workdirMergeConflict, workdirNoConflict, nonRepositoryPath]);
       await githubPackage.activate();
-      await githubPackage.getInitialModelsPromise();
+      await githubPackage.getSwitchboard().getFinishActiveContextUpdatePromise();
 
       // Open a file in the merge conflict repository.
       await workspace.open(path.join(workdirMergeConflict, 'modified-on-both-ours.txt'));
-      await githubPackage.updateActiveModels();
+      await githubPackage.scheduleActiveContextUpdate();
 
-      const resolutionMergeConflict = await githubPackage.getResolutionProgressForWorkdirPath(workdirMergeConflict);
+      const resolutionMergeConflict = contextPool.getContext(workdirMergeConflict).getResolutionProgress();
       await assert.strictEqual(githubPackage.getActiveResolutionProgress(), resolutionMergeConflict);
 
       // Record some resolution progress to recall later
@@ -218,40 +255,281 @@ describe('GithubPackage', function() {
 
       // Open a file in the non-merge conflict repository.
       await workspace.open(path.join(workdirNoConflict, 'b.txt'));
-      await githubPackage.updateActiveModels();
+      await githubPackage.scheduleActiveContextUpdate();
 
-      const resolutionNoConflict = await githubPackage.getResolutionProgressForWorkdirPath(workdirNoConflict);
-      await assert.strictEqual(githubPackage.getActiveResolutionProgress(), resolutionNoConflict);
+      const resolutionNoConflict = contextPool.getContext(workdirNoConflict).getResolutionProgress();
+      assert.strictEqual(githubPackage.getActiveResolutionProgress(), resolutionNoConflict);
       assert.isTrue(githubPackage.getActiveResolutionProgress().isEmpty());
 
       // Open a file in the workdir with no repository.
       await workspace.open(path.join(nonRepositoryPath, 'c.txt'));
-      await githubPackage.updateActiveModels();
+      await githubPackage.scheduleActiveContextUpdate();
 
-      await assert.isNull(githubPackage.getActiveResolutionProgress());
+      assert.isTrue(githubPackage.getActiveResolutionProgress().isEmpty());
 
       // Re-open a file in the merge conflict repository.
       await workspace.open(path.join(workdirMergeConflict, 'modified-on-both-theirs.txt'));
-      await githubPackage.updateActiveModels();
+      await githubPackage.scheduleActiveContextUpdate();
 
-      await assert.strictEqual(githubPackage.getActiveResolutionProgress(), resolutionMergeConflict);
+      assert.strictEqual(githubPackage.getActiveResolutionProgress(), resolutionMergeConflict);
       assert.isFalse(githubPackage.getActiveResolutionProgress().isEmpty());
       assert.equal(githubPackage.getActiveResolutionProgress().getRemaining('modified-on-both-ours.txt'), 3);
     });
+  });
+
+  describe('when the project paths change', function() {
+    it('adds new workdirs to the pool', async function() {
+      const [workdirPath1, workdirPath2, workdirPath3] = await Promise.all([
+        cloneRepository('three-files'),
+        cloneRepository('three-files'),
+        cloneRepository('three-files'),
+      ]);
+
+      project.setPaths([workdirPath1, workdirPath2]);
+      await githubPackage.activate();
+      await githubPackage.getSwitchboard().getFinishActiveContextUpdatePromise();
+
+      assert.isTrue(contextPool.getContext(workdirPath1).isPresent());
+      assert.isTrue(contextPool.getContext(workdirPath2).isPresent());
+      assert.isFalse(contextPool.getContext(workdirPath3).isPresent());
+
+      project.setPaths([workdirPath1, workdirPath2, workdirPath3]);
+      await githubPackage.getSwitchboard().getFinishActiveContextUpdatePromise();
+
+      assert.isTrue(contextPool.getContext(workdirPath1).isPresent());
+      assert.isTrue(contextPool.getContext(workdirPath2).isPresent());
+      assert.isTrue(contextPool.getContext(workdirPath3).isPresent());
+    });
+
+    it('destroys contexts associated with the removed project folders', async function() {
+      const [workdirPath1, workdirPath2, workdirPath3] = await Promise.all([
+        cloneRepository('three-files'),
+        cloneRepository('three-files'),
+        cloneRepository('three-files'),
+      ]);
+      project.setPaths([workdirPath1, workdirPath2, workdirPath3]);
+      await githubPackage.activate();
+      await githubPackage.getSwitchboard().getFinishActiveContextUpdatePromise();
+
+      const [repository1, repository2, repository3] = [workdirPath1, workdirPath2, workdirPath3].map(workdir => {
+        return contextPool.getContext(workdir).getRepository();
+      });
+
+      sinon.stub(repository1, 'destroy');
+      sinon.stub(repository2, 'destroy');
+      sinon.stub(repository3, 'destroy');
+
+      project.removePath(workdirPath1);
+      project.removePath(workdirPath3);
+      await githubPackage.getSwitchboard().getFinishActiveContextUpdatePromise();
+
+      assert.equal(repository1.destroy.callCount, 1);
+      assert.equal(repository3.destroy.callCount, 1);
+      assert.isFalse(repository2.destroy.called);
+
+      assert.isFalse(contextPool.getContext(workdirPath1).isPresent());
+      assert.isFalse(contextPool.getContext(workdirPath3).isPresent());
+      assert.isTrue(contextPool.getContext(workdirPath2).isPresent());
+    });
+
+    it('returns to an absent context when the last project folder is removed', async function() {
+      const workdirPath = await cloneRepository('three-files');
+      project.setPaths([workdirPath]);
+      await contextUpdateAfter(() => githubPackage.activate());
+
+      assert.isTrue(githubPackage.getActiveRepository().isLoading() || githubPackage.getActiveRepository().isPresent());
+
+      await contextUpdateAfter(() => project.setPaths([]));
+
+      assert.isTrue(githubPackage.getActiveRepository().isAbsent());
+    });
+
+    it('does not transition away from an absent guess when no project folders are present', async function() {
+      await contextUpdateAfter(() => githubPackage.activate());
+
+      assert.isTrue(githubPackage.getActiveRepository().isAbsentGuess());
+    });
+  });
+
+  describe('when the active pane item changes', function() {
+    it('becomes the active context', async function() {
+      const [workdirPath1, workdirPath2] = await Promise.all([
+        cloneRepository('three-files'),
+        cloneRepository('three-files'),
+      ]);
+      project.setPaths([workdirPath1, workdirPath2]);
+
+      await githubPackage.activate();
+      await githubPackage.getSwitchboard().getFinishActiveContextUpdatePromise();
+
+      const repository2 = contextPool.getContext(workdirPath2).getRepository();
+      assert.isTrue(githubPackage.getActiveRepository().isUndetermined());
+
+      await contextUpdateAfter(() => workspace.open(path.join(workdirPath2, 'b.txt')));
+
+      assert.strictEqual(githubPackage.getActiveRepository(), repository2);
+    });
+
+    it('adds a new context if not in a project', async function() {
+      const [workdirPath1, workdirPath2] = await Promise.all([
+        cloneRepository('three-files'),
+        cloneRepository('three-files'),
+      ]);
+      project.setPaths([workdirPath1]);
+
+      await githubPackage.activate();
+      await githubPackage.getSwitchboard().getFinishActiveContextUpdatePromise();
+
+      assert.isFalse(contextPool.getContext(workdirPath2).isPresent());
+
+      await contextUpdateAfter(() => workspace.open(path.join(workdirPath2, 'c.txt')));
+
+      assert.equal(githubPackage.getActiveWorkdir(), workdirPath2);
+      assert.isTrue(contextPool.getContext(workdirPath2).isPresent());
+    });
+
+    it('removes a context if not in a project', async function() {
+      const [workdirPath1, workdirPath2] = await Promise.all([
+        cloneRepository('three-files'),
+        cloneRepository('three-files'),
+      ]);
+      project.setPaths([workdirPath1]);
+      await githubPackage.activate();
+      await githubPackage.getSwitchboard().getFinishActiveContextUpdatePromise();
+
+      await contextUpdateAfter(() => workspace.open(path.join(workdirPath2, 'c.txt')));
+      assert.isTrue(contextPool.getContext(workdirPath2).isPresent());
+
+      await contextUpdateAfter(() => workspace.getActivePane().destroyActiveItem());
+      assert.isFalse(contextPool.getContext(workdirPath2).isPresent());
+    });
+  });
+
+  describe('scheduleActiveContextUpdate()', function() {
+    beforeEach(function() {
+      // Necessary since we skip activate()
+      githubPackage.savedState = {};
+    });
+
+    it('prefers the context of the active pane item', async function() {
+      const [workdirPath1, workdirPath2, workdirPath3] = await Promise.all([
+        cloneRepository('three-files'),
+        cloneRepository('three-files'),
+        cloneRepository('three-files'),
+      ]);
+      project.setPaths([workdirPath1]);
+      await workspace.open(path.join(workdirPath2, 'a.txt'));
+
+      await githubPackage.scheduleActiveContextUpdate({
+        activeRepositoryPath: workdirPath3,
+      });
+
+      assert.equal(githubPackage.getActiveWorkdir(), workdirPath2);
+    });
+
+    it('uses an absent context when the active item is not in a git repository', async function() {
+      const nonRepositoryPath = fs.realpathSync(temp.mkdirSync());
+      const workdir = await cloneRepository('three-files');
+      project.setPaths([nonRepositoryPath, workdir]);
+      await writeFile(path.join(nonRepositoryPath, 'a.txt'), 'stuff');
+
+      workspace.open(path.join(nonRepositoryPath, 'a.txt'));
+
+      await githubPackage.scheduleActiveContextUpdate();
+
+      assert.isTrue(githubPackage.getActiveRepository().isAbsent());
+    });
+
+    it('uses the context of a single open project', async function() {
+      const [workdirPath1, workdirPath2] = await Promise.all([
+        cloneRepository('three-files'),
+        cloneRepository('three-files'),
+      ]);
+      project.setPaths([workdirPath1]);
+
+      await githubPackage.scheduleActiveContextUpdate({
+        activeRepositoryPath: workdirPath2,
+      });
+
+      assert.equal(githubPackage.getActiveWorkdir(), workdirPath1);
+    });
+
+    it('uses an empty context with a single open project without a git workdir', async function() {
+      const nonRepositoryPath = await getTempDir();
+      project.setPaths([nonRepositoryPath]);
+
+      await githubPackage.scheduleActiveContextUpdate();
+      await githubPackage.getActiveRepository().getLoadPromise();
+
+      assert.isTrue(contextPool.getContext(nonRepositoryPath).isPresent());
+      assert.isTrue(githubPackage.getActiveRepository().isEmpty());
+      assert.isFalse(githubPackage.getActiveRepository().isAbsent());
+    });
+
+    it('activates a saved context state', async function() {
+      const [workdirPath1, workdirPath2] = await Promise.all([
+        cloneRepository('three-files'),
+        cloneRepository('three-files'),
+      ]);
+      project.setPaths([workdirPath1, workdirPath2]);
+
+      await githubPackage.scheduleActiveContextUpdate({
+        activeRepositoryPath: workdirPath2,
+      });
+
+      assert.equal(githubPackage.getActiveWorkdir(), workdirPath2);
+    });
+
+    it('falls back to keeping the context the same', async function() {
+      const [workdirPath1, workdirPath2] = await Promise.all([
+        cloneRepository('three-files'),
+        cloneRepository('three-files'),
+      ]);
+      project.setPaths([workdirPath1, workdirPath2]);
+
+      contextPool.set([workdirPath1, workdirPath2]);
+      githubPackage.setActiveContext(contextPool.getContext(workdirPath1));
+
+      await githubPackage.scheduleActiveContextUpdate();
+
+      assert.equal(githubPackage.getActiveWorkdir(), workdirPath1);
+    });
+
+    it('discovers a context from an open subdirectory', async function() {
+      const workdirPath = await cloneRepository('three-files');
+      const projectPath = path.join(workdirPath, 'subdir-1');
+      project.setPaths([projectPath]);
+
+      await githubPackage.scheduleActiveContextUpdate();
+
+      assert.equal(githubPackage.getActiveWorkdir(), workdirPath);
+    });
+
+    it('reverts to an empty context if the active repository is destroyed', async function() {
+      const workdirPath = await cloneRepository('three-files');
+      project.setPaths([workdirPath]);
+
+      await githubPackage.scheduleActiveContextUpdate();
+
+      assert.isTrue(contextPool.getContext(workdirPath).isPresent());
+      const repository = contextPool.getContext(workdirPath).getRepository();
+
+      repository.destroy();
+
+      assert.isTrue(githubPackage.getActiveRepository().isAbsent());
+    });
 
     // Don't worry about this on Windows as it's not a common op
     if (process.platform !== 'win32') {
-      it('handles symlinked project paths', async () => {
+      it('handles symlinked project paths', async function() {
         const workdirPath = await cloneRepository('three-files');
         const symlinkPath = fs.realpathSync(temp.mkdirSync()) + '-symlink';
         fs.symlinkSync(workdirPath, symlinkPath);
         project.setPaths([symlinkPath]);
-        await githubPackage.activate();
-
         await workspace.open(path.join(symlinkPath, 'a.txt'));
 
-        await githubPackage.updateActiveModels();
-        assert.isOk(githubPackage.getActiveRepository());
+        await githubPackage.scheduleActiveContextUpdate();
+        await assert.async.isOk(githubPackage.getActiveRepository());
       });
     }
   });
@@ -261,21 +539,28 @@ describe('GithubPackage', function() {
     let workdirPath2, atomGitRepository2, repository2;
 
     beforeEach(async function() {
-      workdirPath1 = await cloneRepository('three-files');
-      workdirPath2 = await cloneRepository('three-files');
+      [workdirPath1, workdirPath2] = await Promise.all([
+        cloneRepository('three-files'),
+        cloneRepository('three-files'),
+      ]);
 
       fs.writeFileSync(path.join(workdirPath1, 'c.txt'), 'ch-ch-ch-changes', 'utf8');
       fs.writeFileSync(path.join(workdirPath2, 'c.txt'), 'ch-ch-ch-changes', 'utf8');
 
       project.setPaths([workdirPath1, workdirPath2]);
       await githubPackage.activate();
-      await githubPackage.getInitialWatchersStartedPromise();
+      await until('change observers have started', () => {
+        return [workdirPath1, workdirPath2].every(workdir => {
+          return contextPool.getContext(workdir).getChangeObserver().isStarted();
+        });
+      });
+
       [atomGitRepository1, atomGitRepository2] = githubPackage.project.getRepositories();
       sinon.stub(atomGitRepository1, 'refreshStatus');
       sinon.stub(atomGitRepository2, 'refreshStatus');
 
-      repository1 = await githubPackage.getRepositoryForWorkdirPath(workdirPath1);
-      repository2 = await githubPackage.getRepositoryForWorkdirPath(workdirPath2);
+      repository1 = contextPool.getContext(workdirPath1).getRepository();
+      repository2 = contextPool.getContext(workdirPath2).getRepository();
       sinon.stub(repository1, 'refresh');
       sinon.stub(repository2, 'refresh');
     });
@@ -317,49 +602,44 @@ describe('GithubPackage', function() {
     });
   });
 
-  describe('#createRepositoryForProjectPath', function() {
+  describe('createRepositoryForProjectPath()', function() {
     it('creates and sets a repository for the given project path', async function() {
-      const workdirPath1 = await cloneRepository('three-files');
-      const workdirPath2 = await cloneRepository('three-files');
-      const nonRepositoryPath = fs.realpathSync(temp.mkdirSync());
-      fs.writeFileSync(path.join(nonRepositoryPath, 'c.txt'));
-      project.setPaths([workdirPath1, workdirPath2, nonRepositoryPath]);
+      const nonRepositoryPath = await getTempDir();
+      project.setPaths([nonRepositoryPath]);
+
       await githubPackage.activate();
+      await githubPackage.getSwitchboard().getFinishActiveContextUpdatePromise();
+      await githubPackage.getActiveRepository().getLoadPromise();
 
-      await workspace.open(path.join(nonRepositoryPath, 'c.txt'));
-      await assert.async.isNull(githubPackage.getActiveRepository());
-      await githubPackage.createRepositoryForProjectPath(nonRepositoryPath);
-      assert.isOk(githubPackage.getActiveRepository());
-      assert.equal(githubPackage.getActiveRepository(), await githubPackage.getRepositoryForWorkdirPath(nonRepositoryPath));
-    });
-  });
+      assert.isTrue(githubPackage.getActiveRepository().isEmpty());
+      assert.isFalse(githubPackage.getActiveRepository().isAbsent());
 
-  describe('#projectPathForItemPath', function() {
-    it('does not error when the path is falsy (e.g. new unsaved file)', function() {
-      sinon.stub(project, 'getDirectories').returns([new Directory('path')]);
-      assert.doesNotThrow(() => {
-        githubPackage.projectPathForItemPath(null);
-      });
-    });
+      await githubPackage.createRepositoryForProjectPath(nonRepositoryPath);
 
-    it('returns the correct path when the item path starts with the project path but the item path is not in the project', function() {
-      const dirs = [path.join('path', 'to', 'my'), path.join('path', 'to', 'my-project')].map(p => new Directory(p));
-      sinon.stub(project, 'getDirectories').returns(dirs);
-      assert.equal(githubPackage.projectPathForItemPath(path.join('path', 'to', 'my-project', 'file.txt')), path.join('path', 'to', 'my-project'));
+      assert.isTrue(githubPackage.getActiveRepository().isPresent());
+      assert.strictEqual(
+        githubPackage.getActiveRepository(),
+        await contextPool.getContext(nonRepositoryPath).getRepository(),
+      );
     });
   });
 
   describe('serialized state', function() {
+    function resolutionProgressFrom(pkg, workdir) {
+      return pkg.getContextPool().getContext(workdir).getResolutionProgress();
+    }
+
     it('restores nonempty resolution progress', async function() {
       const workdirMergeConflict = await cloneRepository('merge-conflict');
       const workdirNoConflict = await cloneRepository('three-files');
 
       project.setPaths([workdirMergeConflict, workdirNoConflict]);
       await githubPackage.activate();
-      await githubPackage.getInitialModelsPromise();
+      await githubPackage.scheduleActiveContextUpdate();
 
       // Record some state to recover later.
-      const resolutionMergeConflict0 = await githubPackage.getResolutionProgressForWorkdirPath(workdirMergeConflict);
+      const resolutionMergeConflict0 = resolutionProgressFrom(githubPackage, workdirMergeConflict);
+      await assert.async.isTrue(resolutionMergeConflict0.loaded);
       resolutionMergeConflict0.reportMarkerCount('modified-on-both-ours.txt', 3);
 
       const payload = githubPackage.serialize();
@@ -370,15 +650,15 @@ describe('GithubPackage', function() {
       assert.isUndefined(payload.resolutionProgressByPath[workdirNoConflict]);
 
       const githubPackage1 = new GithubPackage(
-        workspace, project, commandRegistry, notificationManager, tooltips, styles, config, confirm,
+        workspace, project, commandRegistry, notificationManager, tooltips, styles, config, confirm, getLoadSettings,
       );
       await githubPackage1.activate(payload);
-      await githubPackage1.getInitialModelsPromise();
+      await githubPackage1.scheduleActiveContextUpdate();
 
-      const resolutionMergeConflict1 = await githubPackage1.getResolutionProgressForWorkdirPath(workdirMergeConflict);
-      const resolutionNoConflict1 = await githubPackage1.getResolutionProgressForWorkdirPath(workdirNoConflict);
+      const resolutionMergeConflict1 = resolutionProgressFrom(githubPackage1, workdirMergeConflict);
+      const resolutionNoConflict1 = resolutionProgressFrom(githubPackage1, workdirNoConflict);
 
-      assert.isFalse(resolutionMergeConflict1.isEmpty());
+      await assert.async.isFalse(resolutionMergeConflict1.isEmpty());
       assert.equal(resolutionMergeConflict1.getRemaining('modified-on-both-ours.txt'), 3);
 
       assert.isTrue(resolutionNoConflict1.isEmpty());
diff --git a/test/helpers.js b/test/helpers.js
index eb843d86dc..8f5cf2dcfe 100644
--- a/test/helpers.js
+++ b/test/helpers.js
@@ -38,6 +38,12 @@ export async function cloneRepository(repoName = 'three-files') {
   return copyCachedRepo(repoName);
 }
 
+export async function sha(directory) {
+  const git = new GitShellOutStrategy(directory);
+  const head = await git.getHeadCommit();
+  return head.sha;
+}
+
 /*
  * Initialize an empty repository at a temporary path.
  */
@@ -80,8 +86,10 @@ export async function getHeadCommitOnRemote(remotePath) {
   return git.getHeadCommit();
 }
 
-export function buildRepository(workingDirPath) {
-  return Repository.open(workingDirPath);
+export async function buildRepository(workingDirPath) {
+  const repository = new Repository(workingDirPath);
+  await repository.getLoadPromise();
+  return repository;
 }
 
 export function assertDeepPropertyVals(actual, expected) {
diff --git a/test/models/conflicts/resolution-progress.test.js b/test/models/conflicts/resolution-progress.test.js
index 874433ed0c..6f71983071 100644
--- a/test/models/conflicts/resolution-progress.test.js
+++ b/test/models/conflicts/resolution-progress.test.js
@@ -2,12 +2,14 @@ import ResolutionProgress from '../../../lib/models/conflicts/resolution-progres
 
 describe('ResolutionProgress', function() {
   it('reports undefined for any path that has not reported progress yet', function() {
-    const progress = new ResolutionProgress('1234abcd', {});
+    const progress = new ResolutionProgress();
+    progress.load('1234abcd', {});
     assert.isUndefined(progress.getRemaining('path/to/file.txt'));
   });
 
   it('accepts reports of unresolved conflict counts', function() {
-    const progress = new ResolutionProgress('1234abcd', {});
+    const progress = new ResolutionProgress();
+    progress.load('1234abcd', {});
     progress.reportMarkerCount('path/to/file.txt', 3);
 
     assert.equal(progress.getRemaining('path/to/file.txt'), 3);
@@ -17,7 +19,8 @@ describe('ResolutionProgress', function() {
     let payload;
 
     beforeEach(function() {
-      const progress0 = new ResolutionProgress('1234abcd', {});
+      const progress0 = new ResolutionProgress();
+      progress0.load('1234abcd', {});
       progress0.reportMarkerCount('path/to/file0.txt', 3);
       progress0.reportMarkerCount('path/to/file1.txt', 4);
 
@@ -25,14 +28,16 @@ describe('ResolutionProgress', function() {
     });
 
     it('restores data from the same revision', function() {
-      const progress1 = new ResolutionProgress('1234abcd', payload);
+      const progress1 = new ResolutionProgress();
+      progress1.load('1234abcd', payload);
       assert.equal(progress1.getRemaining('path/to/file0.txt'), 3);
       assert.equal(progress1.getRemaining('path/to/file1.txt'), 4);
       assert.isFalse(progress1.isEmpty());
     });
 
     it('restores an empty object for a different revision', function() {
-      const progress2 = new ResolutionProgress('abcd1234', payload);
+      const progress2 = new ResolutionProgress();
+      progress2.load('abcd1234', payload);
 
       assert.isUndefined(progress2.getRemaining('path/to/file0.txt'));
       assert.isUndefined(progress2.getRemaining('path/to/file1.txt'));
@@ -44,7 +49,8 @@ describe('ResolutionProgress', function() {
     let progress, didUpdateSpy;
 
     beforeEach(function() {
-      progress = new ResolutionProgress('1234abcd', {});
+      progress = new ResolutionProgress();
+      progress.load('1234abcd', {});
       progress.reportMarkerCount('path/file0.txt', 4);
 
       didUpdateSpy = sinon.spy();
diff --git a/test/models/remote.test.js b/test/models/remote.test.js
new file mode 100644
index 0000000000..88f794326d
--- /dev/null
+++ b/test/models/remote.test.js
@@ -0,0 +1,41 @@
+import Remote from '../../lib/models/remote';
+
+describe('Remote', function() {
+  it('detects and extracts information from GitHub repository URLs', function() {
+    const urls = [
+      'git@github.com:atom/github.git',
+      'https://github.com/atom/github.git',
+      'https://git:pass@github.com/atom/github.git',
+      'ssh+https://github.com/atom/github.git',
+      'git://github.com/atom/github',
+      'ssh://git@github.com:atom/github.git',
+    ];
+
+    for (const url of urls) {
+      const remote = new Remote('origin', url);
+
+      assert.equal(remote.getName(), 'origin');
+      assert.equal(remote.getUrl(), url);
+      assert.isTrue(remote.isGithubRepo());
+      assert.equal(remote.getOwner(), 'atom');
+      assert.equal(remote.getRepo(), 'github');
+    }
+  });
+
+  it('detects non-GitHub remotes', function() {
+    const urls = [
+      'git@gitlab.com:atom/github.git',
+      'atom/github',
+    ];
+
+    for (const url of urls) {
+      const remote = new Remote('origin', url);
+
+      assert.equal(remote.getName(), 'origin');
+      assert.equal(remote.getUrl(), url);
+      assert.isFalse(remote.isGithubRepo());
+      assert.isNull(remote.getOwner());
+      assert.isNull(remote.getRepo());
+    }
+  });
+});
diff --git a/test/models/repository.test.js b/test/models/repository.test.js
index 70d1b03441..075d80c070 100644
--- a/test/models/repository.test.js
+++ b/test/models/repository.test.js
@@ -2,49 +2,76 @@ import fs from 'fs';
 import path from 'path';
 import dedent from 'dedent-js';
 import temp from 'temp';
+import util from 'util';
 
 import Repository from '../../lib/models/repository';
+import {expectedDelegates} from '../../lib/models/repository-states';
 
-import {cloneRepository, buildRepository, assertDeepPropertyVals, setUpLocalAndRemoteRepositories, getHeadCommitOnRemote, assertEqualSortedArraysByKey} from '../helpers';
+import {cloneRepository, assertDeepPropertyVals, setUpLocalAndRemoteRepositories, getHeadCommitOnRemote, assertEqualSortedArraysByKey} from '../helpers';
 
 describe('Repository', function() {
-  describe('githubInfoFromRemote', function() {
-    it('returns info about a GitHub repo based on the remote URL', function() {
-      const atomRepo = {
-        githubRepo: true,
-        owner: 'atom',
-        name: 'github',
-      };
-
-      const notARepo = {
-        githubRepo: false,
-        owner: null,
-        name: null,
-      };
-
-      const remotes = [
-        'git@github.com:atom/github.git',
-        'https://github.com/atom/github.git',
-        'https://git:pass@github.com/atom/github.git',
-        'ssh+https://github.com/atom/github.git',
-        'git://github.com/atom/github',
-        'ssh://git@github.com:atom/github.git',
-      ];
-
-      for (const remote of remotes) {
-        assert.deepEqual(Repository.githubInfoFromRemote(remote), atomRepo);
-      }
+  it('delegates all state methods', function() {
+    const missing = expectedDelegates.filter(delegateName => {
+      return Repository.prototype[delegateName] === undefined;
+    });
+
+    // For convenience, write the delegate list to the console when there are any missing (in addition to failing the
+    // test.)
+    if (missing.length > 0) {
+      const formatted = util.inspect(expectedDelegates);
+
+      // eslint-disable-next-line no-console
+      console.log(`Expected delegates for your copy-and-paste convenience:\n\n---\n${formatted}\n---\n`);
+    }
+
+    assert.lengthOf(missing, 0);
+  });
+
+  describe('initial states', function() {
+    let repository;
+
+    afterEach(async function() {
+      repository && await repository.destroy();
+    });
+
+    it('begins in the Loading state with a working directory', async function() {
+      const workdir = await cloneRepository('three-files');
+      repository = new Repository(workdir);
+      assert.isTrue(repository.isInState('Loading'));
+    });
+
+    it('begins in the Absent state with .absent()', function() {
+      repository = Repository.absent();
+      assert.isTrue(repository.isInState('Absent'));
+    });
 
-      assert.deepEqual(Repository.githubInfoFromRemote('git@gitlab.com:atom/github.git'), notARepo);
-      assert.deepEqual(Repository.githubInfoFromRemote('atom/github'), notARepo);
+    it('begins in an AbsentGuess state with .absentGuess()', function() {
+      repository = Repository.absentGuess();
+      assert.isTrue(repository.isInState('AbsentGuess'));
+      assert.isFalse(repository.showGitTabLoading());
+      assert.isTrue(repository.showGitTabInit());
+    });
+
+    it('begins in a LoadingGuess state with .guess()', function() {
+      repository = Repository.loadingGuess();
+      assert.isTrue(repository.isInState('LoadingGuess'));
+      assert.isTrue(repository.showGitTabLoading());
+      assert.isFalse(repository.showGitTabInit());
     });
   });
 
   describe('init', function() {
     it('creates a repository in the given dir and returns the repository', async function() {
       const soonToBeRepositoryPath = fs.realpathSync(temp.mkdirSync());
-      const repo = await Repository.init(soonToBeRepositoryPath);
-      assert.isTrue(await repo.isGitRepository());
+      const repo = new Repository(soonToBeRepositoryPath);
+      assert.isTrue(repo.isLoading());
+
+      await repo.getLoadPromise();
+      assert.isTrue(repo.isEmpty());
+
+      await repo.init();
+
+      assert.isTrue(repo.isPresent());
       assert.equal(repo.getWorkingDirectoryPath(), soonToBeRepositoryPath);
     });
   });
@@ -54,8 +81,11 @@ describe('Repository', function() {
       const upstreamPath = await cloneRepository('three-files');
       const destDir = fs.realpathSync(temp.mkdirSync());
 
-      const repo = await Repository.clone(upstreamPath, destDir);
-      assert.isTrue(await repo.isGitRepository());
+      const repo = new Repository(destDir);
+      const clonePromise = repo.clone(upstreamPath);
+      assert.isTrue(repo.isLoading());
+      await clonePromise;
+      assert.isTrue(repo.isPresent());
       assert.equal(repo.getWorkingDirectoryPath(), destDir);
     });
 
@@ -64,8 +94,9 @@ describe('Repository', function() {
       const parentDir = fs.realpathSync(temp.mkdirSync());
       const destDir = path.join(parentDir, 'subdir');
 
-      const repo = await Repository.clone(upstreamPath, destDir);
-      assert.isTrue(await repo.isGitRepository());
+      const repo = new Repository(destDir);
+      await repo.clone(upstreamPath, destDir);
+      assert.isTrue(repo.isPresent());
       assert.equal(repo.getWorkingDirectoryPath(), destDir);
     });
   });
@@ -73,7 +104,9 @@ describe('Repository', function() {
   describe('staging and unstaging files', function() {
     it('can stage and unstage modified files', async function() {
       const workingDirPath = await cloneRepository('three-files');
-      const repo = await buildRepository(workingDirPath);
+      const repo = new Repository(workingDirPath);
+      await repo.getLoadPromise();
+
       fs.writeFileSync(path.join(workingDirPath, 'subdir-1', 'a.txt'), 'qux\nfoo\nbar\n', 'utf8');
       const [patch] = await repo.getUnstagedChanges();
       const filePath = patch.filePath;
@@ -91,7 +124,9 @@ describe('Repository', function() {
 
     it('can stage and unstage removed files', async function() {
       const workingDirPath = await cloneRepository('three-files');
-      const repo = await buildRepository(workingDirPath);
+      const repo = new Repository(workingDirPath);
+      await repo.getLoadPromise();
+
       fs.unlinkSync(path.join(workingDirPath, 'subdir-1', 'b.txt'));
       const [patch] = await repo.getUnstagedChanges();
       const filePath = patch.filePath;
@@ -109,7 +144,9 @@ describe('Repository', function() {
 
     it('can stage and unstage renamed files', async function() {
       const workingDirPath = await cloneRepository('three-files');
-      const repo = await buildRepository(workingDirPath);
+      const repo = new Repository(workingDirPath);
+      await repo.getLoadPromise();
+
       fs.renameSync(path.join(workingDirPath, 'c.txt'), path.join(workingDirPath, 'subdir-1', 'd.txt'));
       const patches = await repo.getUnstagedChanges();
       const filePath1 = patches[0].filePath;
@@ -129,7 +166,9 @@ describe('Repository', function() {
     it('can stage and unstage added files', async function() {
       const workingDirPath = await cloneRepository('three-files');
       fs.writeFileSync(path.join(workingDirPath, 'subdir-1', 'e.txt'), 'qux', 'utf8');
-      const repo = await buildRepository(workingDirPath);
+      const repo = new Repository(workingDirPath);
+      await repo.getLoadPromise();
+
       const [patch] = await repo.getUnstagedChanges();
       const filePath = patch.filePath;
 
@@ -146,7 +185,9 @@ describe('Repository', function() {
 
     it('can unstage and retrieve staged changes relative to HEAD~', async function() {
       const workingDirPath = await cloneRepository('multiple-commits');
-      const repo = await buildRepository(workingDirPath);
+      const repo = new Repository(workingDirPath);
+      await repo.getLoadPromise();
+
       fs.writeFileSync(path.join(workingDirPath, 'file.txt'), 'three\nfour\n', 'utf8');
       assert.deepEqual(await repo.getStagedChangesSinceParentCommit(), [
         {
@@ -194,7 +235,9 @@ describe('Repository', function() {
   describe('getFilePatchForPath', function() {
     it('returns cached FilePatch objects if they exist', async function() {
       const workingDirPath = await cloneRepository('multiple-commits');
-      const repo = await buildRepository(workingDirPath);
+      const repo = new Repository(workingDirPath);
+      await repo.getLoadPromise();
+
       fs.writeFileSync(path.join(workingDirPath, 'new-file.txt'), 'foooooo', 'utf8');
       fs.writeFileSync(path.join(workingDirPath, 'file.txt'), 'qux\nfoo\nbar\n', 'utf8');
       await repo.stageFiles(['file.txt']);
@@ -209,7 +252,9 @@ describe('Repository', function() {
 
     it('returns new FilePatch object after repository refresh', async function() {
       const workingDirPath = await cloneRepository('three-files');
-      const repo = await buildRepository(workingDirPath);
+      const repo = new Repository(workingDirPath);
+      await repo.getLoadPromise();
+
       fs.writeFileSync(path.join(workingDirPath, 'a.txt'), 'qux\nfoo\nbar\n', 'utf8');
 
       const filePatchA = await repo.getFilePatchForPath('a.txt');
@@ -224,7 +269,9 @@ describe('Repository', function() {
   describe('applyPatchToIndex', function() {
     it('can stage and unstage modified files', async function() {
       const workingDirPath = await cloneRepository('three-files');
-      const repo = await buildRepository(workingDirPath);
+      const repo = new Repository(workingDirPath);
+      await repo.getLoadPromise();
+
       fs.writeFileSync(path.join(workingDirPath, 'subdir-1', 'a.txt'), 'qux\nfoo\nbar\n', 'utf8');
       const unstagedPatch1 = await repo.getFilePatchForPath(path.join('subdir-1', 'a.txt'));
 
@@ -256,8 +303,10 @@ describe('Repository', function() {
   describe('commit', function() {
     it('creates a commit that contains the staged changes', async function() {
       const workingDirPath = await cloneRepository('three-files');
-      const repo = await buildRepository(workingDirPath);
-      assert.equal((await repo.getLastCommit()).message, 'Initial commit');
+      const repo = new Repository(workingDirPath);
+      await repo.getLoadPromise();
+
+      assert.equal((await repo.getLastCommit()).getMessage(), 'Initial commit');
 
       fs.writeFileSync(path.join(workingDirPath, 'subdir-1', 'a.txt'), 'qux\nfoo\nbar\n', 'utf8');
       const unstagedPatch1 = await repo.getFilePatchForPath(path.join('subdir-1', 'a.txt'));
@@ -265,7 +314,7 @@ describe('Repository', function() {
       repo.refresh();
       await repo.applyPatchToIndex(unstagedPatch1);
       await repo.commit('Commit 1');
-      assert.equal((await repo.getLastCommit()).message, 'Commit 1');
+      assert.equal((await repo.getLastCommit()).getMessage(), 'Commit 1');
       repo.refresh();
       assert.deepEqual(await repo.getStagedChanges(), []);
       const unstagedChanges = await repo.getUnstagedChanges();
@@ -274,7 +323,7 @@ describe('Repository', function() {
       const unstagedPatch2 = await repo.getFilePatchForPath(path.join('subdir-1', 'a.txt'));
       await repo.applyPatchToIndex(unstagedPatch2);
       await repo.commit('Commit 2');
-      assert.equal((await repo.getLastCommit()).message, 'Commit 2');
+      assert.equal((await repo.getLastCommit()).getMessage(), 'Commit 2');
       repo.refresh();
       assert.deepEqual(await repo.getStagedChanges(), []);
       assert.deepEqual(await repo.getUnstagedChanges(), []);
@@ -282,7 +331,9 @@ describe('Repository', function() {
 
     it('amends the last commit when the amend option is set to true', async function() {
       const workingDirPath = await cloneRepository('multiple-commits');
-      const repo = await buildRepository(workingDirPath);
+      const repo = new Repository(workingDirPath);
+      await repo.getLoadPromise();
+
       const lastCommit = await repo.git.getHeadCommit();
       const lastCommitParent = await repo.git.getCommit('HEAD~');
       await repo.commit('amend last commit', {amend: true, allowEmpty: true});
@@ -294,7 +345,9 @@ describe('Repository', function() {
 
     it('throws an error when there are unmerged files', async function() {
       const workingDirPath = await cloneRepository('merge-conflict');
-      const repository = await buildRepository(workingDirPath);
+      const repository = new Repository(workingDirPath);
+      await repository.getLoadPromise();
+
       try {
         await repository.git.merge('origin/branch');
       } catch (e) {
@@ -312,12 +365,13 @@ describe('Repository', function() {
       }
 
       assert.equal(await repository.isMerging(), true);
-      assert.equal((await repository.getLastCommit()).toString(), mergeBase.toString());
+      assert.equal((await repository.getLastCommit()).getSha(), mergeBase.getSha());
     });
 
     it('wraps the commit message body at 72 characters', async function() {
       const workingDirPath = await cloneRepository('three-files');
-      const repo = await buildRepository(workingDirPath);
+      const repo = new Repository(workingDirPath);
+      await repo.getLoadPromise();
 
       fs.writeFileSync(path.join(workingDirPath, 'subdir-1', 'a.txt'), 'qux\nfoo\nbar\n', 'utf8');
       await repo.stageFiles([path.join('subdir-1', 'a.txt')]);
@@ -327,7 +381,7 @@ describe('Repository', function() {
         'Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.',
       ].join('\n'));
 
-      const message = (await repo.getLastCommit()).message;
+      const message = (await repo.getLastCommit()).getMessage();
       assert.deepEqual(message.split('\n'), [
         'Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor',
         '',
@@ -338,7 +392,8 @@ describe('Repository', function() {
 
     it('strips out comments', async function() {
       const workingDirPath = await cloneRepository('three-files');
-      const repo = await buildRepository(workingDirPath);
+      const repo = new Repository(workingDirPath);
+      await repo.getLoadPromise();
 
       fs.writeFileSync(path.join(workingDirPath, 'subdir-1', 'a.txt'), 'qux\nfoo\nbar\n', 'utf8');
       await repo.stageFiles([path.join('subdir-1', 'a.txt')]);
@@ -350,14 +405,16 @@ describe('Repository', function() {
         '#  other stuff',
       ].join('\n'));
 
-      assert.deepEqual((await repo.getLastCommit()).message, 'Make a commit');
+      assert.deepEqual((await repo.getLastCommit()).getMessage(), 'Make a commit');
     });
   });
 
   describe('fetch(branchName)', function() {
     it('brings commits from the remote and updates remote branch, and does not update branch', async function() {
       const {localRepoPath} = await setUpLocalAndRemoteRepositories({remoteAhead: true});
-      const localRepo = await buildRepository(localRepoPath);
+      const localRepo = new Repository(localRepoPath);
+      await localRepo.getLoadPromise();
+
       let remoteHead, localHead;
       remoteHead = await localRepo.git.getCommit('origin/master');
       localHead = await localRepo.git.getCommit('master');
@@ -375,7 +432,9 @@ describe('Repository', function() {
   describe('pull()', function() {
     it('updates the remote branch and merges into local branch', async function() {
       const {localRepoPath} = await setUpLocalAndRemoteRepositories({remoteAhead: true});
-      const localRepo = await buildRepository(localRepoPath);
+      const localRepo = new Repository(localRepoPath);
+      await localRepo.getLoadPromise();
+
       let remoteHead, localHead;
       remoteHead = await localRepo.git.getCommit('origin/master');
       localHead = await localRepo.git.getCommit('master');
@@ -393,7 +452,8 @@ describe('Repository', function() {
   describe('push()', function() {
     it('sends commits to the remote and updates ', async function() {
       const {localRepoPath, remoteRepoPath} = await setUpLocalAndRemoteRepositories();
-      const localRepo = await buildRepository(localRepoPath);
+      const localRepo = new Repository(localRepoPath);
+      await localRepo.getLoadPromise();
 
       let localHead, localRemoteHead, remoteHead;
       localHead = await localRepo.git.getCommit('master');
@@ -422,7 +482,8 @@ describe('Repository', function() {
   describe('getAheadCount(branchName) and getBehindCount(branchName)', function() {
     it('returns the number of commits ahead and behind the remote', async function() {
       const {localRepoPath} = await setUpLocalAndRemoteRepositories({remoteAhead: true});
-      const localRepo = await buildRepository(localRepoPath);
+      const localRepo = new Repository(localRepoPath);
+      await localRepo.getLoadPromise();
 
       assert.equal(await localRepo.getBehindCount('master'), 0);
       assert.equal(await localRepo.getAheadCount('master'), 0);
@@ -437,16 +498,27 @@ describe('Repository', function() {
   });
 
   describe('getRemoteForBranch(branchName)', function() {
-    it('returns the remote name associated to the supplied branch name, null if none exists', async function() {
+    it('returns the remote associated to the supplied branch name', async function() {
       const {localRepoPath} = await setUpLocalAndRemoteRepositories({remoteAhead: true});
-      const localRepo = await buildRepository(localRepoPath);
+      const localRepo = new Repository(localRepoPath);
+      await localRepo.getLoadPromise();
+
+      const remote0 = await localRepo.getRemoteForBranch('master');
+      assert.isTrue(remote0.isPresent());
+      assert.equal(remote0.getName(), 'origin');
 
-      assert.equal(await localRepo.getRemoteForBranch('master'), 'origin');
       await localRepo.git.exec(['remote', 'rename', 'origin', 'foo']);
-      assert.equal(await localRepo.getRemoteForBranch('master'), 'foo');
+      localRepo.refresh();
+
+      const remote1 = await localRepo.getRemoteForBranch('master');
+      assert.isTrue(remote1.isPresent());
+      assert.equal(remote1.getName(), 'foo');
 
       await localRepo.git.exec(['remote', 'rm', 'foo']);
-      assert.isNull(await localRepo.getRemoteForBranch('master'));
+      localRepo.refresh();
+
+      const remote2 = await localRepo.getRemoteForBranch('master');
+      assert.isFalse(remote2.isPresent());
     });
   });
 
@@ -454,15 +526,9 @@ describe('Repository', function() {
     describe('getMergeConflicts()', function() {
       it('returns a promise resolving to an array of MergeConflict objects', async function() {
         const workingDirPath = await cloneRepository('merge-conflict');
-        const repo = await buildRepository(workingDirPath);
-        try {
-          await repo.git.merge('origin/branch');
-        } catch (e) {
-          // expected
-          if (!e.message.match(/CONFLICT/)) {
-            throw new Error(`merge failed for wrong reason: ${e.message}`);
-          }
-        }
+        const repo = new Repository(workingDirPath);
+        await repo.getLoadPromise();
+        await assert.isRejected(repo.git.merge('origin/branch'), /CONFLICT/);
 
         repo.refresh();
         let mergeConflicts = await repo.getMergeConflicts();
@@ -520,7 +586,8 @@ describe('Repository', function() {
 
       it('returns an empty array if the repo has no merge conflicts', async function() {
         const workingDirPath = await cloneRepository('three-files');
-        const repo = await buildRepository(workingDirPath);
+        const repo = new Repository(workingDirPath);
+        await repo.getLoadPromise();
 
         const mergeConflicts = await repo.getMergeConflicts();
         assert.deepEqual(mergeConflicts, []);
@@ -530,12 +597,9 @@ describe('Repository', function() {
     describe('stageFiles([path])', function() {
       it('updates the staged changes accordingly', async function() {
         const workingDirPath = await cloneRepository('merge-conflict');
-        const repo = await buildRepository(workingDirPath);
-        try {
-          await repo.git.merge('origin/branch');
-        } catch (e) {
-          // expected
-        }
+        const repo = new Repository(workingDirPath);
+        await repo.getLoadPromise();
+        await assert.isRejected(repo.git.merge('origin/branch'));
 
         repo.refresh();
         const mergeConflictPaths = (await repo.getMergeConflicts()).map(c => c.filePath);
@@ -584,12 +648,9 @@ describe('Repository', function() {
     describe('pathHasMergeMarkers()', function() {
       it('returns true if and only if the file has merge markers', async function() {
         const workingDirPath = await cloneRepository('merge-conflict');
-        const repo = await buildRepository(workingDirPath);
-        try {
-          await repo.git.merge('origin/branch');
-        } catch (e) {
-          // expected
-        }
+        const repo = new Repository(workingDirPath);
+        await repo.getLoadPromise();
+        await assert.isRejected(repo.git.merge('origin/branch'));
 
         assert.isTrue(await repo.pathHasMergeMarkers('added-to-both.txt'));
         assert.isFalse(await repo.pathHasMergeMarkers('removed-on-master.txt'));
@@ -625,12 +686,11 @@ describe('Repository', function() {
       describe('when the working directory is clean', function() {
         it('resets the index and the working directory to match HEAD', async function() {
           const workingDirPath = await cloneRepository('merge-conflict-abort');
-          const repo = await buildRepository(workingDirPath);
-          try {
-            await repo.git.merge('origin/spanish');
-          } catch (e) {
-            // expected
-          }
+          const repo = new Repository(workingDirPath);
+          await repo.getLoadPromise();
+
+          await assert.isRejected(repo.git.merge('origin/spanish'));
+
           assert.equal(await repo.isMerging(), true);
           await repo.abortMerge();
           assert.equal(await repo.isMerging(), false);
@@ -640,12 +700,9 @@ describe('Repository', function() {
       describe('when a dirty file in the working directory is NOT under conflict', function() {
         it('successfully aborts the merge and does not affect the dirty file', async function() {
           const workingDirPath = await cloneRepository('merge-conflict-abort');
-          const repo = await buildRepository(workingDirPath);
-          try {
-            await repo.git.merge('origin/spanish');
-          } catch (e) {
-            // expected
-          }
+          const repo = new Repository(workingDirPath);
+          await repo.getLoadPromise();
+          await assert.isRejected(repo.git.merge('origin/spanish'));
 
           fs.writeFileSync(path.join(workingDirPath, 'fruit.txt'), 'a change\n');
           assert.equal(await repo.isMerging(), true);
@@ -661,12 +718,9 @@ describe('Repository', function() {
       describe('when a dirty file in the working directory is under conflict', function() {
         it('throws an error indicating that the abort could not be completed', async function() {
           const workingDirPath = await cloneRepository('merge-conflict-abort');
-          const repo = await buildRepository(workingDirPath);
-          try {
-            await repo.git.merge('origin/spanish');
-          } catch (e) {
-            // expected
-          }
+          const repo = new Repository(workingDirPath);
+          await repo.getLoadPromise();
+          await assert.isRejected(repo.git.merge('origin/spanish'));
 
           fs.writeFileSync(path.join(workingDirPath, 'animal.txt'), 'a change\n');
           const stagedChanges = await repo.getStagedChanges();
@@ -675,7 +729,7 @@ describe('Repository', function() {
           assert.equal(await repo.isMerging(), true);
           try {
             await repo.abortMerge();
-            assert(false);
+            assert.fail(null, null, 'repo.abortMerge() unexepctedly succeeded');
           } catch (e) {
             assert.match(e.command, /^git merge --abort/);
           }
@@ -690,7 +744,9 @@ describe('Repository', function() {
   describe('discardWorkDirChangesForPaths()', function() {
     it('can discard working directory changes in modified files', async function() {
       const workingDirPath = await cloneRepository('three-files');
-      const repo = await buildRepository(workingDirPath);
+      const repo = new Repository(workingDirPath);
+      await repo.getLoadPromise();
+
       fs.writeFileSync(path.join(workingDirPath, 'subdir-1', 'a.txt'), 'qux\nfoo\nbar\n', 'utf8');
       fs.writeFileSync(path.join(workingDirPath, 'subdir-1', 'b.txt'), 'qux\nfoo\nbar\n', 'utf8');
       fs.writeFileSync(path.join(workingDirPath, 'new-file.txt'), 'hello there', 'utf8');
@@ -704,7 +760,9 @@ describe('Repository', function() {
 
     it('can discard working directory changes in removed files', async function() {
       const workingDirPath = await cloneRepository('three-files');
-      const repo = await buildRepository(workingDirPath);
+      const repo = new Repository(workingDirPath);
+      await repo.getLoadPromise();
+
       fs.unlinkSync(path.join(workingDirPath, 'subdir-1', 'a.txt'));
       fs.unlinkSync(path.join(workingDirPath, 'subdir-1', 'b.txt'));
       const unstagedChanges = await repo.getUnstagedChanges();
@@ -717,7 +775,9 @@ describe('Repository', function() {
 
     it('can discard working directory changes added files', async function() {
       const workingDirPath = await cloneRepository('three-files');
-      const repo = await buildRepository(workingDirPath);
+      const repo = new Repository(workingDirPath);
+      await repo.getLoadPromise();
+
       fs.writeFileSync(path.join(workingDirPath, 'subdir-1', 'e.txt'), 'qux', 'utf8');
       fs.writeFileSync(path.join(workingDirPath, 'subdir-1', 'f.txt'), 'qux', 'utf8');
       const unstagedChanges = await repo.getUnstagedChanges();
@@ -732,7 +792,8 @@ describe('Repository', function() {
   describe('maintaining discard history across repository instances', function() {
     it('restores the history', async function() {
       const workingDirPath = await cloneRepository('three-files');
-      const repo1 = await buildRepository(workingDirPath);
+      const repo1 = new Repository(workingDirPath);
+      await repo1.getLoadPromise();
 
       fs.writeFileSync(path.join(workingDirPath, 'a.txt'), 'qux\nfoo\nbar\n', 'utf8');
       fs.writeFileSync(path.join(workingDirPath, 'b.txt'), 'woohoo', 'utf8');
@@ -748,7 +809,8 @@ describe('Repository', function() {
       });
       const repo1HistorySha = repo1.createDiscardHistoryBlob();
 
-      const repo2 = await buildRepository(workingDirPath);
+      const repo2 = new Repository(workingDirPath);
+      await repo2.getLoadPromise();
       const repo2HistorySha = repo2.createDiscardHistoryBlob();
 
       assert.deepEqual(repo2HistorySha, repo1HistorySha);
@@ -756,14 +818,16 @@ describe('Repository', function() {
 
     it('is resilient to missing history blobs', async function() {
       const workingDirPath = await cloneRepository('three-files');
-      const repo1 = await buildRepository(workingDirPath);
+      const repo1 = new Repository(workingDirPath);
+      await repo1.getLoadPromise();
       await repo1.setConfig('atomGithub.historySha', '1111111111111111111111111111111111111111');
 
       // Should not throw
       await repo1.updateDiscardHistory();
 
       // Also should not throw
-      await buildRepository(workingDirPath);
+      const repo2 = new Repository(workingDirPath);
+      await repo2.getLoadPromise();
     });
   });
 });
diff --git a/test/models/workdir-cache.test.js b/test/models/workdir-cache.test.js
new file mode 100644
index 0000000000..31963dcec0
--- /dev/null
+++ b/test/models/workdir-cache.test.js
@@ -0,0 +1,122 @@
+import path from 'path';
+import temp from 'temp';
+
+import {cloneRepository} from '../helpers';
+
+import WorkdirCache from '../../lib/models/workdir-cache';
+
+describe('WorkdirCache', function() {
+  let cache;
+
+  beforeEach(function() {
+    cache = new WorkdirCache(5);
+  });
+
+  it('finds a workdir that is the given path', async function() {
+    const sameDir = await cloneRepository('three-files');
+    const workDir = await cache.find(sameDir);
+    assert.equal(sameDir, workDir);
+  });
+
+  it("finds a workdir that's a parent of the given path", async function() {
+    const expectedDir = await cloneRepository('three-files');
+    const givenDir = path.join(expectedDir, 'subdir-1');
+    const actualDir = await cache.find(givenDir);
+
+    assert.equal(actualDir, expectedDir);
+  });
+
+  it('returns null when a path is not in a git repository', async function() {
+    const nonWorkdirPath = temp.mkdirSync();
+    assert.isNull(await cache.find(nonWorkdirPath));
+  });
+
+  it('returns null when a path does not exist', async function() {
+    const nope = path.join(
+      __dirname,
+      'does', 'not', 'exist', 'no', 'seriously', 'why', 'did', 'you', 'name', 'a', 'directory', 'this',
+    );
+    assert.isNull(await cache.find(nope));
+  });
+
+  it('understands a file path', async function() {
+    const expectedDir = await cloneRepository('three-files');
+    const givenFile = path.join(expectedDir, 'subdir-1', 'b.txt');
+    const actualDir = await cache.find(givenFile);
+
+    assert.equal(actualDir, expectedDir);
+  });
+
+  it('caches previously discovered results', async function() {
+    const expectedDir = await cloneRepository('three-files');
+    const givenDir = path.join(expectedDir, 'subdir-1');
+
+    // Prime the cache
+    await cache.find(givenDir);
+
+    sinon.spy(cache, 'walkToRoot');
+    const actualDir = await cache.find(givenDir);
+    assert.equal(actualDir, expectedDir);
+    assert.isFalse(cache.walkToRoot.called);
+  });
+
+  it('removes cached entries for all subdirectories of an entry', async function() {
+    const [dir0, dir1] = await Promise.all([
+      cloneRepository('three-files'),
+      cloneRepository('three-files'),
+    ]);
+
+    const pathsToCheck = [
+      dir0,
+      path.join(dir0, 'a.txt'),
+      path.join(dir0, 'subdir-1'),
+      path.join(dir0, 'subdir-1', 'b.txt'),
+      dir1,
+    ];
+    const expectedWorkdirs = [
+      dir0, dir0, dir0, dir0, dir1,
+    ];
+
+    // Prime the cache
+    const initial = await Promise.all(
+      pathsToCheck.map(input => cache.find(input)),
+    );
+    assert.deepEqual(initial, expectedWorkdirs);
+
+    // Re-lookup and hit the cache
+    sinon.spy(cache, 'walkToRoot');
+    const relookup = await Promise.all(
+      pathsToCheck.map(input => cache.find(input)),
+    );
+    assert.deepEqual(relookup, expectedWorkdirs);
+    assert.equal(cache.walkToRoot.callCount, 0);
+
+    // Clear dir0
+    await cache.invalidate(dir0);
+
+    // Re-lookup and hit the cache once
+    const after = await Promise.all(
+      pathsToCheck.map(input => cache.find(input)),
+    );
+    assert.deepEqual(after, expectedWorkdirs);
+    assert.isTrue(cache.walkToRoot.calledWith(dir0));
+    assert.isTrue(cache.walkToRoot.calledWith(path.join(dir0, 'a.txt')));
+    assert.isTrue(cache.walkToRoot.calledWith(path.join(dir0, 'subdir-1')));
+    assert.isTrue(cache.walkToRoot.calledWith(path.join(dir0, 'subdir-1', 'b.txt')));
+    assert.isFalse(cache.walkToRoot.calledWith(dir1));
+  });
+
+  it('clears the cache when the maximum size is exceeded', async function() {
+    const dirs = await Promise.all(
+      Array(6).fill(null, 0, 6).map(() => cloneRepository('three-files')),
+    );
+
+    await Promise.all(dirs.map(dir => cache.find(dir)));
+    const expectedDir = dirs[1];
+
+    sinon.spy(cache, 'walkToRoot');
+    const actualDir = await cache.find(expectedDir);
+    assert.equal(actualDir, expectedDir);
+    assert.isTrue(cache.walkToRoot.called);
+  });
+});
diff --git a/test/models/workdir-context-pool.test.js b/test/models/workdir-context-pool.test.js
new file mode 100644
index 0000000000..90278b8cda
--- /dev/null
+++ b/test/models/workdir-context-pool.test.js
@@ -0,0 +1,223 @@
+import temp from 'temp';
+
+import {cloneRepository, sha} from '../helpers';
+
+import WorkdirContextPool from '../../lib/models/workdir-context-pool';
+
+describe('WorkdirContextPool', function() {
+  let pool;
+  let mockWindow, mockWorkspace;
+
+  beforeEach(function() {
+    mockWindow = {
+      addEventListener: sinon.spy(),
+      removeEventListener: sinon.spy(),
+    };
+
+    mockWorkspace = {
+      observeTextEditors: sinon.spy(),
+    };
+
+    pool = new WorkdirContextPool({
+      window: mockWindow,
+      workspace: mockWorkspace,
+    });
+  });
+
+  describe('add', function() {
+    let workingDirectory;
+
+    beforeEach(async function() {
+      workingDirectory = await cloneRepository('three-files');
+    });
+
+    it('adds a WorkdirContext for a new working directory', function() {
+      assert.equal(pool.size(), 0);
+      assert.isFalse(pool.getContext(workingDirectory).isPresent());
+
+      pool.add(workingDirectory);
+
+      assert.equal(pool.size(), 1);
+      assert.isTrue(pool.getContext(workingDirectory).isPresent());
+    });
+
+    it('is a no-op if the working directory already has a context', function() {
+      pool.add(workingDirectory);
+      assert.equal(pool.size(), 1);
+
+      const context = pool.getContext(workingDirectory);
+      assert.isTrue(context.isPresent());
+
+      pool.add(workingDirectory);
+      assert.equal(pool.size(), 1);
+    });
+
+    it('begins but does not await the asynchronous initialization process', async function() {
+      pool.add(workingDirectory);
+      const context = pool.getContext(workingDirectory);
+      assert.isTrue(context.getRepository().isLoading());
+      assert.isTrue(context.getResolutionProgress().isEmpty());
+      assert.isFalse(context.getChangeObserver().isStarted());
+
+      await context.getRepositoryStatePromise('Present');
+      assert.isTrue(context.getRepository().isPresent());
+    });
+
+    it('passes appropriate serialized state to the resolution progress', async function() {
+      const resolutionProgressByPath = {
+        [workingDirectory]: {
+          revision: await sha(workingDirectory),
+          paths: {'a.txt': 12},
+        },
+      };
+
+      pool.add(workingDirectory, {resolutionProgressByPath});
+      const context = pool.getContext(workingDirectory);
+      await context.getRepositoryStatePromise('Present');
+
+      const resolutionProgress = context.getResolutionProgress();
+      assert.equal(resolutionProgress.getRemaining('a.txt'), 12);
+    });
+  });
+
+  describe('replace', function() {
+    it('adds a WorkdirContext if one is absent', function() {
+      const directory = temp.mkdirSync();
+
+      assert.equal(pool.size(), 0);
+      assert.isFalse(pool.getContext(directory).isPresent());
+
+      pool.replace(directory);
+
+      assert.equal(pool.size(), 1);
+      assert.isTrue(pool.getContext(directory).isPresent());
+    });
+
+    it('removes an existing WorkdirContext if one is present', async function() {
+      const directory = await cloneRepository('three-files');
+
+      pool.add(directory);
+      assert.equal(pool.size(), 1);
+      const context = pool.getContext(directory);
+      assert.isTrue(context.isPresent());
+      const original = context.getRepository();
+
+      pool.replace(directory);
+      assert.equal(pool.size(), 1);
+      assert.isTrue(pool.getContext(directory).isPresent());
+      const replaced = pool.getContext(directory).getRepository();
+
+      assert.notStrictEqual(original, replaced);
+    });
+  });
+
+  describe('remove', function() {
+    let existingDirectory, existingContext;
+
+    beforeEach(async function() {
+      existingDirectory = await cloneRepository('three-files');
+      pool.add(existingDirectory);
+
+      existingContext = pool.getContext(existingDirectory);
+    });
+
+    it('removes a WorkdirContext for an existing working directory', function() {
+      assert.equal(pool.size(), 1);
+      pool.remove(existingDirectory);
+      assert.isFalse(pool.getContext(existingDirectory).isPresent());
+      assert.equal(pool.size(), 0);
+    });
+
+    it('is a no-op if the working directory is not present', function() {
+      assert.equal(pool.size(), 1);
+      pool.remove('/nope');
+      assert.equal(pool.size(), 1);
+    });
+
+    it('begins but does not await the termination process', function() {
+      const repo = existingContext.getRepository();
+      sinon.spy(repo, 'destroy');
+
+      assert.isFalse(existingContext.isDestroyed());
+      pool.remove(existingDirectory);
+      assert.isTrue(existingContext.isDestroyed());
+      assert.isTrue(repo.destroy.called);
+    });
+  });
+
+  describe('set', function() {
+    let dir0, dir1, dir2;
+
+    beforeEach(async function() {
+      [dir0, dir1, dir2] = await Promise.all([
+        cloneRepository('three-files'),
+        cloneRepository('three-files'),
+        cloneRepository('three-files'),
+      ]);
+
+      pool.add(dir0);
+      pool.add(dir1);
+    });
+
+    it('adds new directories, removes missing ones, and maintains kept ones', function() {
+      const context0 = pool.getContext(dir0);
+      const context1 = pool.getContext(dir1);
+
+      pool.set([dir1, dir2]);
+
+      assert.equal(pool.size(), 2);
+
+      assert.isFalse(pool.getContext(dir0).isPresent());
+      assert.isTrue(pool.getContext(dir1).isPresent());
+      assert.isTrue(pool.getContext(dir2).isPresent());
+
+      assert.isTrue(context0.isDestroyed());
+      assert.isFalse(context1.isDestroyed());
+    });
+  });
+
+  describe('getContext', function() {
+    let dir;
+
+    beforeEach(async function() {
+      dir = await cloneRepository('three-files');
+      pool.add(dir);
+    });
+
+    it('returns a context by directory', function() {
+      const context = pool.getContext(dir);
+      assert.isTrue(context.isPresent());
+
+      const repo = context.getRepository();
+      assert.strictEqual(dir, repo.getWorkingDirectoryPath());
+    });
+
+    it('returns a null context when missing', function() {
+      const context = pool.getContext('/nope');
+      assert.isFalse(context.isPresent());
+    });
+  });
+
+  describe('clear', function() {
+    it('removes all resident contexts', async function() {
+      const [dir0, dir1, dir2] = await Promise.all([
+        cloneRepository('three-files'),
+        cloneRepository('three-files'),
+        cloneRepository('three-files'),
+      ]);
+
+      pool.add(dir0);
+      pool.add(dir1);
+      pool.add(dir2);
+
+      assert.equal(pool.size(), 3);
+
+      pool.clear();
+
+      assert.equal(pool.size(), 0);
+      assert.isFalse(pool.getContext(dir0).isPresent());
+      assert.isFalse(pool.getContext(dir1).isPresent());
+      assert.isFalse(pool.getContext(dir2).isPresent());
+    });
+  });
+});
diff --git a/test/models/workdir-context.test.js b/test/models/workdir-context.test.js
new file mode 100644
index 0000000000..e92c718e23
--- /dev/null
+++ b/test/models/workdir-context.test.js
@@ -0,0 +1,143 @@
+import {CompositeDisposable, Disposable} from 'event-kit';
+
+import {cloneRepository, sha} from '../helpers';
+
+import WorkdirContext, {absentWorkdirContext} from '../../lib/models/workdir-context';
+
+describe('WorkdirContext', function() {
+  let context, workingDirectory, subs;
+  let mockPromptCallback;
+
+  beforeEach(async function() {
+    workingDirectory = await cloneRepository('three-files');
+    subs = new CompositeDisposable();
+
+    const mockWindow = {
+      addEventListener: sinon.spy(),
+      removeEventListener: sinon.spy(),
+    };
+
+    const mockWorkspace = {
+      observeTextEditors: sinon.stub().returns(new Disposable()),
+    };
+
+    const mockSavedResolutionProgress = {
+      revision: await sha(workingDirectory),
+      paths: {
+        'a.txt': 2,
+        'b.txt': 3,
+      },
+    };
+
+    mockPromptCallback = query => 'reply';
+
+    context = new WorkdirContext(workingDirectory, {
+      window: mockWindow,
+      workspace: mockWorkspace,
+      promptCallback: mockPromptCallback,
+      savedResolutionProgress: mockSavedResolutionProgress,
+    });
+  });
+
+  afterEach(async function() {
+    context && await context.destroy();
+    subs.dispose();
+  });
+
+  it('returns synchronous models in their initial states', function() {
+    assert.isTrue(context.getRepository().isLoading());
+    assert.isTrue(context.getResolutionProgress().isEmpty());
+    assert.isFalse(context.getChangeObserver().isStarted());
+  });
+
+  it('updates the resolution progress once the repository loads', async function() {
+    const progress = context.getResolutionProgress();
+
+    await context.getRepositoryStatePromise('Present');
+
+    assert.isFalse(progress.isEmpty());
+    assert.equal(progress.getRemaining('a.txt'), 2);
+    assert.equal(progress.getRemaining('b.txt'), 3);
+  });
+
+  it('starts the change observer after the repository loads', async function() {
+    const observer = context.getChangeObserver();
+    await context.getObserverStartedPromise();
+    assert.isTrue(observer.isStarted());
+  });
+
+  it('configures the repository with a prompt callback', async function() {
+    const repo = context.getRepository();
+    await repo.getLoadPromise();
+
+    for (const strategy of repo.git.getImplementers()) {
+      assert.strictEqual(strategy.prompt, mockPromptCallback);
+    }
+  });
+
+  it('notifies the repository on any filesystem change', async function() {
+    const repo = context.getRepository();
+    await context.getRepositoryStatePromise('Present');
+
+    sinon.spy(repo, 'observeFilesystemChange');
+
+    const payload = {};
+    context.getChangeObserver().didChange(payload);
+
+    assert.isTrue(repo.observeFilesystemChange.calledWith(payload));
+  });
+
+  it('re-emits an event on workdir or head change', async function() {
+    const listener = sinon.spy();
+    subs.add(context.onDidChangeWorkdirOrHead(listener));
+
+    await context.getRepositoryStatePromise('Present');
+
+    context.getChangeObserver().didChangeWorkdirOrHead();
+    assert.isTrue(listener.called);
+  });
+
+  it('destroys the repository on destroy()', async function() {
+    await context.getRepositoryStatePromise('Present');
+    const repo = context.getRepository();
+
+    await context.destroy();
+    assert.isTrue(repo.isDestroyed());
+  });
+
+  it('stops the change observer on destroy()', async function() {
+    const observer = context.getChangeObserver();
+    await observer.start();
+
+    await context.destroy();
+    await assert.async.isFalse(observer.isStarted());
+  });
+
+  it('can be destroyed twice', async function() {
+    assert.isFalse(context.isDestroyed());
+
+    await context.destroy();
+    assert.isTrue(context.isDestroyed());
+
+    await context.destroy();
+    assert.isTrue(context.isDestroyed());
+  });
+
+  it('exports a singleton containing a Repository in the absent state', function() {
+    assert.isTrue(absentWorkdirContext.getRepository().isAbsent());
+  });
+
+  it('can be constructed containing an undetermined Repository that acts absent', function() {
+    const undetermined = WorkdirContext.guess({});
+    assert.isTrue(undetermined.getRepository().isUndetermined());
+    assert.isFalse(undetermined.getRepository().showGitTabLoading());
+    assert.isTrue(undetermined.getRepository().showGitTabInit());
+  });
+
+  it("can be constructed containing an undetermined Repository that acts like it's loading", function() {
+    const undetermined = WorkdirContext.guess({projectPathCount: 1});
+    assert.isTrue(undetermined.getRepository().isUndetermined());
+    assert.isTrue(undetermined.getRepository().showGitTabLoading());
+    assert.isFalse(undetermined.getRepository().showGitTabInit());
+  });
+});
diff --git a/test/switchboard.test.js b/test/switchboard.test.js
index 1403a6634e..41e624fd6d 100644
--- a/test/switchboard.test.js
+++ b/test/switchboard.test.js
@@ -1,4 +1,4 @@
-import {CompositeDisposable} from 'atom'; // FIXME import from event-kit
+import {CompositeDisposable} from 'event-kit';
 import Switchboard from '../lib/switchboard';
 
 describe('Switchboard', function() {
diff --git a/test/views/commit-view.test.js b/test/views/commit-view.test.js
index 5c42e20417..c5673f3c6c 100644
--- a/test/views/commit-view.test.js
+++ b/test/views/commit-view.test.js
@@ -2,6 +2,7 @@ import {cloneRepository, buildRepository} from '../helpers';
 import etch from 'etch';
 import until from 'test-until';
 
+import Commit, {nullCommit} from '../../lib/models/commit';
 import CommitView from '../../lib/views/commit-view';
 
 describe('CommitView', function() {
@@ -11,13 +12,35 @@ describe('CommitView', function() {
     atomEnv = global.buildAtomEnvironment();
     commandRegistry = atomEnv.commands;
 
-    lastCommit = {sha: '1234abcd', message: 'commit message', unbornRef: false};
+    lastCommit = new Commit('1234abcd', 'commit message');
   });
 
   afterEach(function() {
     atomEnv.destroy();
   });
 
+  describe('when the repo is loading', function() {
+    let view;
+
+    beforeEach(function() {
+      view = new CommitView({
+        commandRegistry, lastCommit: nullCommit,
+        stagedChangesExist: false, maximumCharacterLimit: 72, message: '',
+      });
+    });
+
+    it("doesn't show the amend checkbox", function() {
+      assert.isUndefined(view.refs.amend);
+    });
+
+    it('disables the commit button', async function() {
+      view.refs.editor.setText('even with text');
+      await view.update({});
+
+      assert.isTrue(view.refs.commitButton.disabled);
+    });
+  });
+
   it('displays the remaining characters limit based on which line is being edited', async function() {
     const view = new CommitView({
       commandRegistry, lastCommit,
@@ -192,10 +215,12 @@ describe('CommitView', function() {
 
   describe('amending', function() {
     it('calls props.setAmending() when the box is checked or unchecked', function() {
+      const previousCommit = new Commit('111', "previous commit's message");
+
       const setAmending = sinon.spy();
       const view = new CommitView({
         commandRegistry,
-        stagedChangesExist: false, lastCommit: {message: 'previous commit\'s message'}, setAmending,
+        stagedChangesExist: false, lastCommit: previousCommit, setAmending,
       });
       const {amend} = view.refs;
 
@@ -210,7 +235,7 @@ describe('CommitView', function() {
       const view = new CommitView({
         commandRegistry,
         stagedChangesExist: false,
-        lastCommit: {unbornRef: true},
+        lastCommit: Commit.createUnborn(),
       });
       assert.isUndefined(view.refs.amend);
     });
diff --git a/test/views/init-dialog.test.js b/test/views/init-dialog.test.js
new file mode 100644
index 0000000000..3991558c49
--- /dev/null
+++ b/test/views/init-dialog.test.js
@@ -0,0 +1,68 @@
+import React from 'react';
+import {mount} from 'enzyme';
+import path from 'path';
+
+import InitDialog from '../../lib/views/init-dialog';
+
+describe('InitDialog', function() {
+  let atomEnv, config, commandRegistry;
+  let app, wrapper, didAccept, didCancel;
+
+  beforeEach(function() {
+    atomEnv = global.buildAtomEnvironment();
+    config = atomEnv.config;
+    commandRegistry = atomEnv.commands;
+    sinon.stub(config, 'get').returns(path.join('home', 'me', 'codes'));
+
+    didAccept = sinon.stub();
+    didCancel = sinon.stub();
+
+    app = (
+      <InitDialog
+        config={config}
+        commandRegistry={commandRegistry}
+        didAccept={didAccept}
+        didCancel={didCancel}
+      />
+    );
+    wrapper = mount(app);
+  });
+
+  afterEach(function() {
+    atomEnv.destroy();
+  });
+
+  const setTextIn = function(selector, text) {
+    wrapper.find(selector).getDOMNode().getModel().setText(text);
+  };
+
+  it('defaults to your project home path', function() {
+    const text = wrapper.find('atom-text-editor').getDOMNode().getModel().getText();
+    assert.equal(text, path.join('home', 'me', 'codes'));
+  });
+
+  it('disables the initialize button with no project path', function() {
+    setTextIn('.github-ProjectPath atom-text-editor', '');
+
+    assert.isTrue(wrapper.find('button.icon-repo-create').prop('disabled'));
+  });
+
+  it('enables the initialize button when the project path is populated', function() {
+    setTextIn('.github-ProjectPath atom-text-editor', path.join('somewhere', 'else'));
+
+    assert.isFalse(wrapper.find('button.icon-repo-create').prop('disabled'));
+  });
+
+  it('calls the acceptance callback', function() {
+    setTextIn('.github-ProjectPath atom-text-editor', '/somewhere/directory/');
+
+    wrapper.find('button.icon-repo-create').simulate('click');
+
+    assert.isTrue(didAccept.calledWith('/somewhere/directory/'));
+  });
+
+  it('calls the cancellation callback', function() {
+    wrapper.find('button.github-CancelButton').simulate('click');
+    assert.isTrue(didCancel.called);
+  });
+});
diff --git a/test/views/staging-view.test.js b/test/views/staging-view.test.js
index 753109f106..ab7269a5b8 100644
--- a/test/views/staging-view.test.js
+++ b/test/views/staging-view.test.js
@@ -101,7 +101,8 @@ describe('StagingView', function() {
         status: {file: 'modified', ours: 'deleted', theirs: 'modified'},
       }];
 
-      const resolutionProgress = new ResolutionProgress('abcd1234', {});
+      const resolutionProgress = new ResolutionProgress();
+      resolutionProgress.load('abcd1234', {});
 
       const view = new StagingView({
         workingDirectoryPath,
@@ -125,7 +126,8 @@ describe('StagingView', function() {
         status: {file: 'modified', ours: 'deleted', theirs: 'modified'},
       }];
 
-      const resolutionProgress = new ResolutionProgress('abcd1234', {
+      const resolutionProgress = new ResolutionProgress();
+      resolutionProgress.load('abcd1234', {
         revision: 'abcd1234',
         paths: {
           [path.join(workingDirectoryPath, 'conflicted-path')]: 10,
@@ -154,7 +156,8 @@ describe('StagingView', function() {
         status: {file: 'modified', ours: 'deleted', theirs: 'modified'},
       }];
 
-      const resolutionProgress = new ResolutionProgress('abcd1234', {
+      const resolutionProgress = new ResolutionProgress();
+      resolutionProgress.load('abcd1234', {
         revision: 'abcd1234',
         paths: {
           [path.join(workingDirectoryPath, 'conflicted-path')]: 0,
@@ -186,7 +189,8 @@ describe('StagingView', function() {
         },
       ];
 
-      const resolutionProgress = new ResolutionProgress('abcd1234', {
+      const resolutionProgress = new ResolutionProgress();
+      resolutionProgress.load('abcd1234', {
         revision: 'abcd1234',
         paths: {
           [path.join(workingDirectoryPath, 'conflicted-path-0.txt')]: 2,
@@ -218,7 +222,8 @@ describe('StagingView', function() {
         status: {file: 'modified', ours: 'deleted', theirs: 'modified'},
       }];
 
-      const resolutionProgress = new ResolutionProgress('abcd1234', {
+      const resolutionProgress = new ResolutionProgress();
+      resolutionProgress.load('abcd1234', {
         revision: 'abcd1234',
         paths: {
           [path.join(workingDirectoryPath, 'conflicted-path')]: 0,