anchor.diff:            return new Some(currentPubspecVersion);
           } else {
             _log.warning(() =>
  -              "Project ${project.name} is hosted but has never been tagged in git. "
  +              "Project ${_project.name} is hosted but has never been tagged in git. "
                 "Can't tell if there are unpublished changes. "
                 "Will not release as pubspec version is not greater than hosted version");
             return const None();
  
positive.code:               type: type, autoUpdateHostedVersions: autoUpdateHostedVersions),
            mode: CommandConcurrencyMode.serialDepthFirst);
  
    @override
    Future init({bool doCheckout: true}) {
      if (!recursive) return initCurrentProject(doCheckout);
  
      Future doInit(JefeProject project) =>
          project.lifecycle.init(doCheckout: doCheckout, recursive: false);
  
      return executeTask(
          'Initialising for development', () => graph.processDepthFirst(doInit));
    }
  
    Future initCurrentProject(bool doCheckout) {
      return executeTask('Initialising for development for project ${graph.name}',
          () async {
        await _git.fetch();
        await _gitFeature.init();
  
        final currentFeatureNameOpt = await _gitFeature.currentFeatureName();
  
        if (currentFeatureNameOpt is Some) {
          final currentFeatureName = currentFeatureNameOpt.get();
          _log.info('Detected existing feature - $currentFeatureName');
          await startNewFeature(currentFeatureName);
        } else {
          if (doCheckout) await _git.checkout(_gitFeature.developBranchName);
        }
      });
    }
  
    Future<ProjectVersions> getCurrentProjectVersions(JefeProject project,
        ReleaseType type, bool autoUpdateHostedVersions) async {
      final currentProjectVersions = await project.projectVersions;
  
      _log.fine('${project.name}: $currentProjectVersions');
  
      final Option<Version> releaseVersionOpt = await _getReleaseVersion(
          currentProjectVersions, autoUpdateHostedVersions, type, project);
  
      return new ProjectVersions(currentProjectVersions, releaseVersionOpt);
    }
  
    Future<Option<Version>> _getReleaseVersion(
        ProjectVersions2 currentVersions,
        bool autoUpdateHostedVersions,
        ReleaseType type,
        JefeProject project) async {
      final hasBeenPublished = currentVersions.hasBeenPublished;
      final isHosted = currentVersions.isHosted;
      final currentPubspecVersion = currentVersions.pubspecVersion;
  
      if (currentVersions.hasBeenGitTagged) {
        final latestTaggedVersion = currentVersions.taggedGitVersion.get();
        if (latestTaggedVersion > currentPubspecVersion) {
          throw new StateError('the latest tagged version $latestTaggedVersion'
              ' is greater than the current pubspec version $currentPubspecVersion');
        } else if (latestTaggedVersion < currentPubspecVersion) {
          // manually bumped version
          return new Some<Version>(currentPubspecVersion);
        } else {
          // latest released version is same as pubspec version
          if (await hasChanges) {
            if (isHosted && !autoUpdateHostedVersions) {
              // Hosted packages must observe semantic versioning so not sensible
              // to try to automatically bump version, unless the user explicitly
              // requests it
              throw new ArgumentError(
                  '${project.name} is hosted and has changes. '
                  'The version must be manually changed for hosted packages');
            } else {
              return new Some(type.bump(currentPubspecVersion));
            }
          } else {
            return const None();
          }
        }
      } else {
        // never been tagged
        if (hasBeenPublished) {
          if (currentPubspecVersion > currentVersions.publishedVersion.get()) {
            return new Some(currentPubspecVersion);
          } else {
            _log.warning(() =>
                "Project ${project.name} is hosted but has never been tagged in git. "
                "Can't tell if there are unpublished changes. "
                "Will not release as pubspec version is not greater than hosted version");
            return const None();
          }
        } else {
          // never tagged and never published. Assume it needs releasing
          return new Some(currentPubspecVersion);
        }
      }
    }
  
    Future<bool> get hasChanges async =>
        new Stream<bool>.fromFutures(<Future<bool>>[
          _gitFeature.hasChangesSinceLatestTaggedVersion,
          _pubspec.haveDependenciesChanged(DependencyType.hosted)
        ]).any((b) => b);
  }
  
  class _ProjectLifecycleSingleProjectImpl
  
negative.code:     implements ProjectLifecycle {
    ProjectLifecycleMultiProjectImpl(JefeProjectGraph graph) : super(graph);
  
    @override
    Future completeFeature({String featureName, bool doPush: false}) {
      return executeTask('complete development of feature $featureName',
  