@shepai/cli 1.183.0-pr554.2632d62 → 1.183.0-pr555.e53ab0e

package/dist/packages/core/src/infrastructure/di/container.js

@@ -12,21 +12,156 @@
  */
 import 'reflect-metadata';
 import { container } from 'tsyringe';
+import { SQLiteSettingsRepository } from '../repositories/sqlite-settings.repository.js';
+import { SQLiteFeatureRepository } from '../repositories/sqlite-feature.repository.js';
+import { SQLiteRepositoryRepository } from '../repositories/sqlite-repository.repository.js';
+import { SQLiteApplicationRepository } from '../repositories/sqlite-application.repository.js';
+import { AgentValidatorService } from '../services/agents/common/agent-validator.service.js';
+import { promisify } from 'node:util';
+import { execFile } from 'node:child_process';
+import { IS_WINDOWS } from '../platform.js';
+import { VersionService } from '../services/version.service.js';
+import { WorktreeService } from '../services/git/worktree.service.js';
+import { FileSystemService } from '../services/file-system.service.js';
+import { ApplicationBriefStore } from '../services/filesystem/application-brief.store.js';
+import { FsProjectScaffoldService } from '../services/project-scaffold/fs-project-scaffold.service.js';
+import { ApplicationCreationPromptBuilder } from '../services/agents/application-creation/application-creation-prompt.builder.js';
+import { PlatformAgentAuthDetectorService } from '../services/agent-auth-detector/platform-agent-auth-detector.service.js';
+import { ToolInstallerServiceImpl } from '../services/tool-installer/tool-installer.service.js';
+import { GitPrService } from '../services/git/git-pr.service.js';
+import { GitForkService } from '../services/git/git-fork.service.js';
+import { SkillInjectorService } from '../services/skill-injector.service.js';
+import { JsonDrivenIdeLauncherService } from '../services/ide-launchers/json-driven-ide-launcher.service.js';
+import { DaemonPidService } from '../services/daemon/daemon-pid.service.js';
+import { DeploymentService } from '../services/deployment/deployment.service.js';
+import { ShepInstanceService } from '../services/shep-instance.service.js';
+import { AttachmentStorageService } from '../services/attachment-storage.service.js';
+import { GitHubRepositoryService } from '../services/external/github-repository.service.js';
+import { BrowserOpenerService } from '../services/browser-opener.service.js';
+import { PtyTerminalSessionService } from '../services/terminal/pty-terminal-session.service.js';
+import { CreateTerminalSessionUseCase } from '../../application/use-cases/terminal/create-terminal-session.use-case.js';
+import { NodeApplicationFileSystemService } from '../services/filesystem/node-application-file-system.service.js';
+import { ListApplicationFilesUseCase } from '../../application/use-cases/applications/list-application-files.use-case.js';
+import { ReadApplicationFileUseCase } from '../../application/use-cases/applications/read-application-file.use-case.js';
+import { ReadApplicationFileRawUseCase } from '../../application/use-cases/applications/read-application-file-raw.use-case.js';
+import { WriteApplicationFileUseCase } from '../../application/use-cases/applications/write-application-file.use-case.js';
+import { WatchApplicationFilesUseCase } from '../../application/use-cases/applications/watch-application-files.use-case.js';
+import { AgentExecutorFactory } from '../services/agents/common/agent-executor-factory.service.js';
+import { AgentExecutorProvider } from '../services/agents/common/agent-executor-provider.service.js';
+import { StructuredAgentCallerService } from '../services/agents/common/structured-agent-caller.service.js';
+import { MockAgentExecutorFactory } from '../services/agents/common/executors/mock-executor-factory.service.js';
+import { AgentRegistryService } from '../services/agents/common/agent-registry.service.js';
+import { AgentRunnerService } from '../services/agents/common/agent-runner.service.js';
+import { SQLiteAgentRunRepository } from '../repositories/agent-run.repository.js';
+import { SQLitePhaseTimingRepository } from '../repositories/sqlite-phase-timing.repository.js';
+import { FeatureAgentProcessService } from '../services/agents/feature-agent/feature-agent-process.service.js';
+import { SpecInitializerService } from '../services/spec/spec-initializer.service.js';
+import { DesktopNotifier } from '../services/notifications/desktop-notifier.js';
+import { NotificationService } from '../services/notifications/notification.service.js';
+import { getNotificationBus } from '../services/notifications/notification-bus.js';
+import { spawn } from 'node:child_process';
+// Use cases
+import { InitializeSettingsUseCase } from '../../application/use-cases/settings/initialize-settings.use-case.js';
+import { LoadSettingsUseCase } from '../../application/use-cases/settings/load-settings.use-case.js';
+import { UpdateSettingsUseCase } from '../../application/use-cases/settings/update-settings.use-case.js';
+import { CompleteOnboardingUseCase } from '../../application/use-cases/settings/complete-onboarding.use-case.js';
+import { CompleteWebOnboardingUseCase } from '../../application/use-cases/settings/complete-web-onboarding.use-case.js';
+import { ConfigureAgentUseCase } from '../../application/use-cases/agents/configure-agent.use-case.js';
+import { ValidateAgentAuthUseCase } from '../../application/use-cases/agents/validate-agent-auth.use-case.js';
+import { RunAgentUseCase } from '../../application/use-cases/agents/run-agent.use-case.js';
+import { GetAgentRunUseCase } from '../../application/use-cases/agents/get-agent-run.use-case.js';
+import { ListAgentRunsUseCase } from '../../application/use-cases/agents/list-agent-runs.use-case.js';
+import { StopAgentRunUseCase } from '../../application/use-cases/agents/stop-agent-run.use-case.js';
+import { DeleteAgentRunUseCase } from '../../application/use-cases/agents/delete-agent-run.use-case.js';
+import { ApproveAgentRunUseCase } from '../../application/use-cases/agents/approve-agent-run.use-case.js';
+import { RejectAgentRunUseCase } from '../../application/use-cases/agents/reject-agent-run.use-case.js';
+import { ReviewFeatureUseCase } from '../../application/use-cases/agents/review-feature.use-case.js';
+import { CreateFeatureUseCase } from '../../application/use-cases/features/create/create-feature.use-case.js';
+import { MetadataGenerator } from '../../application/use-cases/features/create/metadata-generator.js';
+import { SlugResolver } from '../../application/use-cases/features/create/slug-resolver.js';
+import { ListFeaturesUseCase } from '../../application/use-cases/features/list-features.use-case.js';
+import { ShowFeatureUseCase } from '../../application/use-cases/features/show-feature.use-case.js';
+import { DeleteFeatureUseCase } from '../../application/use-cases/features/delete-feature.use-case.js';
+import { ResumeFeatureUseCase } from '../../application/use-cases/features/resume-feature.use-case.js';
+import { StartFeatureUseCase } from '../../application/use-cases/features/start-feature.use-case.js';
+import { UpdateFeaturePinnedConfigUseCase } from '../../application/use-cases/features/update-feature-pinned-config.use-case.js';
+import { AdoptBranchUseCase } from '../../application/use-cases/features/adopt-branch.use-case.js';
+import { GetFeatureArtifactUseCase } from '../../application/use-cases/features/get-feature-artifact.use-case.js';
+import { GetResearchArtifactUseCase } from '../../application/use-cases/features/get-research-artifact.use-case.js';
+import { GetPlanArtifactUseCase } from '../../application/use-cases/features/get-plan-artifact.use-case.js';
+import { ValidateToolAvailabilityUseCase } from '../../application/use-cases/tools/validate-tool-availability.use-case.js';
+import { InstallToolUseCase } from '../../application/use-cases/tools/install-tool.use-case.js';
+import { ListToolsUseCase } from '../../application/use-cases/tools/list-tools.use-case.js';
+import { LaunchToolUseCase } from '../../application/use-cases/tools/launch-tool.use-case.js';
+import { LaunchIdeUseCase } from '../../application/use-cases/ide/launch-ide.use-case.js';
+import { AddRepositoryUseCase } from '../../application/use-cases/repositories/add-repository.use-case.js';
+import { CreateProjectUseCase } from '../../application/use-cases/projects/create-project.use-case.js';
+import { CheckAgentAuthUseCase } from '../../application/use-cases/agents/check-agent-auth.use-case.js';
+import { ListRepositoriesUseCase } from '../../application/use-cases/repositories/list-repositories.use-case.js';
+import { DeleteRepositoryUseCase } from '../../application/use-cases/repositories/delete-repository.use-case.js';
+import { ImportGitHubRepositoryUseCase } from '../../application/use-cases/repositories/import-github-repository.use-case.js';
+import { InitRemoteRepositoryUseCase } from '../../application/use-cases/repositories/init-remote-repository.use-case.js';
+import { ListGitHubRepositoriesUseCase } from '../../application/use-cases/repositories/list-github-repositories.use-case.js';
+import { ListGitHubOrganizationsUseCase } from '../../application/use-cases/repositories/list-github-organizations.use-case.js';
+import { CreateFeatureFromRemoteUseCase } from '../../application/use-cases/features/create/create-feature-from-remote.use-case.js';
+import { CheckAndUnblockFeaturesUseCase } from '../../application/use-cases/features/check-and-unblock-features.use-case.js';
+import { UpdateFeatureLifecycleUseCase } from '../../application/use-cases/features/update/update-feature-lifecycle.use-case.js';
+import { CleanupFeatureWorktreeUseCase } from '../../application/use-cases/features/cleanup-feature-worktree.use-case.js';
+import { ArchiveFeatureUseCase } from '../../application/use-cases/features/archive-feature.use-case.js';
+import { UnarchiveFeatureUseCase } from '../../application/use-cases/features/unarchive-feature.use-case.js';
+import { UpgradeCliUseCase } from '../../application/use-cases/upgrade/upgrade-cli.use-case.js';
+import { SyncRepositoryMainUseCase } from '../../application/use-cases/repositories/sync-repository-main.use-case.js';
+import { RebaseFeatureOnMainUseCase } from '../../application/use-cases/features/rebase-feature-on-main.use-case.js';
+import { GetBranchSyncStatusUseCase } from '../../application/use-cases/features/get-branch-sync-status.use-case.js';
+import { ConflictResolutionService } from '../services/agents/conflict-resolution/conflict-resolution.service.js';
+import { AutoResolveMergedBranchesUseCase } from '../../application/use-cases/features/auto-resolve-merged-branches.use-case.js';
+import { CreateApplicationUseCase } from '../../application/use-cases/applications/create-application.use-case.js';
+import { ListApplicationsUseCase } from '../../application/use-cases/applications/list-applications.use-case.js';
+import { GetApplicationUseCase } from '../../application/use-cases/applications/get-application.use-case.js';
+import { DeleteApplicationUseCase } from '../../application/use-cases/applications/delete-application.use-case.js';
+import { ResumeApplicationWorkflowUseCase } from '../../application/use-cases/applications/resume-application-workflow.use-case.js';
+import { UpdateApplicationUseCase } from '../../application/use-cases/applications/update-application.use-case.js';
+// Plugin use cases
+import { AddPluginUseCase } from '../../application/use-cases/plugins/add-plugin.use-case.js';
+import { RemovePluginUseCase } from '../../application/use-cases/plugins/remove-plugin.use-case.js';
+import { ListPluginsUseCase } from '../../application/use-cases/plugins/list-plugins.use-case.js';
+import { EnablePluginUseCase } from '../../application/use-cases/plugins/enable-plugin.use-case.js';
+import { DisablePluginUseCase } from '../../application/use-cases/plugins/disable-plugin.use-case.js';
+import { ConfigurePluginUseCase } from '../../application/use-cases/plugins/configure-plugin.use-case.js';
+import { CheckPluginHealthUseCase } from '../../application/use-cases/plugins/check-plugin-health.use-case.js';
+import { GetPluginCatalogUseCase } from '../../application/use-cases/plugins/get-plugin-catalog.use-case.js';
+import { SQLitePluginRepository } from '../repositories/sqlite-plugin.repository.js';
+import { PluginHealthCheckerService } from '../services/plugin/plugin-health-checker.service.js';
+import { McpServerManagerService } from '../services/plugin/mcp-server-manager.service.js';
+// Deployment use cases
+import { StartFeatureDeploymentUseCase } from '../../application/use-cases/deployments/start-feature-deployment.use-case.js';
+import { StartRepositoryDeploymentUseCase } from '../../application/use-cases/deployments/start-repository-deployment.use-case.js';
+import { StopDeploymentUseCase } from '../../application/use-cases/deployments/stop-deployment.use-case.js';
+import { GetDeploymentStatusUseCase } from '../../application/use-cases/deployments/get-deployment-status.use-case.js';
+import { ListDeploymentsUseCase } from '../../application/use-cases/deployments/list-deployments.use-case.js';
+// Interactive session use cases
+import { StartInteractiveSessionUseCase } from '../../application/use-cases/interactive/start-interactive-session.use-case.js';
+import { SendInteractiveMessageUseCase } from '../../application/use-cases/interactive/send-interactive-message.use-case.js';
+import { StopInteractiveSessionUseCase } from '../../application/use-cases/interactive/stop-interactive-session.use-case.js';
+import { GetInteractiveChatStateUseCase } from '../../application/use-cases/interactive/get-interactive-chat-state.use-case.js';
+import { RespondToInteractionUseCase } from '../../application/use-cases/interactive/respond-to-interaction.use-case.js';
+// Session listing
+import { ClaudeCodeSessionRepository } from '../services/agents/sessions/claude-code-session.repository.js';
+import { CodexCliSessionRepository } from '../services/agents/sessions/codex-cli-session.repository.js';
+import { StubSessionRepository } from '../services/agents/sessions/stub-session.repository.js';
+import { AgentSessionRepositoryRegistry } from '../../application/services/agents/agent-session-repository.registry.js';
+import { ListAgentSessionsUseCase } from '../../application/use-cases/agents/list-agent-sessions.use-case.js';
+import { GetAgentSessionUseCase } from '../../application/use-cases/agents/get-agent-session.use-case.js';
+import { AgentType } from '../../domain/generated/output.js';
 // Database connection
 import { getSQLiteConnection } from '../persistence/sqlite/connection.js';
 import { runSQLiteMigrations } from '../persistence/sqlite/migrations.js';
