anchor.diff:  
           await _project.pubspecCommands.setToHostedDependencies();
   
  -        await _project.pub.get();
  -
  -        await _project.pub.test();
  -
  -        await _project.git.commit('releasing version $releaseVersion');
  +        await _pub.get();
  +
  +        await _pub.test();
  +
  +        await _git.commit('releasing version $releaseVersion');
   
           if (projectVersions.hasBeenPublished) {
  -          await _project.pub.publish();
  -        }
  -
  -        await _project.gitFeature.releaseFinish(releaseVersion.toString());
  -
  -        await _project.git.push();
  +          await _pub.publish();
  +        }
  +
  +        await _gitFeature.releaseFinish(releaseVersion.toString());
  +
  +        await _git.push();
         }
       });
     }
  
positive.code: 
  import 'package:git/git.dart';
  import 'package:jefe/src/git/git.dart';
  import 'package:jefe/src/project/jefe_project.dart';
  import 'package:jefe/src/project/project.dart';
  import 'package:jefe/src/project/pubspec_commands.dart';
  import 'package:jefe/src/project/release_type.dart';
  import 'package:jefe/src/project_commands/project_command.dart'
      show executeTask;
  //import 'package:jefe/src/project_commands/project_command_executor.dart';
  //import 'package:jefe/src/project_commands/project_lifecycle.dart';
  import 'package:logging/logging.dart';
  import 'package:option/option.dart';
  import 'package:pub_semver/pub_semver.dart';
  import 'package:jefe/src/project/project_lifecycle.dart';
  
  Logger _log = new Logger('jefe.project.commands.git.feature.impl');
  
  const String featureStartCommitPrefix = 'set up project for new feature';
  
  class ProjectLifecycleImpl implements ProjectLifecycle {
  //  final GitFeatureCommands _gitFeature;
  //  final GitCommands _git;
  //  final PubCommands _pub;
  //  final PubSpecCommands _pubSpec;
  
    final JefeProject _project;
    ProjectLifecycleImpl(this._project);
  
  //  ProjectLifecycleImpl(
  //      {GitFeatureCommandsFactory gitFeatureFactory: defaultFlowFeatureFactory})
  //      : this._gitFeature = gitFeatureFactory(),
  //        this._git = new GitCommands(),
  //        this._pub = new PubCommands(),
  //        this._pubSpec = new PubSpecCommands();
  
    @override
    Future startNewFeature(String featureName,
        {bool doPush: false, bool recursive: true}) {
      return executeTask(
          'set up project for new feature "$featureName"',
          () => Future.wait([
                _project.git.assertWorkingTreeClean(),
                _project.gitFeature.featureStart(featureName),
                _project.pubspecCommands.setToPathDependencies(),
                _project.pub.get(),
                _project.git.commit('$featureStartCommitPrefix $featureName'),
                _project.git.push().copy(condition: () => doPush)
              ]));
    }
  
    // TODO: return to this approach once the concurrency support is implemented
  
negative.code:     return executeTask(
          'complete development of feature $featureName for project ${_project.name}',
          () async {
        await _git.assertWorkingTreeClean();
  
        final currentBranchName =
            await gitCurrentBranchName(await _project.gitDir);
        if (!(currentBranchName == _gitFeature.developBranchName)) {
          await _gitFeature.featureFinish(featureName,
              excludeOnlyCommitIf: (Commit c) =>
                  c.message.startsWith(featureStartCommitPrefix));
        }
  
        await _project.pubspecCommands.setToGitDependencies();
        await _pub.get();
        await _git.commit('completed development of feature $featureName');
  
        if (doPush) await _git.push();
      });
    }
  
  