-import { DeploymentService } from '../services/deployment/deployment.service.js';
+import { SQLiteInteractiveSessionRepository } from '../repositories/sqlite-interactive-session.repository.js';
+import { SQLiteInteractiveMessageRepository } from '../repositories/sqlite-interactive-message.repository.js';
+import { SQLiteWorkflowStepRepository } from '../repositories/sqlite-workflow-step.repository.js';
 import { InteractiveSessionService } from '../services/interactive/interactive-session.service.js';
 import { FeatureContextBuilder } from '../services/interactive/feature-context.builder.js';
-// Topic-grouped registration modules
-import { registerRepositories } from './modules/register-repositories.js';
-import { registerServices } from './modules/register-services.js';
-import { registerTools } from './modules/register-tools.js';
-import { registerAgents } from './modules/register-agents.js';
-import { registerCloudDeploy } from './modules/register-cloud-deploy.js';
-import { registerDeployment } from './modules/register-deployment.js';
-import { registerUseCases } from './modules/register-use-cases.js';
-import { registerInteractive } from './modules/register-interactive.js';
+import { RunWorkflowUseCase } from '../../application/use-cases/workflows/run-workflow.use-case.js';
 let _initialized = false;
 /**
  * Initialize the DI container with all dependencies.
@@ -45,42 +180,554 @@ export async function initializeContainer() {
     await runSQLiteMigrations(db);
     // Register database instance
     container.registerInstance('Database', db);
-    // ─── Topic-grouped registrations (pure, lazy) ────────────────────────────
-    registerRepositories(container);
-    registerServices(container);
-    registerTools(container);
-    registerAgents(container);
-    registerCloudDeploy(container);
-    registerDeployment(container);
-    registerUseCases(container);
-    registerInteractive(container);
-    // ─── Eager deployment service ────────────────────────────────────────────
-    // DeploymentService needs the database and calls `recoverAll()` at startup,
-    // so it's constructed here and registered as a pre-built instance rather
-    // than as a lazy singleton.
+    // Register repositories
+    container.register('ISettingsRepository', {
+        useFactory: (c) => {
+            const database = c.resolve('Database');
+            return new SQLiteSettingsRepository(database);
+        },
+    });
+    container.register('IFeatureRepository', {
+        useFactory: (c) => {
+            const database = c.resolve('Database');
+            return new SQLiteFeatureRepository(database);
+        },
+    });
+    container.register('IRepositoryRepository', {
+        useFactory: (c) => {
+            const database = c.resolve('Database');
+            return new SQLiteRepositoryRepository(database);
+        },
+    });
+    container.register('IApplicationRepository', {
+        useFactory: (c) => {
+            const database = c.resolve('Database');
+            return new SQLiteApplicationRepository(database);
+        },
+    });
+    container.register('IPluginRepository', {
+        useFactory: (c) => {
+            const database = c.resolve('Database');
+            return new SQLitePluginRepository(database);
+        },
+    });
+    // Register external dependencies as tokens
+    // On Windows, agent CLIs ship as .cmd/.ps1 scripts (e.g. cursor's `agent.cmd`).
+    // execFile without shell: true cannot resolve .cmd extensions, causing ENOENT.
+    const execFileAsync = promisify(execFile);
+    const execFn = IS_WINDOWS
+        ? (file, args, options) => execFileAsync(file, args, { ...options, shell: true, windowsHide: true })
+        : execFileAsync;
+    container.registerInstance('ExecFunction', execFn);
+    // Register services (singletons via @injectable + token)
+    container.registerSingleton('IAgentValidator', AgentValidatorService);
+    container.registerSingleton('IVersionService', VersionService);
+    // IWebServerService is registered as a lazy proxy to avoid importing `next`
+    // (~80ms) for non-web commands. The actual service is loaded on first method call.
+    container.register('IWebServerService', {
+        useFactory: () => {
+            let instance = null;
+            const getInstance = async () => {
+                if (!instance) {
+                    const { WebServerService } = await import('../services/web-server.service.js');
+                    instance = new WebServerService();
+                }
+                return instance;
+            };
+            return new Proxy({}, {
+                get: (_target, prop) => {
+                    return async (...args) => {
+                        const svc = await getInstance();
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        return svc[prop](...args);
+                    };
+                },
+            });
+        },
+    });
+    container.registerSingleton('IWorktreeService', WorktreeService);
+    container.registerSingleton('IFileSystemService', FileSystemService);
+    container.registerSingleton('IApplicationBriefStore', ApplicationBriefStore);
+    container.registerSingleton('IProjectScaffoldService', FsProjectScaffoldService);
+    container.registerSingleton('IApplicationCreationPromptBuilder', ApplicationCreationPromptBuilder);
+    container.registerSingleton('IAgentAuthDetectorService', PlatformAgentAuthDetectorService);
+    container.registerSingleton('ISkillInjectorService', SkillInjectorService);
+    container.registerSingleton('IToolInstallerService', ToolInstallerServiceImpl);
+    container.registerSingleton('IGitPrService', GitPrService);
+    container.registerSingleton('IGitForkService', GitForkService);
+    container.registerSingleton('IGitHubRepositoryService', GitHubRepositoryService);
+    container.registerSingleton('IIdeLauncherService', JsonDrivenIdeLauncherService);
+    container.registerSingleton('IDaemonService', DaemonPidService);
+    container.registerSingleton('IApplicationFileSystemService', NodeApplicationFileSystemService);
+    container.registerSingleton('ITerminalSessionService', PtyTerminalSessionService);
+    container.registerSingleton(AttachmentStorageService);
+    container.register('AttachmentStorageService', { useToken: AttachmentStorageService });
     const deploymentService = new DeploymentService();
     deploymentService.setDatabase(db);
     deploymentService.recoverAll();
     container.registerInstance('IDeploymentService', deploymentService);
-    // ─── Boot-time workflow-step recovery ────────────────────────────────────
-    // Any step left in `running` by a previous daemon is orphaned. Flip it to
-    // `interrupted` BEFORE any session can resolve so the UI never shows
-    // phantom "in-progress" state from a dead process.
+    container.registerSingleton('IShepInstanceService', ShepInstanceService);
+    // Register plugin services
+    container.registerSingleton('IPluginHealthChecker', PluginHealthCheckerService);
+    // SpawnFunction token for McpServerManagerService (uses child_process.spawn)
+    container.register('SpawnFunction', { useValue: spawn });
+    container.registerSingleton('IMcpServerManager', McpServerManagerService);
+    // Register agent infrastructure
+    container.register('IAgentRunRepository', {
+        useFactory: (c) => {
+            const database = c.resolve('Database');
+            return new SQLiteAgentRunRepository(database);
+        },
+    });
+    container.register('IPhaseTimingRepository', {
+        useFactory: (c) => {
+            const database = c.resolve('Database');
+            return new SQLitePhaseTimingRepository(database);
+        },
+    });
+    if (process.env.SHEP_MOCK_EXECUTOR === '1') {
+        container.register('IAgentExecutorFactory', {
+            useFactory: () => new MockAgentExecutorFactory(),
+        });
+    }
+    else {
+        container.register('IAgentExecutorFactory', {
+            useFactory: () => {
+                // Wrap spawn with sensible defaults: stdio piped and windowsHide on Win32.
+                // Each executor controls its own `shell` option — cursor needs shell: true
+                // for .cmd scripts, but claude-code must NOT use shell (DEP0190 / prompt mangling).
+                const spawnWithPipe = (command, args, options) => {
+                    return spawn(command, args, {
+                        stdio: 'pipe',
+                        ...(process.platform === 'win32' ? { windowsHide: true } : {}),
+                        ...options,
+                    });
+                };
+                return new AgentExecutorFactory(spawnWithPipe);
+            },
+        });
+    }
+    container.register('IAgentExecutorProvider', {
+        useFactory: (c) => {
+            const factory = c.resolve('IAgentExecutorFactory');
+            const settingsRepo = c.resolve('ISettingsRepository');
+            return new AgentExecutorProvider(factory, settingsRepo);
+        },
+    });
+    container.register('IStructuredAgentCaller', {
+        useFactory: (c) => {
+            const provider = c.resolve('IAgentExecutorProvider');
+            const factory = c.resolve('IAgentExecutorFactory');
+            return new StructuredAgentCallerService(provider, factory);
+        },
+    });
+    container.register('IAgentRegistry', {
+        useFactory: () => new AgentRegistryService(),
+    });
+    container.register('IAgentRunner', {
+        useFactory: (c) => {
+            const registry = c.resolve('IAgentRegistry');
+            const executorProvider = c.resolve('IAgentExecutorProvider');
+            const runRepository = c.resolve('IAgentRunRepository');
+            // Checkpointer is lazy-loaded to avoid ~240ms startup cost from
+            // @langchain/langgraph-checkpoint-sqlite on every CLI invocation.
+            return new AgentRunnerService(registry, executorProvider, runRepository);
+        },
+    });
+    container.register('IFeatureAgentProcessService', {
+        useFactory: (c) => {
+            const runRepository = c.resolve('IAgentRunRepository');
+            return new FeatureAgentProcessService(runRepository);
+        },
+    });
+    container.register('ISpecInitializerService', {
+        useFactory: () => new SpecInitializerService(),
+    });
+    // Register notification services
+    const notificationBus = getNotificationBus();
+    container.registerInstance('NotificationEventBus', notificationBus);
+    container.register('DesktopNotifier', {
+        useFactory: () => new DesktopNotifier(),
+    });
+    container.register('INotificationService', {
+        useFactory: (c) => {
+            const bus = c.resolve('NotificationEventBus');
+            const desktopNotif = c.resolve('DesktopNotifier');
+            return new NotificationService(bus, desktopNotif);
+        },
+    });
+    // Register browser opener service
+    container.register('IBrowserOpener', {
+        useFactory: () => new BrowserOpenerService(),
+    });
+    // Register use cases (singletons for performance)
+    container.registerSingleton(InitializeSettingsUseCase);
+    container.registerSingleton(LoadSettingsUseCase);
+    container.registerSingleton(UpdateSettingsUseCase);
+    container.registerSingleton(CompleteOnboardingUseCase);
+    container.registerSingleton(CompleteWebOnboardingUseCase);
+    container.registerSingleton(ConfigureAgentUseCase);
+    container.registerSingleton(ValidateAgentAuthUseCase);
+    container.registerSingleton(RunAgentUseCase);
+    container.registerSingleton(GetAgentRunUseCase);
+    container.registerSingleton(ListAgentRunsUseCase);
+    container.registerSingleton(StopAgentRunUseCase);
+    container.registerSingleton(DeleteAgentRunUseCase);
+    container.registerSingleton(ApproveAgentRunUseCase);
+    container.registerSingleton(RejectAgentRunUseCase);
+    container.registerSingleton(ReviewFeatureUseCase);
+    container.registerSingleton(MetadataGenerator);
+    container.registerSingleton(SlugResolver);
+    container.registerSingleton(CreateFeatureUseCase);
+    container.registerSingleton(ListFeaturesUseCase);
+    container.registerSingleton(ShowFeatureUseCase);
+    container.registerSingleton(DeleteFeatureUseCase);
+    container.registerSingleton(ResumeFeatureUseCase);
+    container.registerSingleton(StartFeatureUseCase);
+    container.registerSingleton(UpdateFeaturePinnedConfigUseCase);
+    container.registerSingleton(AdoptBranchUseCase);
+    container.registerSingleton(GetFeatureArtifactUseCase);
+    container.registerSingleton(GetResearchArtifactUseCase);
+    container.registerSingleton(GetPlanArtifactUseCase);
+    container.registerSingleton(ValidateToolAvailabilityUseCase);
+    container.registerSingleton(InstallToolUseCase);
+    container.registerSingleton(ListToolsUseCase);
+    container.registerSingleton(LaunchToolUseCase);
+    container.registerSingleton(LaunchIdeUseCase);
+    container.registerSingleton(CreateTerminalSessionUseCase);
+    container.registerSingleton(ListApplicationFilesUseCase);
+    container.registerSingleton(ReadApplicationFileUseCase);
+    container.registerSingleton(ReadApplicationFileRawUseCase);
+    container.registerSingleton(WriteApplicationFileUseCase);
+    container.registerSingleton(WatchApplicationFilesUseCase);
+    container.registerSingleton(AddRepositoryUseCase);
+    container.registerSingleton(CreateProjectUseCase);
+    container.registerSingleton(CheckAgentAuthUseCase);
+    container.registerSingleton(ListRepositoriesUseCase);
+    container.registerSingleton(DeleteRepositoryUseCase);
+    container.registerSingleton(ImportGitHubRepositoryUseCase);
+    container.registerSingleton(InitRemoteRepositoryUseCase);
+    container.registerSingleton(CreateFeatureFromRemoteUseCase);
+    container.registerSingleton(ListGitHubRepositoriesUseCase);
+    container.registerSingleton(ListGitHubOrganizationsUseCase);
+    // CheckAndUnblockFeaturesUseCase must be registered before UpdateFeatureLifecycleUseCase
+    // because the latter injects the former via class token.
+    container.registerSingleton(CheckAndUnblockFeaturesUseCase);
+    container.registerSingleton(UpdateFeatureLifecycleUseCase);
+    container.registerSingleton(CleanupFeatureWorktreeUseCase);
+    container.registerSingleton(ArchiveFeatureUseCase);
+    container.registerSingleton(UnarchiveFeatureUseCase);
+    container.registerSingleton(UpgradeCliUseCase);
+    container.registerSingleton(ConflictResolutionService);
+    container.register('ConflictResolutionService', {
+        useFactory: (c) => c.resolve(ConflictResolutionService),
+    });
+    container.registerSingleton(SyncRepositoryMainUseCase);
+    container.registerSingleton(RebaseFeatureOnMainUseCase);
+    container.registerSingleton(GetBranchSyncStatusUseCase);
+    container.registerSingleton(AutoResolveMergedBranchesUseCase);
+    container.registerSingleton(CreateApplicationUseCase);
+    container.registerSingleton(ListApplicationsUseCase);
+    container.registerSingleton(GetApplicationUseCase);
+    container.registerSingleton(DeleteApplicationUseCase);
+    container.registerSingleton(ResumeApplicationWorkflowUseCase);
+    container.registerSingleton(UpdateApplicationUseCase);
+    // Plugin use cases
+    container.registerSingleton(AddPluginUseCase);
+    container.registerSingleton(RemovePluginUseCase);
+    container.registerSingleton(ListPluginsUseCase);
+    container.registerSingleton(EnablePluginUseCase);
+    container.registerSingleton(DisablePluginUseCase);
+    container.registerSingleton(ConfigurePluginUseCase);
+    container.registerSingleton(CheckPluginHealthUseCase);
+    container.registerSingleton(GetPluginCatalogUseCase);
+    // Deployment use cases
+    container.registerSingleton(StartFeatureDeploymentUseCase);
+    container.registerSingleton(StartRepositoryDeploymentUseCase);
+    container.registerSingleton(StopDeploymentUseCase);
+    container.registerSingleton(GetDeploymentStatusUseCase);
+    container.registerSingleton(ListDeploymentsUseCase);
+    // Session repositories (per-AgentType string tokens)
+    container.register(`IAgentSessionRepository:${AgentType.ClaudeCode}`, {
+        useFactory: () => new ClaudeCodeSessionRepository(),
+    });
+    container.register(`IAgentSessionRepository:${AgentType.Cursor}`, {
+        useFactory: () => new StubSessionRepository(AgentType.Cursor),
+    });
+    container.register(`IAgentSessionRepository:${AgentType.GeminiCli}`, {
+        useFactory: () => new StubSessionRepository(AgentType.GeminiCli),
+    });
+    container.register(`IAgentSessionRepository:${AgentType.CodexCli}`, {
+        useFactory: () => new CodexCliSessionRepository(),
+    });
+    container.register(`IAgentSessionRepository:${AgentType.CopilotCli}`, {
+        useFactory: () => new StubSessionRepository(AgentType.CopilotCli),
+    });
+    container.registerSingleton(AgentSessionRepositoryRegistry);
+    container.registerSingleton(ListAgentSessionsUseCase);
+    container.registerSingleton(GetAgentSessionUseCase);
+    // String-token aliases for web routes (Turbopack can't resolve .js→.ts
+    // imports inside @shepai/core, so routes use string tokens instead of class refs)
+    container.register('CreateFeatureUseCase', {
+        useFactory: (c) => c.resolve(CreateFeatureUseCase),
+    });
+    container.register('ListFeaturesUseCase', {
+        useFactory: (c) => c.resolve(ListFeaturesUseCase),
+    });
+    container.register('ShowFeatureUseCase', {
+        useFactory: (c) => c.resolve(ShowFeatureUseCase),
+    });
+    container.register('DeleteFeatureUseCase', {
+        useFactory: (c) => c.resolve(DeleteFeatureUseCase),
+    });
+    container.register('ResumeFeatureUseCase', {
+        useFactory: (c) => c.resolve(ResumeFeatureUseCase),
+    });
+    container.register('StartFeatureUseCase', {
+        useFactory: (c) => c.resolve(StartFeatureUseCase),
+    });
+    container.register('UpdateFeaturePinnedConfigUseCase', {
+        useFactory: (c) => c.resolve(UpdateFeaturePinnedConfigUseCase),
+    });
+    container.register('AdoptBranchUseCase', {
+        useFactory: (c) => c.resolve(AdoptBranchUseCase),
+    });
+    container.register('StopAgentRunUseCase', {
+        useFactory: (c) => c.resolve(StopAgentRunUseCase),
+    });
+    container.register('ApproveAgentRunUseCase', {
+        useFactory: (c) => c.resolve(ApproveAgentRunUseCase),
+    });
+    container.register('RejectAgentRunUseCase', {
+        useFactory: (c) => c.resolve(RejectAgentRunUseCase),
+    });
+    container.register('GetFeatureArtifactUseCase', {
+        useFactory: (c) => c.resolve(GetFeatureArtifactUseCase),
+    });
+    container.register('GetResearchArtifactUseCase', {
+        useFactory: (c) => c.resolve(GetResearchArtifactUseCase),
+    });
+    container.register('GetPlanArtifactUseCase', {
+        useFactory: (c) => c.resolve(GetPlanArtifactUseCase),
+    });
+    container.register('InstallToolUseCase', {
+        useFactory: (c) => c.resolve(InstallToolUseCase),
+    });
+    container.register('ListToolsUseCase', {
+        useFactory: (c) => c.resolve(ListToolsUseCase),
+    });
+    container.register('LaunchToolUseCase', {
+        useFactory: (c) => c.resolve(LaunchToolUseCase),
+    });
+    container.register('LaunchIdeUseCase', {
+        useFactory: (c) => c.resolve(LaunchIdeUseCase),
+    });
+    container.register('AddRepositoryUseCase', {
+        useFactory: (c) => c.resolve(AddRepositoryUseCase),
+    });
+    container.register('CreateProjectUseCase', {
+        useFactory: (c) => c.resolve(CreateProjectUseCase),
+    });
+    container.register('CheckAgentAuthUseCase', {
+        useFactory: (c) => c.resolve(CheckAgentAuthUseCase),
+    });
+    container.register('ListRepositoriesUseCase', {
+        useFactory: (c) => c.resolve(ListRepositoriesUseCase),
+    });
+    container.register('DeleteRepositoryUseCase', {
+        useFactory: (c) => c.resolve(DeleteRepositoryUseCase),
+    });
+    container.register('ImportGitHubRepositoryUseCase', {
+        useFactory: (c) => c.resolve(ImportGitHubRepositoryUseCase),
+    });
+    container.register('InitRemoteRepositoryUseCase', {
+        useFactory: (c) => c.resolve(InitRemoteRepositoryUseCase),
+    });
+    container.register('CreateFeatureFromRemoteUseCase', {
+        useFactory: (c) => c.resolve(CreateFeatureFromRemoteUseCase),
+    });
+    container.register('ListGitHubRepositoriesUseCase', {
+        useFactory: (c) => c.resolve(ListGitHubRepositoriesUseCase),
+    });
+    container.register('ListGitHubOrganizationsUseCase', {
+        useFactory: (c) => c.resolve(ListGitHubOrganizationsUseCase),
+    });
+    container.register('CheckAndUnblockFeaturesUseCase', {
+        useFactory: (c) => c.resolve(CheckAndUnblockFeaturesUseCase),
+    });
+    container.register('UpdateFeatureLifecycleUseCase', {
+        useFactory: (c) => c.resolve(UpdateFeatureLifecycleUseCase),
+    });
+    container.register('LoadSettingsUseCase', {
+        useFactory: (c) => c.resolve(LoadSettingsUseCase),
+    });
+    container.register('UpdateSettingsUseCase', {
+        useFactory: (c) => c.resolve(UpdateSettingsUseCase),
+    });
+    container.register('CompleteWebOnboardingUseCase', {
+        useFactory: (c) => c.resolve(CompleteWebOnboardingUseCase),
+    });
+    container.register('CleanupFeatureWorktreeUseCase', {
+        useFactory: (c) => c.resolve(CleanupFeatureWorktreeUseCase),
+    });
+    container.register('ArchiveFeatureUseCase', {
+        useFactory: (c) => c.resolve(ArchiveFeatureUseCase),
+    });
+    container.register('UnarchiveFeatureUseCase', {
+        useFactory: (c) => c.resolve(UnarchiveFeatureUseCase),
+    });
+    container.register('StartFeatureDeploymentUseCase', {
+        useFactory: (c) => c.resolve(StartFeatureDeploymentUseCase),
+    });
+    container.register('StartRepositoryDeploymentUseCase', {
+        useFactory: (c) => c.resolve(StartRepositoryDeploymentUseCase),
+    });
+    container.register('StopDeploymentUseCase', {
+        useFactory: (c) => c.resolve(StopDeploymentUseCase),
+    });
+    container.register('GetDeploymentStatusUseCase', {
+        useFactory: (c) => c.resolve(GetDeploymentStatusUseCase),
+    });
+    container.register('ListDeploymentsUseCase', {
+        useFactory: (c) => c.resolve(ListDeploymentsUseCase),
+    });
+    container.register('UpgradeCliUseCase', {
+        useFactory: (c) => c.resolve(UpgradeCliUseCase),
+    });
+    container.register('SyncRepositoryMainUseCase', {
+        useFactory: (c) => c.resolve(SyncRepositoryMainUseCase),
+    });
+    container.register('RebaseFeatureOnMainUseCase', {
+        useFactory: (c) => c.resolve(RebaseFeatureOnMainUseCase),
+    });
+    container.register('GetBranchSyncStatusUseCase', {
+        useFactory: (c) => c.resolve(GetBranchSyncStatusUseCase),
+    });
+    container.register('AutoResolveMergedBranchesUseCase', {
+        useFactory: (c) => c.resolve(AutoResolveMergedBranchesUseCase),
+    });
+    container.register('CreateApplicationUseCase', {
+        useFactory: (c) => c.resolve(CreateApplicationUseCase),
+    });
+    container.register('ListApplicationsUseCase', {
+        useFactory: (c) => c.resolve(ListApplicationsUseCase),
+    });
+    container.register('GetApplicationUseCase', {
+        useFactory: (c) => c.resolve(GetApplicationUseCase),
+    });
+    container.register('DeleteApplicationUseCase', {
+        useFactory: (c) => c.resolve(DeleteApplicationUseCase),
+    });
+    container.register('ResumeApplicationWorkflowUseCase', {
+        useFactory: (c) => c.resolve(ResumeApplicationWorkflowUseCase),
+    });
+    container.register('UpdateApplicationUseCase', {
+        useFactory: (c) => c.resolve(UpdateApplicationUseCase),
+    });
+    container.register('ListApplicationFilesUseCase', {
+        useFactory: (c) => c.resolve(ListApplicationFilesUseCase),
+    });
+    container.register('ReadApplicationFileUseCase', {
+        useFactory: (c) => c.resolve(ReadApplicationFileUseCase),
+    });
+    container.register('ReadApplicationFileRawUseCase', {
+        useFactory: (c) => c.resolve(ReadApplicationFileRawUseCase),
+    });
+    container.register('WriteApplicationFileUseCase', {
+        useFactory: (c) => c.resolve(WriteApplicationFileUseCase),
+    });
+    container.register('WatchApplicationFilesUseCase', {
+        useFactory: (c) => c.resolve(WatchApplicationFilesUseCase),
+    });
+    container.register('CreateTerminalSessionUseCase', {
+        useFactory: (c) => c.resolve(CreateTerminalSessionUseCase),
+    });
+    // Plugin use case string-token aliases for web routes
+    container.register('AddPluginUseCase', {
+        useFactory: (c) => c.resolve(AddPluginUseCase),
+    });
+    container.register('RemovePluginUseCase', {
+        useFactory: (c) => c.resolve(RemovePluginUseCase),
+    });
+    container.register('ListPluginsUseCase', {
+        useFactory: (c) => c.resolve(ListPluginsUseCase),
+    });
+    container.register('EnablePluginUseCase', {
+        useFactory: (c) => c.resolve(EnablePluginUseCase),
+    });
+    container.register('DisablePluginUseCase', {
+        useFactory: (c) => c.resolve(DisablePluginUseCase),
+    });
+    container.register('ConfigurePluginUseCase', {
+        useFactory: (c) => c.resolve(ConfigurePluginUseCase),
+    });
+    container.register('CheckPluginHealthUseCase', {
+        useFactory: (c) => c.resolve(CheckPluginHealthUseCase),
+    });
+    container.register('GetPluginCatalogUseCase', {
+        useFactory: (c) => c.resolve(GetPluginCatalogUseCase),
+    });
+    // Register interactive session infrastructure
+    container.register('IInteractiveSessionRepository', {
+        useFactory: (c) => {
+            const database = c.resolve('Database');
+            return new SQLiteInteractiveSessionRepository(database);
+        },
+    });
+    container.register('IInteractiveMessageRepository', {
+        useFactory: (c) => {
+            const database = c.resolve('Database');
+            return new SQLiteInteractiveMessageRepository(database);
+        },
+    });
+    container.register('IWorkflowStepRepository', {
+        useFactory: (c) => {
+            const database = c.resolve('Database');
+            return new SQLiteWorkflowStepRepository(database);
+        },
+    });
+    // Boot-time recovery: any step left in `running` by a previous
+    // daemon is orphaned. Flip it to `interrupted` BEFORE any session
+    // can resolve so the UI never shows phantom "in-progress" state
+    // from a dead process.
     const workflowStepRepoBoot = container.resolve('IWorkflowStepRepository');
     const interruptedCount = await workflowStepRepoBoot.markAllRunningAsInterrupted();
     if (interruptedCount > 0) {
         // eslint-disable-next-line no-console
         console.log(`[workflow-step-recovery] marked ${interruptedCount} orphaned running step(s) as interrupted`);
     }
-    // ─── Interactive session service (eager) ─────────────────────────────────
-    // Constructed with already-resolved dependencies + the boot workflow-step
-    // repo so the recovery state is shared with the running instance.
     const interactiveSessionRepo = container.resolve('IInteractiveSessionRepository');
     const interactiveMessageRepo = container.resolve('IInteractiveMessageRepository');
     const interactiveSessionService = new InteractiveSessionService(interactiveSessionRepo, interactiveMessageRepo, container.resolve('IAgentExecutorFactory'), container.resolve('IFeatureRepository'), new FeatureContextBuilder(), workflowStepRepoBoot);
     container.registerInstance('IInteractiveSessionService', interactiveSessionService);
-    // Startup cleanup: mark any zombie sessions (booting/ready from a prior
-    // server run) as stopped.
+    // Register interactive session use cases
+    container.registerSingleton(StartInteractiveSessionUseCase);
+    container.registerSingleton(SendInteractiveMessageUseCase);
+    container.registerSingleton(StopInteractiveSessionUseCase);
+    container.registerSingleton(GetInteractiveChatStateUseCase);
+    container.registerSingleton(RespondToInteractionUseCase);
+    // String-token aliases for web routes (Turbopack can't resolve .js→.ts
+    // imports inside @shepai/core, so routes use string tokens instead of class refs)
+    container.register('StartInteractiveSessionUseCase', {
+        useFactory: (c) => c.resolve(StartInteractiveSessionUseCase),
+    });
+    container.register('SendInteractiveMessageUseCase', {
+        useFactory: (c) => c.resolve(SendInteractiveMessageUseCase),
+    });
+    container.register('StopInteractiveSessionUseCase', {
+        useFactory: (c) => c.resolve(StopInteractiveSessionUseCase),
+    });
+    container.register('GetInteractiveChatStateUseCase', {
+        useFactory: (c) => c.resolve(GetInteractiveChatStateUseCase),
+    });
+    container.register('RespondToInteractionUseCase', {
+        useFactory: (c) => c.resolve(RespondToInteractionUseCase),
+    });
+    container.registerSingleton(RunWorkflowUseCase);
+    container.register('RunWorkflowUseCase', {
+        useFactory: (c) => c.resolve(RunWorkflowUseCase),
+    });
+    // Startup cleanup: mark any zombie sessions (booting/ready from a prior server run) as stopped
     await interactiveSessionRepo.markAllActiveStopped();
     _initialized = true;
     return container;