fix: replace orchestrator-develop branch references with main

The orchestrator-develop branch no longer exists. Update all fallback clone commands and test fixtures to use main instead. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
ci: set macOS builds to continue-on-error
2026-05-31 22:06:16 -07:00 · 2026-03-09 20:09:49 +00:00 · 2026-03-05 23:34:08 +00:00 · 2026-03-05 07:52:11 +00:00 · 2026-03-05 07:07:20 +00:00 · 2026-03-05 07:00:09 +00:00
18 changed files with 1967 additions and 3229 deletions
--- a/action.yml
+++ b/action.yml
@@ -279,66 +279,120 @@ inputs:
    description:
      '[Orchestrator] Specifies the repo for the unity builder. Useful if you forked the repo for testing, features, or
      fixes.'
-  remotePowershellHost:
+  gcpProject:
+    required: false
    default: ''
+    description:
+      '[Orchestrator] [Experimental] Google Cloud project ID for Cloud Run Jobs provider. Falls back to
+      GOOGLE_CLOUD_PROJECT env var.'
+  gcpRegion:
    required: false
-    description: '[Orchestrator] Remote PowerShell host (hostname or IP) for the remote-powershell provider'
-  remotePowershellCredential:
    default: ''
+    description:
+      '[Orchestrator] [Experimental] Google Cloud region for Cloud Run Jobs (e.g. us-central1). Defaults to the region
+      input if empty.'
+  gcpStorageType:
    required: false
-    description: '[Orchestrator] Remote PowerShell credential (username:password or certificate path)'
-  remotePowershellTransport:
-    default: 'wsman'
+    default: 'gcs-fuse'
+    description:
+      '[Orchestrator] [Experimental] Storage type for Cloud Run Jobs. Options: gcs-fuse (mount GCS bucket as filesystem,
+      unlimited size, best for large sequential I/O), gcs-copy (copy artifacts in/out via gsutil, simpler, no FUSE
+      overhead), nfs (Filestore NFS mount, true POSIX, good random I/O, up to 100 TiB), in-memory (tmpfs, fastest but
+      volatile, up to 32 GiB).'
+  gcpBucket:
    required: false
-    description: '[Orchestrator] Remote PowerShell transport protocol (wsman or ssh)'
-  githubActionsRepo:
    default: ''
+    description:
+      '[Orchestrator] [Experimental] GCS bucket name for build artifact storage. Used by gcs-fuse and gcs-copy storage
+      types.'
+  gcpFilestoreIp:
    required: false
-    description: '[Orchestrator] Target repository (owner/repo) for the github-actions provider'
-  githubActionsWorkflow:
    default: ''
+    description:
+      '[Orchestrator] [Experimental] Filestore instance IP address for NFS storage type. Required when gcpStorageType is
+      nfs.'
+  gcpFilestoreShare:
+    required: false
+    default: '/share1'
+    description:
+      '[Orchestrator] [Experimental] Filestore share name for NFS storage type. Defaults to /share1 (the Filestore
+      default).'
+  gcpMachineType:
+    required: false
+    default: 'e2-standard-4'
+    description: '[Orchestrator] [Experimental] Machine type for Cloud Run Jobs (e.g. e2-standard-4, e2-highmem-8).'
+  gcpDiskSizeGb:
+    required: false
+    default: '100'
+    description:
+      '[Orchestrator] [Experimental] Disk size in GB for Cloud Run Jobs in-memory volumes. Only applies to in-memory
+      storage type (max 32).'
+  gcpServiceAccount:
    required: false
-    description: '[Orchestrator] Workflow filename or ID to dispatch for the github-actions provider'
-  githubActionsToken:
    default: ''
+    description: '[Orchestrator] [Experimental] Google Cloud service account email for Cloud Run Jobs execution.'
+  gcpVpcConnector:
    required: false
-    description: '[Orchestrator] PAT with actions:write scope for the github-actions provider'
-  githubActionsRef:
-    default: 'main'
-    required: false
-    description: '[Orchestrator] Branch/ref to run the workflow on for the github-actions provider'
-  gitlabProjectId:
    default: ''
+    description: '[Orchestrator] [Experimental] VPC connector name for Cloud Run Jobs private networking.'
+  azureResourceGroup:
    required: false
-    description: '[Orchestrator] GitLab project ID or URL-encoded path for the gitlab-ci provider'
-  gitlabTriggerToken:
    default: ''
+    description:
+      '[Orchestrator] [Experimental] Azure resource group for Container Instances provider. Falls back to
+      AZURE_RESOURCE_GROUP env var.'
+  azureLocation:
    required: false
-    description: '[Orchestrator] Pipeline trigger token for the gitlab-ci provider'
-  gitlabApiUrl:
-    default: 'https://gitlab.com'
-    required: false
-    description: '[Orchestrator] GitLab API URL (for self-hosted instances) for the gitlab-ci provider'
-  gitlabRef:
-    default: 'main'
-    required: false
-    description: '[Orchestrator] Branch/ref to trigger the pipeline on for the gitlab-ci provider'
-  ansibleInventory:
    default: ''
+    description:
+      '[Orchestrator] [Experimental] Azure region for Container Instances (e.g. eastus, westeurope). Defaults to the
+      region input if empty.'
+  azureStorageType:
+    required: false
+    default: 'azure-files'
+    description:
+      '[Orchestrator] [Experimental] Storage type for Azure Container Instances. Options: azure-files (SMB file share
+      mount, up to 100 TiB, premium throughput), blob-copy (copy artifacts in/out via az storage blob, no mount
+      overhead), azure-files-nfs (NFS 4.1 file share mount, true POSIX, no SMB lock overhead), in-memory (emptyDir
+      tmpfs, fastest but volatile, size limited by container memory).'
+  azureStorageAccount:
    required: false
-    description: '[Orchestrator] Path to Ansible inventory file or dynamic inventory script'
-  ansiblePlaybook:
    default: ''
+    description:
+      '[Orchestrator] [Experimental] Azure Storage Account name. Used by azure-files, azure-files-nfs, and blob-copy
+      storage types.'
+  azureFileShareName:
+    required: false
+    default: 'unity-builds'
+    description:
+      '[Orchestrator] [Experimental] Azure File Share name within the storage account. Used by azure-files and
+      azure-files-nfs storage types. Supports up to 100 TiB per share.'
+  azureBlobContainer:
+    required: false
+    default: 'unity-builds'
+    description: '[Orchestrator] [Experimental] Azure Blob container name for blob-copy storage type.'
+  azureSubscriptionId:
    required: false
-    description: '[Orchestrator] Path to Ansible playbook for Unity builds'
-  ansibleExtraVars:
    default: ''
+    description: '[Orchestrator] [Experimental] Azure subscription ID. Falls back to AZURE_SUBSCRIPTION_ID env var.'
+  azureCpu:
+    required: false
+    default: '4'
+    description: '[Orchestrator] [Experimental] CPU cores for Azure Container Instances (1-16).'
+  azureMemoryGb:
+    required: false
+    default: '16'
+    description: '[Orchestrator] [Experimental] Memory in GB for Azure Container Instances (1-16).'
+  azureDiskSizeGb:
+    required: false
+    default: '100'
+    description:
+      '[Orchestrator] [Experimental] File share quota in GB for Azure Container Instances. Premium shares support up to
+      102400 GB (100 TiB).'
+  azureSubnetId:
    required: false
-    description: '[Orchestrator] Additional Ansible variables as JSON'
-  ansibleVaultPassword:
    default: ''
-    required: false
-    description: '[Orchestrator] Path to Ansible vault password file'
+    description: '[Orchestrator] [Experimental] Azure subnet resource ID for VNet-integrated Container Instances.'

 outputs:
  volume:
--- a/dist/index.js
+++ b/dist/index.js
--- a/dist/index.js.map
+++ b/dist/index.js.map
--- a/src/model/build-parameters.ts
+++ b/src/model/build-parameters.ts
@@ -107,28 +107,30 @@ class BuildParameters {
  public unityHubVersionOnMac!: string;
  public dockerWorkspacePath!: string;

-  // Remote PowerShell provider
-  public remotePowershellHost!: string;
-  public remotePowershellCredential!: string;
-  public remotePowershellTransport!: string;
+  // GCP Cloud Run (Experimental)
+  public gcpProject!: string;
+  public gcpRegion!: string;
+  public gcpStorageType!: string;
+  public gcpBucket!: string;
+  public gcpFilestoreIp!: string;
+  public gcpFilestoreShare!: string;
+  public gcpMachineType!: string;
+  public gcpDiskSizeGb!: string;
+  public gcpServiceAccount!: string;
+  public gcpVpcConnector!: string;

-  // GitHub Actions provider
-  public githubActionsRepo!: string;
-  public githubActionsWorkflow!: string;
-  public githubActionsToken!: string;
-  public githubActionsRef!: string;
-
-  // GitLab CI provider
-  public gitlabProjectId!: string;
-  public gitlabTriggerToken!: string;
-  public gitlabApiUrl!: string;
-  public gitlabRef!: string;
-
-  // Ansible provider
-  public ansibleInventory!: string;
-  public ansiblePlaybook!: string;
-  public ansibleExtraVars!: string;
-  public ansibleVaultPassword!: string;
+  // Azure Container Instances (Experimental)
+  public azureResourceGroup!: string;
+  public azureLocation!: string;
+  public azureStorageType!: string;
+  public azureStorageAccount!: string;
+  public azureBlobContainer!: string;
+  public azureFileShareName!: string;
+  public azureSubscriptionId!: string;
+  public azureCpu!: string;
+  public azureMemoryGb!: string;
+  public azureDiskSizeGb!: string;
+  public azureSubnetId!: string;

  public static shouldUseRetainedWorkspaceMode(buildParameters: BuildParameters) {
    return buildParameters.maxRetainedWorkspaces > 0 && Orchestrator.lockedWorkspace !== ``;
@@ -251,6 +253,27 @@ class BuildParameters {
      inputPullCommand: OrchestratorOptions.inputPullCommand,
      pullInputList: OrchestratorOptions.pullInputList,
      kubeStorageClass: OrchestratorOptions.kubeStorageClass,
+      gcpProject: Input.gcpProject,
+      gcpRegion: Input.gcpRegion,
+      gcpStorageType: Input.gcpStorageType,
+      gcpBucket: Input.gcpBucket,
+      gcpFilestoreIp: Input.gcpFilestoreIp,
+      gcpFilestoreShare: Input.gcpFilestoreShare,
+      gcpMachineType: Input.gcpMachineType,
+      gcpDiskSizeGb: Input.gcpDiskSizeGb,
+      gcpServiceAccount: Input.gcpServiceAccount,
+      gcpVpcConnector: Input.gcpVpcConnector,
+      azureResourceGroup: Input.azureResourceGroup,
+      azureLocation: Input.azureLocation,
+      azureStorageType: Input.azureStorageType,
+      azureStorageAccount: Input.azureStorageAccount,
+      azureBlobContainer: Input.azureBlobContainer,
+      azureFileShareName: Input.azureFileShareName,
+      azureSubscriptionId: Input.azureSubscriptionId,
+      azureCpu: Input.azureCpu,
+      azureMemoryGb: Input.azureMemoryGb,
+      azureDiskSizeGb: Input.azureDiskSizeGb,
+      azureSubnetId: Input.azureSubnetId,
      cacheKey: OrchestratorOptions.cacheKey,
      maxRetainedWorkspaces: Number.parseInt(OrchestratorOptions.maxRetainedWorkspaces),
      useLargePackages: OrchestratorOptions.useLargePackages,
@@ -265,29 +288,6 @@ class BuildParameters {
      cacheUnityInstallationOnMac: Input.cacheUnityInstallationOnMac,
      unityHubVersionOnMac: Input.unityHubVersionOnMac,
      dockerWorkspacePath: Input.dockerWorkspacePath,
-
-      // Remote PowerShell provider
-      remotePowershellHost: Input.remotePowershellHost,
-      remotePowershellCredential: Input.remotePowershellCredential,
-      remotePowershellTransport: Input.remotePowershellTransport,
-
-      // GitHub Actions provider
-      githubActionsRepo: Input.githubActionsRepo,
-      githubActionsWorkflow: Input.githubActionsWorkflow,
-      githubActionsToken: Input.githubActionsToken,
-      githubActionsRef: Input.githubActionsRef,
-
-      // GitLab CI provider
-      gitlabProjectId: Input.gitlabProjectId,
-      gitlabTriggerToken: Input.gitlabTriggerToken,
-      gitlabApiUrl: Input.gitlabApiUrl,
-      gitlabRef: Input.gitlabRef,
-
-      // Ansible provider
-      ansibleInventory: Input.ansibleInventory,
-      ansiblePlaybook: Input.ansiblePlaybook,
-      ansibleExtraVars: Input.ansibleExtraVars,
-      ansibleVaultPassword: Input.ansibleVaultPassword,
    };
  }

--- a/src/model/input.ts
+++ b/src/model/input.ts
@@ -282,80 +282,90 @@ class Input {
    return Input.getInput('skipActivation')?.toLowerCase() ?? 'false';
  }

-  // ### ### ###
-  // Remote PowerShell provider
-  // ### ### ###
-
-  static get remotePowershellHost(): string {
-    return Input.getInput('remotePowershellHost') ?? '';
+  // GCP Cloud Run (Experimental)
+  static get gcpProject(): string {
+    return Input.getInput('gcpProject') ?? '';
  }

-  static get remotePowershellCredential(): string {
-    return Input.getInput('remotePowershellCredential') ?? '';
+  static get gcpRegion(): string {
+    return Input.getInput('gcpRegion') ?? '';
  }

-  static get remotePowershellTransport(): string {
-    return Input.getInput('remotePowershellTransport') ?? 'wsman';
+  static get gcpStorageType(): string {
+    return Input.getInput('gcpStorageType') ?? 'gcs-fuse';
  }

-  // ### ### ###
-  // GitHub Actions provider
-  // ### ### ###
-
-  static get githubActionsRepo(): string {
-    return Input.getInput('githubActionsRepo') ?? '';
+  static get gcpBucket(): string {
+    return Input.getInput('gcpBucket') ?? '';
  }

-  static get githubActionsWorkflow(): string {
-    return Input.getInput('githubActionsWorkflow') ?? '';
+  static get gcpFilestoreIp(): string {
+    return Input.getInput('gcpFilestoreIp') ?? '';
  }

-  static get githubActionsToken(): string {
-    return Input.getInput('githubActionsToken') ?? '';
+  static get gcpFilestoreShare(): string {
+    return Input.getInput('gcpFilestoreShare') ?? '/share1';
  }

-  static get githubActionsRef(): string {
-    return Input.getInput('githubActionsRef') ?? 'main';
+  static get gcpMachineType(): string {
+    return Input.getInput('gcpMachineType') ?? 'e2-standard-4';
  }

-  // ### ### ###
-  // GitLab CI provider
-  // ### ### ###
-
-  static get gitlabProjectId(): string {
-    return Input.getInput('gitlabProjectId') ?? '';
+  static get gcpDiskSizeGb(): string {
+    return Input.getInput('gcpDiskSizeGb') ?? '100';
  }

-  static get gitlabTriggerToken(): string {
-    return Input.getInput('gitlabTriggerToken') ?? '';
+  static get gcpServiceAccount(): string {
+    return Input.getInput('gcpServiceAccount') ?? '';
  }

-  static get gitlabApiUrl(): string {
-    return Input.getInput('gitlabApiUrl') ?? 'https://gitlab.com';
+  static get gcpVpcConnector(): string {
+    return Input.getInput('gcpVpcConnector') ?? '';
  }

-  static get gitlabRef(): string {
-    return Input.getInput('gitlabRef') ?? 'main';
+  // Azure Container Instances (Experimental)
+  static get azureResourceGroup(): string {
+    return Input.getInput('azureResourceGroup') ?? '';
  }

-  // ### ### ###
-  // Ansible provider
-  // ### ### ###
-
-  static get ansibleInventory(): string {
-    return Input.getInput('ansibleInventory') ?? '';
+  static get azureLocation(): string {
+    return Input.getInput('azureLocation') ?? '';
  }

-  static get ansiblePlaybook(): string {
-    return Input.getInput('ansiblePlaybook') ?? '';
+  static get azureStorageType(): string {
+    return Input.getInput('azureStorageType') ?? 'azure-files';
  }

-  static get ansibleExtraVars(): string {
-    return Input.getInput('ansibleExtraVars') ?? '';
+  static get azureStorageAccount(): string {
+    return Input.getInput('azureStorageAccount') ?? '';
  }

-  static get ansibleVaultPassword(): string {
-    return Input.getInput('ansibleVaultPassword') ?? '';
+  static get azureBlobContainer(): string {
+    return Input.getInput('azureBlobContainer') ?? 'unity-builds';
+  }
+
+  static get azureFileShareName(): string {
+    return Input.getInput('azureFileShareName') ?? 'unity-builds';
+  }
+
+  static get azureSubscriptionId(): string {
+    return Input.getInput('azureSubscriptionId') ?? '';
+  }
+
+  static get azureCpu(): string {
+    return Input.getInput('azureCpu') ?? '4';
+  }
+
+  static get azureMemoryGb(): string {
+    return Input.getInput('azureMemoryGb') ?? '16';
+  }
+
+  static get azureDiskSizeGb(): string {
+    return Input.getInput('azureDiskSizeGb') ?? '100';
+  }
+
+  static get azureSubnetId(): string {
+    return Input.getInput('azureSubnetId') ?? '';
  }

  public static ToEnvVarFormat(input: string) {
--- a/src/model/orchestrator/orchestrator.ts
+++ b/src/model/orchestrator/orchestrator.ts
@@ -13,10 +13,8 @@ import OrchestratorEnvironmentVariable from './options/orchestrator-environment-
 import TestOrchestrator from './providers/test';
 import LocalOrchestrator from './providers/local';
 import LocalDockerOrchestrator from './providers/docker';
-import RemotePowershellProvider from './providers/remote-powershell';
-import GitHubActionsProvider from './providers/github-actions';
-import GitLabCIProvider from './providers/gitlab-ci';
-import AnsibleProvider from './providers/ansible';
+import GcpCloudRunProvider from './providers/gcp-cloud-run';
+import AzureAciProvider from './providers/azure-aci';
 import loadProvider from './providers/provider-loader';
 import GitHub from '../github';
 import SharedWorkspaceLocking from './services/core/shared-workspace-locking';
@@ -162,17 +160,13 @@ class Orchestrator {
      case 'local':
        Orchestrator.Provider = new LocalOrchestrator();
        break;
-      case 'remote-powershell':
-        Orchestrator.Provider = new RemotePowershellProvider(Orchestrator.buildParameters);
+      case 'gcp-cloud-run':
+        OrchestratorLogger.log('⚠ EXPERIMENTAL: GCP Cloud Run Jobs provider');
+        Orchestrator.Provider = new GcpCloudRunProvider(Orchestrator.buildParameters);
        break;
-      case 'github-actions':
-        Orchestrator.Provider = new GitHubActionsProvider(Orchestrator.buildParameters);
-        break;
-      case 'gitlab-ci':
-        Orchestrator.Provider = new GitLabCIProvider(Orchestrator.buildParameters);
-        break;
-      case 'ansible':
-        Orchestrator.Provider = new AnsibleProvider(Orchestrator.buildParameters);
+      case 'azure-aci':
+        OrchestratorLogger.log('⚠ EXPERIMENTAL: Azure Container Instances provider');
+        Orchestrator.Provider = new AzureAciProvider(Orchestrator.buildParameters);
        break;
      default:
        // Try to load provider using the dynamic loader for unknown providers
--- a/src/model/orchestrator/providers/ansible/ansible-provider.test.ts
+++ b/src/model/orchestrator/providers/ansible/ansible-provider.test.ts
@@ -1,291 +0,0 @@
-import AnsibleProvider from '.';
-import BuildParameters from '../../../build-parameters';
-import { OrchestratorSystem } from '../../services/core/orchestrator-system';
-import OrchestratorLogger from '../../services/core/orchestrator-logger';
-import * as core from '@actions/core';
-
-jest.mock('../../services/core/orchestrator-system');
-jest.mock('../../services/core/orchestrator-logger');
-jest.mock('@actions/core', () => ({
-  info: jest.fn(),
-  warning: jest.fn(),
-  error: jest.fn(),
-  setOutput: jest.fn(),
-  getInput: jest.fn(() => ''),
-}));
-
-const mockRun = OrchestratorSystem.Run as jest.MockedFunction<typeof OrchestratorSystem.Run>;
-const mockLog = OrchestratorLogger.log as jest.MockedFunction<typeof OrchestratorLogger.log>;
-const mockLogWarning = OrchestratorLogger.logWarning as jest.MockedFunction<typeof OrchestratorLogger.logWarning>;
-
-function createBuildParameters(overrides: Partial<BuildParameters> = {}): BuildParameters {
-  return {
-    ansibleInventory: '/etc/ansible/hosts',
-    ansiblePlaybook: '/playbooks/unity-build.yml',
-    ansibleExtraVars: '',
-    ansibleVaultPassword: '',
-    ...overrides,
-  } as BuildParameters;
-}
-
-describe('AnsibleProvider', () => {
-  let provider: AnsibleProvider;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    provider = new AnsibleProvider(createBuildParameters());
-  });
-
-  describe('constructor', () => {
-    it('initializes with all provided parameters', () => {
-      const params = createBuildParameters({
-        ansibleInventory: '/custom/inventory',
-        ansiblePlaybook: '/custom/playbook.yml',
-        ansibleExtraVars: '{"key":"value"}',
-        ansibleVaultPassword: '/vault/pass',
-      });
-      const p = new AnsibleProvider(params);
-      expect(p).toBeDefined();
-    });
-
-    it('handles missing optional parameters gracefully', () => {
-      const params = createBuildParameters({
-        ansiblePlaybook: undefined,
-        ansibleExtraVars: undefined,
-        ansibleVaultPassword: undefined,
-      });
-      const p = new AnsibleProvider(params);
-      expect(p).toBeDefined();
-    });
-  });
-
-  describe('setupWorkflow', () => {
-    it('verifies ansible binary, ansible-playbook binary, and inventory exist', async () => {
-      mockRun.mockResolvedValueOnce('ansible [core 2.14.0]'); // ansible --version
-      mockRun.mockResolvedValueOnce('/usr/bin/ansible-playbook'); // ansible-playbook check
-      mockRun.mockResolvedValueOnce(''); // test -e inventory
-
-      await provider.setupWorkflow('guid-123', createBuildParameters(), 'main', []);
-
-      expect(mockRun).toHaveBeenCalledTimes(3);
-      expect(mockRun.mock.calls[0][0]).toContain('ansible --version');
-      expect(mockRun.mock.calls[1][0]).toContain('ansible-playbook');
-      expect(mockRun.mock.calls[2][0]).toContain('test -e "/etc/ansible/hosts"');
-      expect(mockLog).toHaveBeenCalledWith(expect.stringContaining('ansible'));
-      expect(mockLog).toHaveBeenCalledWith(expect.stringContaining('ansible-playbook binary verified'));
-    });
-
-    it('throws when inventory is not configured', async () => {
-      const params = createBuildParameters({ ansibleInventory: '' });
-      provider = new AnsibleProvider(params);
-
-      await expect(provider.setupWorkflow('guid-123', params, 'main', [])).rejects.toThrow(
-        'ansibleInventory is required',
-      );
-    });
-
-    it('throws when ansible binary is not found on PATH', async () => {
-      mockRun.mockRejectedValueOnce(new Error('command not found: ansible'));
-
-      await expect(provider.setupWorkflow('guid-123', createBuildParameters(), 'main', [])).rejects.toThrow(
-        'Ansible not found on PATH',
-      );
-    });
-
-    it('throws when ansible-playbook binary is not found', async () => {
-      mockRun.mockResolvedValueOnce('ansible [core 2.14.0]'); // ansible version OK
-      mockRun.mockRejectedValueOnce(new Error('command not found')); // ansible-playbook missing
-
-      await expect(provider.setupWorkflow('guid-123', createBuildParameters(), 'main', [])).rejects.toThrow(
-        'ansible-playbook not found on PATH',
-      );
-
-      expect(core.error).toHaveBeenCalledWith('ansible-playbook not found. Install Ansible or ensure it is in PATH.');
-    });
-
-    it('throws when inventory file does not exist', async () => {
-      mockRun.mockResolvedValueOnce('ansible [core 2.14.0]'); // ansible version OK
-      mockRun.mockResolvedValueOnce('/usr/bin/ansible-playbook'); // ansible-playbook OK
-      mockRun.mockRejectedValueOnce(new Error('test -e failed')); // inventory missing
-
-      await expect(provider.setupWorkflow('guid-123', createBuildParameters(), 'main', [])).rejects.toThrow(
-        'Inventory not found: /etc/ansible/hosts',
-      );
-    });
-  });
-
-  describe('runTaskInWorkflow', () => {
-    it('constructs ansible-playbook command with correct variables and returns output', async () => {
-      mockRun.mockResolvedValueOnce('PLAY [build] *****\nok: [server1]\nPLAY RECAP');
-
-      const result = await provider.runTaskInWorkflow(
-        'guid-run1',
-        'unityci/editor:2021.3',
-        'echo build',
-        '/mount',
-        '/workspace',
-        [],
-        [],
-      );
-
-      expect(result).toContain('PLAY [build]');
-
-      const command = mockRun.mock.calls[0][0];
-      expect(command).toContain('ansible-playbook');
-      expect(command).toContain('-i "/etc/ansible/hosts"');
-      expect(command).toContain('"/playbooks/unity-build.yml"');
-      expect(command).toContain('--no-color');
-      expect(command).toContain('build_guid');
-      expect(command).toContain('guid-run1');
-      expect(command).toContain('build_image');
-      expect(command).toContain('unityci/editor:2021.3');
-      expect(command).toContain('build_commands');
-      expect(command).toContain('mount_dir');
-      expect(command).toContain('working_dir');
-    });
-
-    it('throws when playbook is not configured', async () => {
-      const params = createBuildParameters({ ansiblePlaybook: '' });
-      provider = new AnsibleProvider(params);
-
-      await expect(provider.runTaskInWorkflow('guid-nopb', 'img', 'cmd', '/m', '/w', [], [])).rejects.toThrow(
-        'ansiblePlaybook is required',
-      );
-    });
-
-    it('passes environment variables as extra-vars in snake_case', async () => {
-      mockRun.mockResolvedValueOnce('ok');
-
-      const env = [
-        { name: 'UNITY_LICENSE', value: 'lic-data' },
-        { name: 'BUILD_TARGET', value: 'Linux64' },
-      ];
-
-      await provider.runTaskInWorkflow('guid-env', 'img', 'cmd', '/m', '/w', env as any, []);
-
-      const command = mockRun.mock.calls[0][0];
-      // Environment variable names are lowercased as Ansible variables
-      expect(command).toContain('unity_license');
-      expect(command).toContain('lic-data');
-      expect(command).toContain('build_target');
-      expect(command).toContain('Linux64');
-    });
-
-    it('merges user-provided extra vars from JSON string', async () => {
-      const params = createBuildParameters({
-        ansibleExtraVars: JSON.stringify({ custom_var: 'custom_value', another: '42' }),
-      });
-      provider = new AnsibleProvider(params);
-      mockRun.mockResolvedValueOnce('ok');
-
-      await provider.runTaskInWorkflow('guid-extra', 'img', 'cmd', '/m', '/w', [], []);
-
-      const command = mockRun.mock.calls[0][0];
-      expect(command).toContain('custom_var');
-      expect(command).toContain('custom_value');
-      expect(command).toContain('another');
-    });
-
-    it('logs warning when extra vars JSON is invalid but continues', async () => {
-      const params = createBuildParameters({ ansibleExtraVars: 'not-valid-json{{{' });
-      provider = new AnsibleProvider(params);
-      mockRun.mockResolvedValueOnce('ok');
-
-      await provider.runTaskInWorkflow('guid-badjson', 'img', 'cmd', '/m', '/w', [], []);
-
-      expect(mockLogWarning).toHaveBeenCalledWith(expect.stringContaining('Failed to parse ansibleExtraVars'));
-    });
-
-    it('includes vault password file flag when configured', async () => {
-      const params = createBuildParameters({ ansibleVaultPassword: '/secure/vault-pass.txt' });
-      provider = new AnsibleProvider(params);
-      mockRun.mockResolvedValueOnce('ok');
-
-      await provider.runTaskInWorkflow('guid-vault', 'img', 'cmd', '/m', '/w', [], []);
-
-      const command = mockRun.mock.calls[0][0];
-      expect(command).toContain('--vault-password-file "/secure/vault-pass.txt"');
-    });
-
-    it('does not include vault password flag when not configured', async () => {
-      mockRun.mockResolvedValueOnce('ok');
-
-      await provider.runTaskInWorkflow('guid-novault', 'img', 'cmd', '/m', '/w', [], []);
-
-      const command = mockRun.mock.calls[0][0];
-      expect(command).not.toContain('--vault-password-file');
-    });
-
-    it('prefixes secrets as environment variables in the command', async () => {
-      mockRun.mockResolvedValueOnce('ok');
-
-      const secrets = [
-        { ParameterKey: 'key1', EnvironmentVariable: 'SECRET_TOKEN', ParameterValue: 'tok-abc' },
-        { ParameterKey: 'key2', EnvironmentVariable: 'DEPLOY_KEY', ParameterValue: 'dk-xyz' },
-      ];
-
-      await provider.runTaskInWorkflow('guid-secrets', 'img', 'cmd', '/m', '/w', [], secrets as any);
-
-      const command = mockRun.mock.calls[0][0];
-      expect(command).toMatch(/^SECRET_TOKEN='tok-abc'/);
-      expect(command).toContain("DEPLOY_KEY='dk-xyz'");
-      expect(command).toContain('ansible-playbook');
-    });
-
-    it('throws and logs warning when playbook execution fails', async () => {
-      const execError = new Error('UNREACHABLE! Host unreachable');
-      mockRun.mockRejectedValueOnce(execError);
-
-      await expect(provider.runTaskInWorkflow('guid-hostfail', 'img', 'cmd', '/m', '/w', [], [])).rejects.toThrow(
-        'UNREACHABLE',
-      );
-
-      expect(mockLogWarning).toHaveBeenCalledWith(expect.stringContaining('Playbook failed'));
-    });
-  });
-
-  describe('cleanupWorkflow', () => {
-    it('completes without error and logs cleanup message', async () => {
-      await provider.cleanupWorkflow(createBuildParameters(), 'main', []);
-      expect(mockLog).toHaveBeenCalledWith(expect.stringContaining('Cleanup complete'));
-    });
-  });
-
-  describe('garbageCollect', () => {
-    it('returns empty string (no-op)', async () => {
-      const result = await provider.garbageCollect('', false, 0, false, false);
-      expect(result).toBe('');
-    });
-  });
-
-  describe('listResources', () => {
-    it('returns inventory path as a resource when configured', async () => {
-      const resources = await provider.listResources();
-
-      expect(resources).toHaveLength(1);
-      expect(resources[0].Name).toBe('/etc/ansible/hosts');
-    });
-
-    it('returns empty array when inventory is not configured', async () => {
-      const params = createBuildParameters({ ansibleInventory: '' });
-      provider = new AnsibleProvider(params);
-
-      const resources = await provider.listResources();
-      expect(resources).toEqual([]);
-    });
-  });
-
-  describe('listWorkflow', () => {
-    it('returns empty array (not implemented)', async () => {
-      const workflows = await provider.listWorkflow();
-      expect(workflows).toEqual([]);
-    });
-  });
-
-  describe('watchWorkflow', () => {
-    it('returns empty string (not implemented)', async () => {
-      const result = await provider.watchWorkflow();
-      expect(result).toBe('');
-    });
-  });
-});
--- a/src/model/orchestrator/providers/ansible/index.ts
+++ b/src/model/orchestrator/providers/ansible/index.ts
@@ -1,197 +0,0 @@
-import * as core from '@actions/core';
-import BuildParameters from '../../../build-parameters';
-import { OrchestratorSystem } from '../../services/core/orchestrator-system';
-import OrchestratorEnvironmentVariable from '../../options/orchestrator-environment-variable';
-import OrchestratorLogger from '../../services/core/orchestrator-logger';
-import { ProviderInterface } from '../provider-interface';
-import OrchestratorSecret from '../../options/orchestrator-secret';
-import { ProviderResource } from '../provider-resource';
-import { ProviderWorkflow } from '../provider-workflow';
-
-/**
- * Ansible provider — executes Unity builds via Ansible playbooks
- * against managed inventory.
- *
- * Use case: Teams with existing Ansible infrastructure for server
- * management who want to leverage their inventory for build distribution.
- */
-class AnsibleProvider implements ProviderInterface {
-  private buildParameters: BuildParameters;
-  private inventory: string;
-  private playbook: string;
-  private extraVariables: string;
-  private vaultPassword: string;
-
-  constructor(buildParameters: BuildParameters) {
-    this.buildParameters = buildParameters;
-    this.inventory = buildParameters.ansibleInventory || '';
-    this.playbook = buildParameters.ansiblePlaybook || '';
-    this.extraVariables = buildParameters.ansibleExtraVars || '';
-    this.vaultPassword = buildParameters.ansibleVaultPassword || '';
-  }
-
-  async setupWorkflow(
-    // eslint-disable-next-line no-unused-vars
-    buildGuid: string,
-    // eslint-disable-next-line no-unused-vars
-    buildParameters: BuildParameters,
-    // eslint-disable-next-line no-unused-vars
-    branchName: string,
-    // eslint-disable-next-line no-unused-vars
-    defaultSecretsArray: { ParameterKey: string; EnvironmentVariable: string; ParameterValue: string }[],
-  ): Promise<void> {
-    OrchestratorLogger.log(`[Ansible] Setting up playbook execution`);
-
-    if (!this.inventory) {
-      throw new Error('ansibleInventory is required for the ansible provider');
-    }
-
-    // Verify ansible is available
-    try {
-      const version = await OrchestratorSystem.Run('ansible --version | head -1');
-      OrchestratorLogger.log(`[Ansible] ${version.trim()}`);
-    } catch (error: any) {
-      throw new Error(`Ansible not found on PATH: ${error.message || error}`);
-    }
-
-    // Verify ansible-playbook binary exists (may be separate from ansible)
-    try {
-      await OrchestratorSystem.Run('command -v ansible-playbook || which ansible-playbook || where ansible-playbook');
-      OrchestratorLogger.log(`[Ansible] ansible-playbook binary verified`);
-    } catch (error: any) {
-      core.error('ansible-playbook not found. Install Ansible or ensure it is in PATH.');
-      throw new Error(`ansible-playbook not found on PATH: ${error.message || error}`);
-    }
-
-    // Verify inventory exists
-    try {
-      await OrchestratorSystem.Run(`test -e "${this.inventory}"`);
-    } catch {
-      throw new Error(`Inventory not found: ${this.inventory}`);
-    }
-  }
-
-  async runTaskInWorkflow(
-    buildGuid: string,
-    image: string,
-    commands: string,
-    mountdir: string,
-    workingdir: string,
-    environment: OrchestratorEnvironmentVariable[],
-    secrets: OrchestratorSecret[],
-  ): Promise<string> {
-    OrchestratorLogger.log(`[Ansible] Running playbook against inventory ${this.inventory}`);
-
-    if (!this.playbook) {
-      throw new Error(
-        'ansiblePlaybook is required — no default playbook is provided yet. ' +
-          'Provide a playbook that accepts build_guid, build_image, build_commands, mount_dir, and working_dir variables.',
-      );
-    }
-
-    // Build extra-vars JSON
-    // These use snake_case because they are Ansible variable names passed to playbooks
-    const playbookVariables: Record<string, string> = {
-      // eslint-disable-next-line camelcase
-      build_guid: buildGuid,
-      // eslint-disable-next-line camelcase
-      build_image: image,
-      // eslint-disable-next-line camelcase
-      build_commands: commands,
-      // eslint-disable-next-line camelcase
-      mount_dir: mountdir,
-      // eslint-disable-next-line camelcase
-      working_dir: workingdir,
-    };
-
-    for (const element of environment) {
-      playbookVariables[element.name.toLowerCase()] = element.value;
-    }
-
-    // Merge user-provided extra vars
-    if (this.extraVariables) {
-      try {
-        const userVariables = JSON.parse(this.extraVariables);
-        Object.assign(playbookVariables, userVariables);
-      } catch {
-        OrchestratorLogger.logWarning(`[Ansible] Failed to parse ansibleExtraVars as JSON, using as-is`);
-      }
-    }
-
-    const extraVariablesJson = JSON.stringify(playbookVariables).replace(/'/g, "'\\''");
-
-    // Build ansible-playbook command
-    const commandParts = [
-      'ansible-playbook',
-      `-i "${this.inventory}"`,
-      `"${this.playbook}"`,
-      `-e '${extraVariablesJson}'`,
-      '--no-color',
-    ];
-
-    if (this.vaultPassword) {
-      commandParts.push(`--vault-password-file "${this.vaultPassword}"`);
-    }
-
-    // Add secret variables as extra environment
-    const environmentPrefix = secrets
-      .map((secret) => `${secret.EnvironmentVariable}='${secret.ParameterValue}'`)
-      .join(' ');
-
-    const fullCommand = environmentPrefix ? `${environmentPrefix} ${commandParts.join(' ')}` : commandParts.join(' ');
-
-    try {
-      const output = await OrchestratorSystem.Run(fullCommand);
-      OrchestratorLogger.log(`[Ansible] Playbook completed successfully`);
-
-      return output;
-    } catch (error: any) {
-      OrchestratorLogger.logWarning(`[Ansible] Playbook failed: ${error.message || error}`);
-      throw error;
-    }
-  }
-
-  async cleanupWorkflow(
-    // eslint-disable-next-line no-unused-vars
-    buildParameters: BuildParameters,
-    // eslint-disable-next-line no-unused-vars
-    branchName: string,
-    // eslint-disable-next-line no-unused-vars
-    defaultSecretsArray: { ParameterKey: string; EnvironmentVariable: string; ParameterValue: string }[],
-  ): Promise<void> {
-    OrchestratorLogger.log(`[Ansible] Cleanup complete`);
-  }
-
-  async garbageCollect(
-    // eslint-disable-next-line no-unused-vars
-    filter: string,
-    // eslint-disable-next-line no-unused-vars
-    previewOnly: boolean,
-    // eslint-disable-next-line no-unused-vars
-    olderThan: Number,
-    // eslint-disable-next-line no-unused-vars
-    fullCache: boolean,
-    // eslint-disable-next-line no-unused-vars
-    baseDependencies: boolean,
-  ): Promise<string> {
-    return '';
-  }
-
-  async listResources(): Promise<ProviderResource[]> {
-    if (!this.inventory) return [];
-
-    const resource = new ProviderResource();
-    resource.Name = this.inventory;
-
-    return [resource];
-  }
-
-  async listWorkflow(): Promise<ProviderWorkflow[]> {
-    return [];
-  }
-
-  async watchWorkflow(): Promise<string> {
-    return '';
-  }
-}
-export default AnsibleProvider;
--- a/src/model/orchestrator/providers/azure-aci/index.ts
+++ b/src/model/orchestrator/providers/azure-aci/index.ts
@@ -0,0 +1,536 @@
+/**
+ * Azure Container Instances (ACI) Provider (Experimental)
+ *
+ * Executes Unity builds as Azure Container Instances with configurable storage backends.
+ *
+ * Storage types:
+ *   - azure-files:     SMB file share mount via Azure Files. Up to 100 TiB per share,
+ *                       premium throughput. Default.
+ *                       Requires: azureStorageAccount, azureFileShareName
+ *   - blob-copy:       Copy artifacts in/out of Azure Blob Storage before/after the build.
+ *                       No mount overhead, simpler.
+ *                       Requires: azureStorageAccount, azureBlobContainer
+ *   - azure-files-nfs: NFS 4.1 file share mount. True POSIX semantics, no SMB lock overhead,
+ *                       better for Unity Library caching (many small random reads).
+ *                       Requires: azureStorageAccount, azureFileShareName, Premium FileStorage,
+ *                       VNet integration (azureSubnetId)
+ *   - in-memory:       emptyDir volume (tmpfs). Fastest I/O but volatile, size limited by
+ *                       container memory allocation.
+ *
+ * Prerequisites:
+ *   - Azure CLI authenticated (az login or service principal)
+ *   - A resource group for build resources
+ *   - Contributor role on the resource group
+ *
+ * @experimental This provider is experimental. APIs and behavior may change.
+ */
+
+import { ProviderInterface } from '../provider-interface';
+import BuildParameters from '../../../build-parameters';
+import OrchestratorLogger from '../../services/core/orchestrator-logger';
+import OrchestratorEnvironmentVariable from '../../options/orchestrator-environment-variable';
+import OrchestratorSecret from '../../options/orchestrator-secret';
+import { ProviderResource } from '../provider-resource';
+import { ProviderWorkflow } from '../provider-workflow';
+import { OrchestratorSystem } from '../../services/core/orchestrator-system';
+import { Input } from '../../..';
+import ResourceTracking from '../../services/core/resource-tracking';
+
+type AzureStorageType = 'azure-files' | 'blob-copy' | 'azure-files-nfs' | 'in-memory';
+
+class AzureAciProvider implements ProviderInterface {
+  private readonly resourceGroup: string;
+  private readonly location: string;
+  private readonly storageType: AzureStorageType;
+  private readonly storageAccount: string;
+  private readonly blobContainer: string;
+  private readonly fileShareName: string;
+  private readonly subscriptionId: string;
+  private readonly cpu: number;
+  private readonly memoryGb: number;
+  private readonly diskSizeGb: number;
+  private readonly subnetId: string;
+  private buildParameters: BuildParameters;
+
+  constructor(buildParameters: BuildParameters) {
+    this.buildParameters = buildParameters;
+    this.resourceGroup = buildParameters.azureResourceGroup || process.env.AZURE_RESOURCE_GROUP || '';
+    this.location = buildParameters.azureLocation || Input.region || 'eastus';
+    this.storageType = (buildParameters.azureStorageType || 'azure-files') as AzureStorageType;
+    this.storageAccount = buildParameters.azureStorageAccount || process.env.AZURE_STORAGE_ACCOUNT || '';
+    this.blobContainer = buildParameters.azureBlobContainer || 'unity-builds';
+    this.fileShareName = buildParameters.azureFileShareName || 'unity-builds';
+    this.subscriptionId = buildParameters.azureSubscriptionId || process.env.AZURE_SUBSCRIPTION_ID || '';
+    this.cpu = Number.parseInt(buildParameters.azureCpu || '4', 10);
+    this.memoryGb = Number.parseInt(buildParameters.azureMemoryGb || '16', 10);
+    this.diskSizeGb = Number.parseInt(buildParameters.azureDiskSizeGb || '100', 10);
+    this.subnetId = buildParameters.azureSubnetId || '';
+
+    OrchestratorLogger.log('[Azure ACI] Provider initialized (EXPERIMENTAL)');
+    OrchestratorLogger.log(`[Azure ACI] Resource Group: ${this.resourceGroup || '(not set)'}`);
+    OrchestratorLogger.log(`[Azure ACI] Location: ${this.location}`);
+    OrchestratorLogger.log(`[Azure ACI] Storage: ${this.storageType}`);
+    OrchestratorLogger.log(`[Azure ACI] Resources: ${this.cpu} CPU, ${this.memoryGb}GB RAM`);
+
+    this.validateStorageConfig();
+  }
+
+  private validateStorageConfig(): void {
+    switch (this.storageType) {
+      case 'azure-files':
+        if (!this.storageAccount) {
+          OrchestratorLogger.logWarning(
+            '[Azure ACI] Storage type "azure-files" requires azureStorageAccount to be set.',
+          );
+        } else {
+          OrchestratorLogger.log(`[Azure ACI] File Share: ${this.storageAccount}/${this.fileShareName} (SMB)`);
+        }
+        break;
+      case 'azure-files-nfs':
+        if (!this.storageAccount) {
+          OrchestratorLogger.logWarning(
+            '[Azure ACI] Storage type "azure-files-nfs" requires azureStorageAccount (Premium FileStorage).',
+          );
+        }
+        if (!this.subnetId) {
+          OrchestratorLogger.logWarning('[Azure ACI] NFS file shares require VNet integration. Set azureSubnetId.');
+        } else {
+          OrchestratorLogger.log(`[Azure ACI] File Share: ${this.storageAccount}/${this.fileShareName} (NFS 4.1)`);
+        }
+        break;
+      case 'blob-copy':
+        if (!this.storageAccount) {
+          OrchestratorLogger.logWarning('[Azure ACI] Storage type "blob-copy" requires azureStorageAccount to be set.');
+        } else {
+          OrchestratorLogger.log(`[Azure ACI] Blob container: ${this.storageAccount}/${this.blobContainer}`);
+        }
+        break;
+      case 'in-memory':
+        OrchestratorLogger.log(
+          `[Azure ACI] In-memory volume (emptyDir): limited by ${this.memoryGb}GB container memory`,
+        );
+        break;
+      default:
+        OrchestratorLogger.logWarning(
+          `[Azure ACI] Unknown storage type '${this.storageType}'. Valid: azure-files, blob-copy, azure-files-nfs, in-memory`,
+        );
+    }
+
+    if (!this.resourceGroup) {
+      OrchestratorLogger.logWarning(
+        '[Azure ACI] No resource group specified. Set azureResourceGroup input or AZURE_RESOURCE_GROUP env var.',
+      );
+    }
+  }
+
+  async setupWorkflow(
+    buildGuid: string,
+    buildParameters: BuildParameters,
+    branchName: string,
+    defaultSecretsArray: { ParameterKey: string; EnvironmentVariable: string; ParameterValue: string }[],
+  ) {
+    OrchestratorLogger.log(`[Azure ACI] Setting up workflow for build ${buildGuid}`);
+    ResourceTracking.logAllocationSummary('azure-aci setup');
+
+    // Verify Azure CLI is available
+    try {
+      await OrchestratorSystem.Run('az version --output json', false, true);
+      OrchestratorLogger.log('[Azure ACI] Azure CLI detected');
+    } catch {
+      throw new Error(
+        '[Azure ACI] Azure CLI not found. Install Azure CLI: https://learn.microsoft.com/en-us/cli/azure/install-azure-cli',
+      );
+    }
+
+    if (this.subscriptionId) {
+      await OrchestratorSystem.Run(`az account set --subscription="${this.subscriptionId}"`);
+    }
+
+    // Ensure resource group exists
+    if (this.resourceGroup) {
+      try {
+        await OrchestratorSystem.Run(`az group show --name "${this.resourceGroup}" --output json`, false, true);
+        OrchestratorLogger.log(`[Azure ACI] Resource group ${this.resourceGroup} exists`);
+      } catch {
+        OrchestratorLogger.log(`[Azure ACI] Creating resource group ${this.resourceGroup}`);
+        await OrchestratorSystem.Run(`az group create --name "${this.resourceGroup}" --location "${this.location}"`);
+      }
+    }
+
+    // Storage-specific setup
+    switch (this.storageType) {
+      case 'azure-files':
+        await this.setupStorageAccount('Standard_LRS', 'StorageV2');
+        await this.setupFileShare();
+        break;
+      case 'azure-files-nfs':
+        await this.setupStorageAccount('Premium_LRS', 'FileStorage');
+        await this.setupNfsFileShare();
+        break;
+      case 'blob-copy':
+        await this.setupStorageAccount('Standard_LRS', 'StorageV2');
+        await this.setupBlobContainer();
+        break;
+      case 'in-memory':
+        // No storage setup needed
+        break;
+    }
+  }
+
+  private async setupStorageAccount(sku: string, kind: string): Promise<void> {
+    if (!this.storageAccount || !this.resourceGroup) return;
+
+    try {
+      await OrchestratorSystem.Run(
+        `az storage account show --name "${this.storageAccount}" --resource-group "${this.resourceGroup}" --output json`,
+        false,
+        true,
+      );
+      OrchestratorLogger.log(`[Azure ACI] Storage account ${this.storageAccount} exists`);
+    } catch {
+      OrchestratorLogger.log(`[Azure ACI] Creating storage account ${this.storageAccount} (${sku}, ${kind})`);
+      await OrchestratorSystem.Run(
+        `az storage account create --name "${this.storageAccount}" --resource-group "${this.resourceGroup}" --location "${this.location}" --sku ${sku} --kind ${kind}`,
+      );
+    }
+  }
+
+  private async setupFileShare(): Promise<void> {
+    if (!this.storageAccount || !this.resourceGroup) return;
+    try {
+      await OrchestratorSystem.Run(
+        `az storage share-rm show --storage-account "${this.storageAccount}" --name "${this.fileShareName}" --resource-group "${this.resourceGroup}" --output json`,
+        false,
+        true,
+      );
+    } catch {
+      OrchestratorLogger.log(`[Azure ACI] Creating file share ${this.fileShareName} (${this.diskSizeGb}GB)`);
+      await OrchestratorSystem.Run(
+        `az storage share-rm create --storage-account "${this.storageAccount}" --name "${this.fileShareName}" --resource-group "${this.resourceGroup}" --quota ${this.diskSizeGb}`,
+      );
+    }
+  }
+
+  private async setupNfsFileShare(): Promise<void> {
+    if (!this.storageAccount || !this.resourceGroup) return;
+    try {
+      await OrchestratorSystem.Run(
+        `az storage share-rm show --storage-account "${this.storageAccount}" --name "${this.fileShareName}" --resource-group "${this.resourceGroup}" --output json`,
+        false,
+        true,
+      );
+    } catch {
+      OrchestratorLogger.log(`[Azure ACI] Creating NFS file share ${this.fileShareName} (${this.diskSizeGb}GB)`);
+      await OrchestratorSystem.Run(
+        `az storage share-rm create --storage-account "${this.storageAccount}" --name "${this.fileShareName}" --resource-group "${this.resourceGroup}" --quota ${this.diskSizeGb} --enabled-protocols NFS`,
+      );
+    }
+  }
+
+  private async setupBlobContainer(): Promise<void> {
+    if (!this.storageAccount || !this.resourceGroup) return;
+    try {
+      await OrchestratorSystem.Run(
+        `az storage container show --name "${this.blobContainer}" --account-name "${this.storageAccount}" --output json`,
+        false,
+        true,
+      );
+    } catch {
+      OrchestratorLogger.log(`[Azure ACI] Creating blob container ${this.blobContainer}`);
+      await OrchestratorSystem.Run(
+        `az storage container create --name "${this.blobContainer}" --account-name "${this.storageAccount}"`,
+      );
+    }
+  }
+
+  private async getStorageKey(): Promise<string> {
+    if (!this.storageAccount || !this.resourceGroup) return '';
+    try {
+      const keyJson = await OrchestratorSystem.Run(
+        `az storage account keys list --account-name "${this.storageAccount}" --resource-group "${this.resourceGroup}" --output json`,
+        false,
+        true,
+      );
+      const keys = JSON.parse(keyJson);
+      return keys[0]?.value || '';
+    } catch (error: any) {
+      OrchestratorLogger.logWarning(`[Azure ACI] Could not get storage key: ${error.message}`);
+      return '';
+    }
+  }
+
+  private async buildVolumeFlags(mountdir: string): Promise<string> {
+    switch (this.storageType) {
+      case 'azure-files': {
+        const storageKey = await this.getStorageKey();
+        if (!storageKey) return '';
+        return [
+          `--azure-file-volume-account-name "${this.storageAccount}"`,
+          `--azure-file-volume-account-key "${storageKey}"`,
+          `--azure-file-volume-share-name "${this.fileShareName}"`,
+          `--azure-file-volume-mount-path "${mountdir}"`,
+        ].join(' ');
+      }
+
+      case 'azure-files-nfs': {
+        // ACI NFS mount uses a YAML deployment template; for CLI we use the same
+        // azure-file-volume flags but the share must be NFS-enabled and
+        // the container must be in a VNet
+        const storageKey = await this.getStorageKey();
+        if (!storageKey) return '';
+        return [
+          `--azure-file-volume-account-name "${this.storageAccount}"`,
+          `--azure-file-volume-account-key "${storageKey}"`,
+          `--azure-file-volume-share-name "${this.fileShareName}"`,
+          `--azure-file-volume-mount-path "${mountdir}"`,
+        ].join(' ');
+      }
+
+      case 'in-memory':
+        // ACI emptyDir volumes require YAML deployment; for simplicity we skip
+        // the volume mount and let the container use its own filesystem
+        OrchestratorLogger.log('[Azure ACI] In-memory mode: using container filesystem (no persistent mount)');
+        return '';
+
+      case 'blob-copy':
+        // No volume mount — artifacts are copied in/out via az storage blob commands
+        return '';
+
+      default:
+        return '';
+    }
+  }
+
+  async runTaskInWorkflow(
+    buildGuid: string,
+    image: string,
+    commands: string,
+    mountdir: string,
+    workingdir: string,
+    environment: OrchestratorEnvironmentVariable[],
+    secrets: OrchestratorSecret[],
+  ): Promise<string> {
+    OrchestratorLogger.log(`[Azure ACI] Running task for build ${buildGuid}`);
+    ResourceTracking.logAllocationSummary('azure-aci task');
+
+    const containerName = `unity-build-${buildGuid}`
+      .toLowerCase()
+      .replace(/[^a-z0-9-]/g, '-')
+      .slice(0, 63);
+
+    // Build environment variable flags
+    const allEnvVars = [
+      ...environment.map((env) => `${env.name}=${env.value}`),
+      ...secrets.map((s) => `${s.EnvironmentVariable}=${s.ParameterValue}`),
+    ];
+    const envFlag = allEnvVars.length > 0 ? `--environment-variables ${allEnvVars.map((e) => `"${e}"`).join(' ')}` : '';
+
+    // Build volume flags based on storage type
+    const volumeFlags = await this.buildVolumeFlags(mountdir);
+
+    const subnetFlag = this.subnetId ? `--subnet "${this.subnetId}"` : '';
+
+    // For blob-copy, wrap the user command with copy-in/copy-out steps
+    let effectiveCommands = commands;
+    if (this.storageType === 'blob-copy' && this.storageAccount && commands) {
+      effectiveCommands = [
+        `az storage blob download-batch --destination "${mountdir}" --source "${this.blobContainer}" --account-name "${this.storageAccount}" 2>/dev/null || true`,
+        commands,
+        `az storage blob upload-batch --source "${mountdir}" --destination "${this.blobContainer}" --account-name "${this.storageAccount}" --overwrite`,
+      ].join(' && ');
+    }
+
+    const commandFlag = effectiveCommands
+      ? `--command-line "/bin/sh -c '${effectiveCommands.replace(/'/g, "'\\''")}'"`
+      : '';
+
+    const createCmd = [
+      'az container create',
+      `--resource-group "${this.resourceGroup}"`,
+      `--name "${containerName}"`,
+      `--image "${image}"`,
+      `--location "${this.location}"`,
+      `--cpu ${this.cpu}`,
+      `--memory ${this.memoryGb}`,
+      '--restart-policy Never',
+      '--os-type Linux',
+      volumeFlags,
+      envFlag,
+      subnetFlag,
+      commandFlag,
+      '--output json',
+    ]
+      .filter(Boolean)
+      .join(' ');
+
+    try {
+      await OrchestratorSystem.Run(createCmd);
+      OrchestratorLogger.log(
+        `[Azure ACI] Container ${containerName} created (storage: ${this.storageType}), waiting for completion...`,
+      );
+    } catch (error: any) {
+      throw new Error(`[Azure ACI] Failed to create container: ${error.message}`);
+    }
+
+    const output = await this.waitForContainerCompletion(containerName);
+    return output;
+  }
+
+  private async waitForContainerCompletion(containerName: string): Promise<string> {
+    const maxWaitMs = 24 * 60 * 60 * 1000;
+    const pollIntervalMs = 15_000;
+    const startTime = Date.now();
+    let lastLogLength = 0;
+
+    while (Date.now() - startTime < maxWaitMs) {
+      try {
+        const stateJson = await OrchestratorSystem.Run(
+          `az container show --resource-group "${this.resourceGroup}" --name "${containerName}" --output json`,
+          false,
+          true,
+        );
+
+        const state = JSON.parse(stateJson);
+        const containerState =
+          state.containers?.[0]?.instanceView?.currentState?.state || state.instanceView?.state || 'Unknown';
+        const provisioningState = state.provisioningState || 'Unknown';
+
+        // Stream logs incrementally
+        try {
+          const logs = await OrchestratorSystem.Run(
+            `az container logs --resource-group "${this.resourceGroup}" --name "${containerName}"`,
+            false,
+            true,
+          );
+          if (logs && logs.length > lastLogLength) {
+            const newLogs = logs.slice(lastLogLength);
+            for (const line of newLogs.split('\n')) {
+              if (line.trim()) {
+                OrchestratorLogger.log(`[Build] ${line}`);
+              }
+            }
+            lastLogLength = logs.length;
+          }
+        } catch {
+          // Logs may not be available yet
+        }
+
+        if (containerState === 'Terminated' || provisioningState === 'Succeeded') {
+          const exitCode = state.containers?.[0]?.instanceView?.currentState?.exitCode;
+          if (exitCode !== undefined && exitCode !== 0) {
+            throw new Error(`[Azure ACI] Container exited with code ${exitCode}`);
+          }
+          OrchestratorLogger.log('[Azure ACI] Container completed successfully');
+          try {
+            return await OrchestratorSystem.Run(
+              `az container logs --resource-group "${this.resourceGroup}" --name "${containerName}"`,
+              false,
+              true,
+            );
+          } catch {
+            return '';
+          }
+        }
+
+        if (provisioningState === 'Failed') {
+          const detail =
+            state.containers?.[0]?.instanceView?.currentState?.detailStatus ||
+            state.containers?.[0]?.instanceView?.events?.map((e: any) => e.message).join('; ') ||
+            'Unknown error';
+          throw new Error(`[Azure ACI] Container provisioning failed: ${detail}`);
+        }
+      } catch (error: any) {
+        if (error.message?.includes('Container provisioning failed') || error.message?.includes('exited with code')) {
+          throw error;
+        }
+        OrchestratorLogger.logWarning(`[Azure ACI] Polling error: ${error.message}`);
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+
+    throw new Error('[Azure ACI] Container execution timed out after 24 hours');
+  }
+
+  async cleanupWorkflow(
+    buildParameters: BuildParameters,
+    branchName: string,
+    defaultSecretsArray: { ParameterKey: string; EnvironmentVariable: string; ParameterValue: string }[],
+  ) {
+    OrchestratorLogger.log('[Azure ACI] Cleaning up workflow');
+  }
+
+  async garbageCollect(
+    filter: string,
+    previewOnly: boolean,
+    olderThan: Number,
+    fullCache: boolean,
+    baseDependencies: boolean,
+  ): Promise<string> {
+    OrchestratorLogger.log('[Azure ACI] Garbage collecting old container groups');
+
+    try {
+      const containersJson = await OrchestratorSystem.Run(
+        `az container list --resource-group "${this.resourceGroup}" --output json`,
+        false,
+        true,
+      );
+
+      const containers = JSON.parse(containersJson || '[]');
+      const cutoffDate = new Date();
+      cutoffDate.setDate(cutoffDate.getDate() - Number(olderThan));
+
+      let deletedCount = 0;
+      for (const container of containers) {
+        const name = container.name || '';
+        if (!name.startsWith('unity-build-')) continue;
+
+        const createdAt = new Date(container.tags?.createdAt || container.properties?.provisioningState || 0);
+        const state = container.containers?.[0]?.instanceView?.currentState?.state || '';
+
+        if (state === 'Terminated' || createdAt < cutoffDate) {
+          if (previewOnly) {
+            OrchestratorLogger.log(`[Azure ACI] Would delete: ${name}`);
+          } else {
+            await OrchestratorSystem.Run(
+              `az container delete --resource-group "${this.resourceGroup}" --name "${name}" --yes`,
+            );
+            deletedCount++;
+          }
+        }
+      }
+
+      return `Garbage collected ${deletedCount} Azure container instances`;
+    } catch (error: any) {
+      OrchestratorLogger.logWarning(`[Azure ACI] Garbage collection failed: ${error.message}`);
+      return '';
+    }
+  }
+
+  async listResources(): Promise<ProviderResource[]> {
+    try {
+      const containersJson = await OrchestratorSystem.Run(
+        `az container list --resource-group "${this.resourceGroup}" --output json`,
+        false,
+        true,
+      );
+
+      const containers = JSON.parse(containersJson || '[]');
+      return containers
+        .filter((c: any) => (c.name || '').startsWith('unity-build-'))
+        .map((c: any) => ({ Name: c.name || '' }));
+    } catch {
+      return [];
+    }
+  }
+
+  listWorkflow(): Promise<ProviderWorkflow[]> {
+    throw new Error('[Azure ACI] listWorkflow not implemented for this experimental provider');
+  }
+
+  async watchWorkflow(): Promise<string> {
+    throw new Error('[Azure ACI] watchWorkflow not implemented for this experimental provider');
+  }
+}
+
+export default AzureAciProvider;
--- a/src/model/orchestrator/providers/gcp-cloud-run/index.ts
+++ b/src/model/orchestrator/providers/gcp-cloud-run/index.ts
@@ -0,0 +1,435 @@
+/**
+ * Google Cloud Run Jobs Provider (Experimental)
+ *
+ * Executes Unity builds as Cloud Run Jobs with configurable storage backends.
+ *
+ * Storage types:
+ *   - gcs-fuse:   Mount a GCS bucket as a POSIX filesystem via GCS FUSE sidecar.
+ *                  Unlimited size, best for large sequential reads/writes.
+ *                  Requires: gcpBucket
+ *   - gcs-copy:   Copy artifacts in/out of GCS before/after the build via gsutil.
+ *                  No mount overhead, simpler, works everywhere.
+ *                  Requires: gcpBucket
+ *   - nfs:        Mount a Filestore NFS share. True POSIX semantics, good random I/O,
+ *                  up to 100 TiB. Best for Library caching (many small random reads).
+ *                  Requires: gcpFilestoreIp, gcpFilestoreShare
+ *   - in-memory:  tmpfs volume (emptyDir). Fastest I/O but volatile and limited to 32 GiB.
+ *                  Good for scratch/temp space during builds.
+ *
+ * Prerequisites:
+ *   - Google Cloud SDK authenticated (GOOGLE_APPLICATION_CREDENTIALS or gcloud auth)
+ *   - Cloud Run Jobs API enabled
+ *   - Service account with roles: Cloud Run Admin, Storage Admin, Logs Viewer
+ *
+ * @experimental This provider is experimental. APIs and behavior may change.
+ */
+
+import { ProviderInterface } from '../provider-interface';
+import BuildParameters from '../../../build-parameters';
+import OrchestratorLogger from '../../services/core/orchestrator-logger';
+import OrchestratorEnvironmentVariable from '../../options/orchestrator-environment-variable';
+import OrchestratorSecret from '../../options/orchestrator-secret';
+import { ProviderResource } from '../provider-resource';
+import { ProviderWorkflow } from '../provider-workflow';
+import { OrchestratorSystem } from '../../services/core/orchestrator-system';
+import { Input } from '../../..';
+import ResourceTracking from '../../services/core/resource-tracking';
+
+type GcpStorageType = 'gcs-fuse' | 'gcs-copy' | 'nfs' | 'in-memory';
+
+class GcpCloudRunProvider implements ProviderInterface {
+  private readonly project: string;
+  private readonly region: string;
+  private readonly storageType: GcpStorageType;
+  private readonly bucket: string;
+  private readonly filestoreIp: string;
+  private readonly filestoreShare: string;
+  private readonly machineType: string;
+  private readonly diskSizeGb: number;
+  private readonly serviceAccount: string;
+  private readonly vpcConnector: string;
+  private buildParameters: BuildParameters;
+
+  constructor(buildParameters: BuildParameters) {
+    this.buildParameters = buildParameters;
+    this.project = buildParameters.gcpProject || process.env.GOOGLE_CLOUD_PROJECT || process.env.GCLOUD_PROJECT || '';
+    this.region = buildParameters.gcpRegion || Input.region || 'us-central1';
+    this.storageType = (buildParameters.gcpStorageType || 'gcs-fuse') as GcpStorageType;
+    this.bucket = buildParameters.gcpBucket || '';
+    this.filestoreIp = buildParameters.gcpFilestoreIp || '';
+    this.filestoreShare = buildParameters.gcpFilestoreShare || '/share1';
+    this.machineType = buildParameters.gcpMachineType || 'e2-standard-4';
+    this.diskSizeGb = Number.parseInt(buildParameters.gcpDiskSizeGb || '100', 10);
+    this.serviceAccount = buildParameters.gcpServiceAccount || '';
+    this.vpcConnector = buildParameters.gcpVpcConnector || '';
+
+    OrchestratorLogger.log('[GCP Cloud Run] Provider initialized (EXPERIMENTAL)');
+    OrchestratorLogger.log(`[GCP Cloud Run] Project: ${this.project || '(auto-detect)'}`);
+    OrchestratorLogger.log(`[GCP Cloud Run] Region: ${this.region}`);
+    OrchestratorLogger.log(`[GCP Cloud Run] Storage: ${this.storageType}`);
+
+    this.validateStorageConfig();
+  }
+
+  private validateStorageConfig(): void {
+    switch (this.storageType) {
+      case 'gcs-fuse':
+      case 'gcs-copy':
+        if (!this.bucket) {
+          OrchestratorLogger.logWarning(
+            `[GCP Cloud Run] Storage type '${this.storageType}' requires gcpBucket to be set.`,
+          );
+        } else {
+          OrchestratorLogger.log(`[GCP Cloud Run] Bucket: gs://${this.bucket}`);
+        }
+        break;
+      case 'nfs':
+        if (!this.filestoreIp) {
+          OrchestratorLogger.logWarning('[GCP Cloud Run] Storage type "nfs" requires gcpFilestoreIp to be set.');
+        } else {
+          OrchestratorLogger.log(`[GCP Cloud Run] Filestore: ${this.filestoreIp}:${this.filestoreShare}`);
+        }
+        if (!this.vpcConnector) {
+          OrchestratorLogger.logWarning(
+            '[GCP Cloud Run] NFS storage usually requires gcpVpcConnector for private network access to Filestore.',
+          );
+        }
+        break;
+      case 'in-memory':
+        OrchestratorLogger.log(`[GCP Cloud Run] In-memory volume: ${Math.min(this.diskSizeGb, 32)} GiB (max 32)`);
+        break;
+      default:
+        OrchestratorLogger.logWarning(
+          `[GCP Cloud Run] Unknown storage type '${this.storageType}'. Valid: gcs-fuse, gcs-copy, nfs, in-memory`,
+        );
+    }
+
+    if (!this.project) {
+      OrchestratorLogger.logWarning(
+        '[GCP Cloud Run] No project specified. Set gcpProject input or GOOGLE_CLOUD_PROJECT env var.',
+      );
+    }
+  }
+
+  async setupWorkflow(
+    buildGuid: string,
+    buildParameters: BuildParameters,
+    branchName: string,
+    defaultSecretsArray: { ParameterKey: string; EnvironmentVariable: string; ParameterValue: string }[],
+  ) {
+    OrchestratorLogger.log(`[GCP Cloud Run] Setting up workflow for build ${buildGuid}`);
+    ResourceTracking.logAllocationSummary('gcp-cloud-run setup');
+
+    // Verify gcloud CLI is available
+    try {
+      await OrchestratorSystem.Run('gcloud --version', false, true);
+      OrchestratorLogger.log('[GCP Cloud Run] gcloud CLI detected');
+    } catch {
+      throw new Error(
+        '[GCP Cloud Run] gcloud CLI not found. Install Google Cloud SDK: https://cloud.google.com/sdk/docs/install',
+      );
+    }
+
+    // Verify Cloud Run Jobs API is enabled
+    try {
+      const projectFlag = this.project ? `--project=${this.project}` : '';
+      await OrchestratorSystem.Run(
+        `gcloud services list --enabled --filter="name:run.googleapis.com" ${projectFlag} --format="value(name)"`,
+        false,
+        true,
+      );
+    } catch {
+      OrchestratorLogger.logWarning(
+        '[GCP Cloud Run] Could not verify Cloud Run API status. Ensure run.googleapis.com is enabled.',
+      );
+    }
+
+    // Storage-specific setup
+    if ((this.storageType === 'gcs-fuse' || this.storageType === 'gcs-copy') && this.bucket) {
+      await this.ensureBucketExists();
+    }
+  }
+
+  private async ensureBucketExists(): Promise<void> {
+    try {
+      await OrchestratorSystem.Run(
+        `gcloud storage buckets describe gs://${this.bucket} --format="value(name)"`,
+        false,
+        true,
+      );
+      OrchestratorLogger.log(`[GCP Cloud Run] Bucket gs://${this.bucket} exists`);
+    } catch {
+      OrchestratorLogger.log(`[GCP Cloud Run] Creating bucket gs://${this.bucket}`);
+      const projectFlag = this.project ? `--project=${this.project}` : '';
+      await OrchestratorSystem.Run(
+        `gcloud storage buckets create gs://${this.bucket} --location=${this.region} ${projectFlag}`,
+      );
+    }
+  }
+
+  private buildVolumeFlags(mountdir: string): { volumeFlags: string; mountFlags: string } {
+    switch (this.storageType) {
+      case 'gcs-fuse':
+        if (!this.bucket) return { volumeFlags: '', mountFlags: '' };
+        return {
+          volumeFlags: `--add-volume=name=gcs-fuse,type=cloud-storage,bucket=${this.bucket}`,
+          mountFlags: `--add-volume-mount=volume=gcs-fuse,mount-path=${mountdir}`,
+        };
+
+      case 'nfs':
+        if (!this.filestoreIp) return { volumeFlags: '', mountFlags: '' };
+        return {
+          volumeFlags: `--add-volume=name=nfs-vol,type=nfs,location=${this.filestoreIp}:${this.filestoreShare}`,
+          mountFlags: `--add-volume-mount=volume=nfs-vol,mount-path=${mountdir}`,
+        };
+
+      case 'in-memory': {
+        const sizeGib = Math.min(this.diskSizeGb, 32);
+        return {
+          volumeFlags: `--add-volume=name=tmpfs-vol,type=in-memory,size-limit=${sizeGib}Gi`,
+          mountFlags: `--add-volume-mount=volume=tmpfs-vol,mount-path=${mountdir}`,
+        };
+      }
+
+      case 'gcs-copy':
+        // No volume mount — artifacts are copied in/out via gsutil commands
+        return { volumeFlags: '', mountFlags: '' };
+
+      default:
+        return { volumeFlags: '', mountFlags: '' };
+    }
+  }
+
+  private async copyArtifactsIn(mountdir: string): Promise<void> {
+    if (this.storageType !== 'gcs-copy' || !this.bucket) return;
+    OrchestratorLogger.log(`[GCP Cloud Run] Copying artifacts from gs://${this.bucket} to ${mountdir}`);
+    try {
+      await OrchestratorSystem.Run(`gcloud storage cp -r "gs://${this.bucket}/*" "${mountdir}/" || true`, false, true);
+    } catch {
+      OrchestratorLogger.log('[GCP Cloud Run] No existing artifacts to restore (bucket may be empty)');
+    }
+  }
+
+  private async copyArtifactsOut(mountdir: string): Promise<void> {
+    if (this.storageType !== 'gcs-copy' || !this.bucket) return;
+    OrchestratorLogger.log(`[GCP Cloud Run] Uploading artifacts from ${mountdir} to gs://${this.bucket}`);
+    await OrchestratorSystem.Run(`gcloud storage cp -r "${mountdir}/*" "gs://${this.bucket}/"`, false, true);
+  }
+
+  async runTaskInWorkflow(
+    buildGuid: string,
+    image: string,
+    commands: string,
+    mountdir: string,
+    workingdir: string,
+    environment: OrchestratorEnvironmentVariable[],
+    secrets: OrchestratorSecret[],
+  ): Promise<string> {
+    OrchestratorLogger.log(`[GCP Cloud Run] Running task for build ${buildGuid}`);
+    ResourceTracking.logAllocationSummary('gcp-cloud-run task');
+
+    const jobName = `unity-build-${buildGuid}`
+      .toLowerCase()
+      .replace(/[^a-z0-9-]/g, '-')
+      .slice(0, 63);
+    const projectFlag = this.project ? `--project=${this.project}` : '';
+
+    // Build environment variable flags
+    const envFlags = environment
+      .map((env) => `${env.name}=${env.value}`)
+      .concat(secrets.map((s) => `${s.EnvironmentVariable}=${s.ParameterValue}`));
+    const envString = envFlags.length > 0 ? `--set-env-vars="${envFlags.join(',')}"` : '';
+
+    // Build storage volume flags
+    const { volumeFlags, mountFlags } = this.buildVolumeFlags(mountdir);
+
+    // For gcs-copy, wrap the user command with copy-in/copy-out steps
+    let effectiveCommands = commands;
+    if (this.storageType === 'gcs-copy' && this.bucket && commands) {
+      effectiveCommands = [
+        `gcloud storage cp -r "gs://${this.bucket}/*" "${mountdir}/" 2>/dev/null || true`,
+        commands,
+        `gcloud storage cp -r "${mountdir}/*" "gs://${this.bucket}/"`,
+      ].join(' && ');
+    }
+
+    const saFlag = this.serviceAccount ? `--service-account=${this.serviceAccount}` : '';
+    const vpcFlag = this.vpcConnector ? `--vpc-connector=${this.vpcConnector}` : '';
+
+    // Create the Cloud Run Job
+    const createCmd = [
+      'gcloud run jobs create',
+      jobName,
+      `--image=${image}`,
+      `--region=${this.region}`,
+      '--task-timeout=86400s',
+      '--max-retries=0',
+      '--cpu=4',
+      '--memory=16Gi',
+      volumeFlags,
+      mountFlags,
+      envString,
+      saFlag,
+      vpcFlag,
+      projectFlag,
+      '--format=json',
+      '--quiet',
+    ]
+      .filter(Boolean)
+      .join(' ');
+
+    try {
+      await OrchestratorSystem.Run(createCmd);
+      OrchestratorLogger.log(`[GCP Cloud Run] Job ${jobName} created`);
+    } catch (error: any) {
+      if (error.message?.includes('already exists')) {
+        OrchestratorLogger.log(`[GCP Cloud Run] Job ${jobName} already exists, updating...`);
+        const updateCmd = createCmd.replace('jobs create', 'jobs update');
+        await OrchestratorSystem.Run(updateCmd);
+      } else {
+        throw error;
+      }
+    }
+
+    // Override the command if provided
+    if (effectiveCommands) {
+      const updateCmd = [
+        'gcloud run jobs update',
+        jobName,
+        `--region=${this.region}`,
+        '--command="/bin/sh"',
+        `--args="-c,${effectiveCommands}"`,
+        projectFlag,
+        '--quiet',
+      ]
+        .filter(Boolean)
+        .join(' ');
+
+      await OrchestratorSystem.Run(updateCmd);
+    }
+
+    // Execute the job
+    OrchestratorLogger.log(`[GCP Cloud Run] Executing job ${jobName} (storage: ${this.storageType})...`);
+    const executeCmd = [
+      'gcloud run jobs execute',
+      jobName,
+      `--region=${this.region}`,
+      projectFlag,
+      '--wait',
+      '--format=json',
+      '--quiet',
+    ]
+      .filter(Boolean)
+      .join(' ');
+
+    let output = '';
+    try {
+      output = await OrchestratorSystem.Run(executeCmd);
+      OrchestratorLogger.log('[GCP Cloud Run] Job execution completed');
+    } catch (error: any) {
+      await this.streamJobLogs(jobName);
+      throw new Error(`[GCP Cloud Run] Job execution failed: ${error.message}`);
+    }
+
+    await this.streamJobLogs(jobName);
+    return output;
+  }
+
+  private async streamJobLogs(jobName: string): Promise<void> {
+    const projectFlag = this.project ? `--project=${this.project}` : '';
+    try {
+      const logs = await OrchestratorSystem.Run(
+        `gcloud logging read "resource.type=cloud_run_job AND resource.labels.job_name=${jobName}" ${projectFlag} --limit=1000 --format="value(textPayload)" --order=asc`,
+        false,
+        true,
+      );
+      if (logs) {
+        for (const line of logs.split('\n')) {
+          if (line.trim()) {
+            OrchestratorLogger.log(`[Build] ${line}`);
+          }
+        }
+      }
+    } catch {
+      OrchestratorLogger.logWarning('[GCP Cloud Run] Could not retrieve job logs');
+    }
+  }
+
+  async cleanupWorkflow(
+    buildParameters: BuildParameters,
+    branchName: string,
+    defaultSecretsArray: { ParameterKey: string; EnvironmentVariable: string; ParameterValue: string }[],
+  ) {
+    OrchestratorLogger.log('[GCP Cloud Run] Cleaning up workflow');
+  }
+
+  async garbageCollect(
+    filter: string,
+    previewOnly: boolean,
+    olderThan: Number,
+    fullCache: boolean,
+    baseDependencies: boolean,
+  ): Promise<string> {
+    OrchestratorLogger.log('[GCP Cloud Run] Garbage collecting old jobs');
+    const projectFlag = this.project ? `--project=${this.project}` : '';
+
+    try {
+      const jobsJson = await OrchestratorSystem.Run(
+        `gcloud run jobs list --region=${this.region} ${projectFlag} --filter="metadata.name~unity-build-" --format="json(metadata.name,metadata.creationTimestamp)"`,
+        false,
+        true,
+      );
+
+      const jobs = JSON.parse(jobsJson || '[]');
+      const cutoffDate = new Date();
+      cutoffDate.setDate(cutoffDate.getDate() - Number(olderThan));
+
+      let deletedCount = 0;
+      for (const job of jobs) {
+        const createdAt = new Date(job.metadata?.creationTimestamp || 0);
+        if (createdAt < cutoffDate) {
+          const name = job.metadata?.name;
+          if (previewOnly) {
+            OrchestratorLogger.log(`[GCP Cloud Run] Would delete: ${name}`);
+          } else {
+            await OrchestratorSystem.Run(
+              `gcloud run jobs delete ${name} --region=${this.region} ${projectFlag} --quiet`,
+            );
+            deletedCount++;
+          }
+        }
+      }
+
+      return `Garbage collected ${deletedCount} Cloud Run jobs`;
+    } catch (error: any) {
+      OrchestratorLogger.logWarning(`[GCP Cloud Run] Garbage collection failed: ${error.message}`);
+      return '';
+    }
+  }
+
+  async listResources(): Promise<ProviderResource[]> {
+    const projectFlag = this.project ? `--project=${this.project}` : '';
+    try {
+      const jobsJson = await OrchestratorSystem.Run(
+        `gcloud run jobs list --region=${this.region} ${projectFlag} --filter="metadata.name~unity-build-" --format="json(metadata.name)"`,
+        false,
+        true,
+      );
+
+      const jobs = JSON.parse(jobsJson || '[]');
+      return jobs.map((job: any) => ({ Name: job.metadata?.name || '' }));
+    } catch {
+      return [];
+    }
+  }
+
+  listWorkflow(): Promise<ProviderWorkflow[]> {
+    throw new Error('[GCP Cloud Run] listWorkflow not implemented for this experimental provider');
+  }
+
+  async watchWorkflow(): Promise<string> {
+    throw new Error('[GCP Cloud Run] watchWorkflow not implemented for this experimental provider');
+  }
+}
+
+export default GcpCloudRunProvider;
--- a/src/model/orchestrator/providers/github-actions/github-actions-provider.test.ts
+++ b/src/model/orchestrator/providers/github-actions/github-actions-provider.test.ts
@@ -1,333 +0,0 @@
-import GitHubActionsProvider from '.';
-import BuildParameters from '../../../build-parameters';
-import { OrchestratorSystem } from '../../services/core/orchestrator-system';
-import OrchestratorLogger from '../../services/core/orchestrator-logger';
-import * as core from '@actions/core';
-
-jest.mock('../../services/core/orchestrator-system');
-jest.mock('../../services/core/orchestrator-logger');
-jest.mock('@actions/core', () => ({
-  info: jest.fn(),
-  warning: jest.fn(),
-  error: jest.fn(),
-  setOutput: jest.fn(),
-  getInput: jest.fn(() => ''),
-}));
-
-const mockRun = OrchestratorSystem.Run as jest.MockedFunction<typeof OrchestratorSystem.Run>;
-const mockLog = OrchestratorLogger.log as jest.MockedFunction<typeof OrchestratorLogger.log>;
-
-function createBuildParameters(overrides: Partial<BuildParameters> = {}): BuildParameters {
-  return {
-    githubActionsRepo: 'owner/repo',
-    githubActionsWorkflow: 'build.yml',
-    githubActionsToken: 'ghp_test_token_123',
-    githubActionsRef: 'main',
-    ...overrides,
-  } as BuildParameters;
-}
-
-// Override setTimeout to execute callbacks immediately so polling loops complete fast
-const originalSetTimeout = global.setTimeout;
-beforeAll(() => {
-  global.setTimeout = ((fn: (...args: any[]) => void, _ms?: number, ...args: any[]) => {
-    return originalSetTimeout(fn, 0, ...args);
-  }) as any;
-});
-afterAll(() => {
-  global.setTimeout = originalSetTimeout;
-});
-
-describe('GitHubActionsProvider', () => {
-  let provider: GitHubActionsProvider;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    provider = new GitHubActionsProvider(createBuildParameters());
-  });
-
-  describe('constructor', () => {
-    it('sets default ref to main when not specified', () => {
-      const params = createBuildParameters({ githubActionsRef: undefined });
-      const p = new GitHubActionsProvider(params);
-      expect(p).toBeDefined();
-    });
-
-    it('uses provided ref when specified', () => {
-      const params = createBuildParameters({ githubActionsRef: 'develop' });
-      const p = new GitHubActionsProvider(params);
-      expect(p).toBeDefined();
-    });
-  });
-
-  describe('setupWorkflow', () => {
-    it('verifies workflow exists via gh api and logs success', async () => {
-      mockRun.mockResolvedValueOnce('12345\n');
-
-      await provider.setupWorkflow('guid-123', createBuildParameters(), 'main', []);
-
-      expect(mockRun).toHaveBeenCalledTimes(1);
-      const command = mockRun.mock.calls[0][0];
-      expect(command).toContain('gh api repos/owner/repo/actions/workflows/build.yml');
-      expect(command).toContain("--jq '.id'");
-      expect(command).toContain('GH_TOKEN=ghp_test_token_123');
-      expect(mockLog).toHaveBeenCalledWith(expect.stringContaining('Workflow verified'));
-    });
-
-    it('throws when repo is not configured', async () => {
-      const params = createBuildParameters({ githubActionsRepo: '' });
-      provider = new GitHubActionsProvider(params);
-
-      await expect(provider.setupWorkflow('guid-123', params, 'main', [])).rejects.toThrow(
-        'githubActionsRepo and githubActionsWorkflow are required',
-      );
-    });
-
-    it('throws when workflow is not configured', async () => {
-      const params = createBuildParameters({ githubActionsWorkflow: '' });
-      provider = new GitHubActionsProvider(params);
-
-      await expect(provider.setupWorkflow('guid-123', params, 'main', [])).rejects.toThrow(
-        'githubActionsRepo and githubActionsWorkflow are required',
-      );
-    });
-
-    it('throws when token is missing', async () => {
-      const params = createBuildParameters({ githubActionsToken: '' });
-      provider = new GitHubActionsProvider(params);
-
-      await expect(provider.setupWorkflow('guid-123', params, 'main', [])).rejects.toThrow(
-        'githubActionsToken is required',
-      );
-    });
-
-    it('throws descriptive error when workflow verification fails', async () => {
-      mockRun.mockRejectedValueOnce(new Error('Not Found'));
-
-      await expect(provider.setupWorkflow('guid-123', createBuildParameters(), 'main', [])).rejects.toThrow(
-        'Failed to verify workflow build.yml in owner/repo',
-      );
-    });
-  });
-
-  describe('runTaskInWorkflow', () => {
-    it('dispatches workflow with correct inputs and returns logs on success', async () => {
-      // Dispatch succeeds
-      mockRun.mockResolvedValueOnce('');
-      // First poll finds the run
-      mockRun.mockResolvedValueOnce(JSON.stringify({ id: 99001, status: 'in_progress' }));
-      // Status poll returns completed
-      mockRun.mockResolvedValueOnce(JSON.stringify({ status: 'completed', conclusion: 'success' }));
-      // Log fetch succeeds
-      mockRun.mockResolvedValueOnce('Build output log content here');
-
-      const result = await provider.runTaskInWorkflow(
-        'guid-abc',
-        'unityci/editor:2021.3',
-        'echo build',
-        '/mount',
-        '/work',
-        [],
-        [],
-      );
-
-      expect(result).toBe('Build output log content here');
-
-      // Verify dispatch command
-      const dispatchCommand = mockRun.mock.calls[0][0];
-      expect(dispatchCommand).toContain('dispatches');
-      expect(dispatchCommand).toContain('-X POST');
-      expect(dispatchCommand).toContain("ref='main'");
-
-      // Verify log fetch command
-      const logCommand = mockRun.mock.calls[3][0];
-      expect(logCommand).toContain('gh run view');
-      expect(logCommand).toContain('--log');
-      expect(logCommand).toContain('--repo owner/repo');
-    });
-
-    it('base64 encodes commands in the inputs payload', async () => {
-      mockRun.mockResolvedValueOnce(''); // dispatch
-      mockRun.mockResolvedValueOnce(JSON.stringify({ id: 100, status: 'completed' })); // run found
-      mockRun.mockResolvedValueOnce(JSON.stringify({ status: 'completed', conclusion: 'success' })); // status
-      mockRun.mockResolvedValueOnce('logs'); // logs
-
-      await provider.runTaskInWorkflow('guid-1', 'image:latest', 'echo hello && build', '/mnt', '/w', [], []);
-
-      const dispatchCommand = mockRun.mock.calls[0][0];
-      const expectedB64 = Buffer.from('echo hello && build').toString('base64');
-      expect(dispatchCommand).toContain(expectedB64);
-    });
-
-    it('includes environment variables as JSON input', async () => {
-      mockRun.mockResolvedValueOnce(''); // dispatch
-      mockRun.mockResolvedValueOnce(JSON.stringify({ id: 200, status: 'completed' })); // run found
-      mockRun.mockResolvedValueOnce(JSON.stringify({ status: 'completed', conclusion: 'success' })); // status
-      mockRun.mockResolvedValueOnce('logs'); // logs
-
-      const env = [
-        { name: 'UNITY_LICENSE', value: 'license-data' },
-        { name: 'BUILD_TARGET', value: 'StandaloneWindows64' },
-      ];
-
-      await provider.runTaskInWorkflow('guid-2', 'img', 'cmd', '/m', '/w', env as any, []);
-
-      const dispatchCommand = mockRun.mock.calls[0][0];
-      expect(dispatchCommand).toContain('UNITY_LICENSE');
-      expect(dispatchCommand).toContain('BUILD_TARGET');
-    });
-
-    it('throws when workflow dispatch fails', async () => {
-      mockRun.mockRejectedValueOnce(new Error('403 Forbidden'));
-
-      await expect(provider.runTaskInWorkflow('guid-err', 'img', 'cmd', '/m', '/w', [], [])).rejects.toThrow(
-        'Failed to dispatch workflow',
-      );
-    });
-
-    it('throws when workflow run does not start within timeout', async () => {
-      mockRun.mockResolvedValueOnce(''); // dispatch succeeds
-
-      // All 30 poll attempts fail
-      for (let i = 0; i < 30; i++) {
-        mockRun.mockRejectedValueOnce(new Error('not found'));
-      }
-
-      await expect(provider.runTaskInWorkflow('guid-timeout', 'img', 'cmd', '/m', '/w', [], [])).rejects.toThrow(
-        'Workflow run did not start within',
-      );
-    });
-
-    it('throws when workflow run fails with non-success conclusion', async () => {
-      mockRun.mockResolvedValueOnce(''); // dispatch
-      mockRun.mockResolvedValueOnce(JSON.stringify({ id: 300, status: 'in_progress' })); // run appears
-      mockRun.mockResolvedValueOnce(JSON.stringify({ status: 'completed', conclusion: 'failure' })); // fails
-
-      await expect(provider.runTaskInWorkflow('guid-fail', 'img', 'cmd', '/m', '/w', [], [])).rejects.toThrow(
-        'Workflow run failed with conclusion: failure',
-      );
-    });
-
-    it('returns fallback message when log fetch fails', async () => {
-      mockRun.mockResolvedValueOnce(''); // dispatch
-      mockRun.mockResolvedValueOnce(JSON.stringify({ id: 400, status: 'completed' })); // run appears
-      mockRun.mockResolvedValueOnce(JSON.stringify({ status: 'completed', conclusion: 'success' })); // completes
-      mockRun.mockRejectedValueOnce(new Error('logs unavailable')); // log fetch fails
-
-      const result = await provider.runTaskInWorkflow('guid-nologs', 'img', 'cmd', '/m', '/w', [], []);
-
-      expect(result).toContain('completed successfully');
-      expect(result).toContain('logs unavailable');
-    });
-
-    it('handles cancelled workflow run conclusion', async () => {
-      mockRun.mockResolvedValueOnce(''); // dispatch
-      mockRun.mockResolvedValueOnce(JSON.stringify({ id: 500, status: 'in_progress' })); // run
-      mockRun.mockResolvedValueOnce(JSON.stringify({ status: 'completed', conclusion: 'cancelled' })); // cancelled
-
-      await expect(provider.runTaskInWorkflow('guid-cancel', 'img', 'cmd', '/m', '/w', [], [])).rejects.toThrow(
-        'Workflow run failed with conclusion: cancelled',
-      );
-    });
-
-    it('throws timeout error when polling exceeds maximum duration', async () => {
-      // Save real Date.now
-      const realDateNow = Date.now;
-      let callCount = 0;
-
-      // dispatch succeeds
-      mockRun.mockResolvedValueOnce('');
-      // run appears
-      mockRun.mockResolvedValueOnce(JSON.stringify({ id: 600, status: 'in_progress' }));
-      // Status always returns in_progress
-      mockRun.mockImplementation(() => Promise.resolve(JSON.stringify({ status: 'in_progress' })));
-
-      // First call returns normal time, subsequent calls simulate 5 hours elapsed
-      Date.now = () => {
-        callCount++;
-        if (callCount <= 2) return realDateNow.call(Date);
-        return realDateNow.call(Date) + 14_400_001; // 4 hours + 1ms
-      };
-
-      try {
-        await expect(provider.runTaskInWorkflow('guid-poll-timeout', 'img', 'cmd', '/m', '/w', [], [])).rejects.toThrow(
-          'did not complete within 4 hours',
-        );
-
-        expect(core.error).toHaveBeenCalledWith(expect.stringContaining('did not complete within 4 hours'));
-      } finally {
-        Date.now = realDateNow;
-      }
-    });
-  });
-
-  describe('cleanupWorkflow', () => {
-    it('completes without error and logs cleanup message', async () => {
-      await provider.cleanupWorkflow(createBuildParameters(), 'main', []);
-      expect(mockLog).toHaveBeenCalledWith(expect.stringContaining('Cleanup complete'));
-    });
-  });
-
-  describe('garbageCollect', () => {
-    it('returns empty string (no-op)', async () => {
-      const result = await provider.garbageCollect('', false, 0, false, false);
-      expect(result).toBe('');
-    });
-  });
-
-  describe('listResources', () => {
-    it('returns runner names from the repository', async () => {
-      mockRun.mockResolvedValueOnce('runner-1\nrunner-2\nrunner-3\n');
-
-      const resources = await provider.listResources();
-
-      expect(resources).toHaveLength(3);
-      expect(resources[0].Name).toBe('runner-1');
-      expect(resources[1].Name).toBe('runner-2');
-      expect(resources[2].Name).toBe('runner-3');
-    });
-
-    it('returns empty array when repo or token is missing', async () => {
-      const params = createBuildParameters({ githubActionsRepo: '' });
-      provider = new GitHubActionsProvider(params);
-
-      const resources = await provider.listResources();
-      expect(resources).toEqual([]);
-      expect(mockRun).not.toHaveBeenCalled();
-    });
-
-    it('returns empty array when API call fails', async () => {
-      mockRun.mockRejectedValueOnce(new Error('API error'));
-
-      const resources = await provider.listResources();
-      expect(resources).toEqual([]);
-    });
-  });
-
-  describe('listWorkflow', () => {
-    it('returns recent workflow run names', async () => {
-      mockRun.mockResolvedValueOnce('Build Unity\nRun Tests\n');
-
-      const workflows = await provider.listWorkflow();
-
-      expect(workflows).toHaveLength(2);
-      expect(workflows[0].Name).toBe('Build Unity');
-      expect(workflows[1].Name).toBe('Run Tests');
-    });
-
-    it('returns empty array when credentials missing', async () => {
-      const params = createBuildParameters({ githubActionsToken: '' });
-      provider = new GitHubActionsProvider(params);
-
-      const workflows = await provider.listWorkflow();
-      expect(workflows).toEqual([]);
-    });
-  });
-
-  describe('watchWorkflow', () => {
-    it('returns message when no active run exists', async () => {
-      const result = await provider.watchWorkflow();
-      expect(result).toBe('No active run to watch');
-    });
-  });
-});
--- a/src/model/orchestrator/providers/github-actions/index.ts
+++ b/src/model/orchestrator/providers/github-actions/index.ts
@@ -1,284 +0,0 @@
-import * as core from '@actions/core';
-import BuildParameters from '../../../build-parameters';
-import { OrchestratorSystem } from '../../services/core/orchestrator-system';
-import OrchestratorEnvironmentVariable from '../../options/orchestrator-environment-variable';
-import OrchestratorLogger from '../../services/core/orchestrator-logger';
-import { ProviderInterface } from '../provider-interface';
-import OrchestratorSecret from '../../options/orchestrator-secret';
-import { ProviderResource } from '../provider-resource';
-import { ProviderWorkflow } from '../provider-workflow';
-
-const MAX_POLLING_DURATION_MS = 14_400_000; // 4 hours
-
-/**
- * GitHub Actions provider — triggers builds as workflow_dispatch events
- * on a target repository via the GitHub API.
- *
- * Use case: Distribute builds across orgs, use specialized runner pools,
- * or trigger builds in repos with Unity licenses.
- */
-class GitHubActionsProvider implements ProviderInterface {
-  private buildParameters: BuildParameters;
-  private repo: string;
-  private workflow: string;
-  private token: string;
-  private ref: string;
-  private runId: number = 0;
-
-  constructor(buildParameters: BuildParameters) {
-    this.buildParameters = buildParameters;
-    this.repo = buildParameters.githubActionsRepo || '';
-    this.workflow = buildParameters.githubActionsWorkflow || '';
-    this.token = buildParameters.githubActionsToken || '';
-    this.ref = buildParameters.githubActionsRef || 'main';
-  }
-
-  async setupWorkflow(
-    // eslint-disable-next-line no-unused-vars
-    buildGuid: string,
-    // eslint-disable-next-line no-unused-vars
-    buildParameters: BuildParameters,
-    // eslint-disable-next-line no-unused-vars
-    branchName: string,
-    // eslint-disable-next-line no-unused-vars
-    defaultSecretsArray: { ParameterKey: string; EnvironmentVariable: string; ParameterValue: string }[],
-  ): Promise<void> {
-    OrchestratorLogger.log(`[GitHubActions] Setting up workflow dispatch to ${this.repo}`);
-
-    if (!this.repo || !this.workflow) {
-      throw new Error('githubActionsRepo and githubActionsWorkflow are required for the github-actions provider');
-    }
-
-    if (!this.token) {
-      throw new Error('githubActionsToken is required (PAT with actions:write scope)');
-    }
-
-    // Verify repository and workflow exist
-    try {
-      const result = await OrchestratorSystem.Run(
-        `GH_TOKEN=${this.token} gh api repos/${this.repo}/actions/workflows/${this.workflow} --jq '.id'`,
-      );
-      OrchestratorLogger.log(`[GitHubActions] Workflow verified: ${this.workflow} (ID: ${result.trim()})`);
-    } catch (error: any) {
-      throw new Error(`Failed to verify workflow ${this.workflow} in ${this.repo}: ${error.message || error}`);
-    }
-  }
-
-  async runTaskInWorkflow(
-    buildGuid: string,
-    image: string,
-    commands: string,
-    mountdir: string,
-    workingdir: string,
-    environment: OrchestratorEnvironmentVariable[],
-    // eslint-disable-next-line no-unused-vars
-    secrets: OrchestratorSecret[],
-  ): Promise<string> {
-    OrchestratorLogger.log(`[GitHubActions] Dispatching workflow ${this.workflow} on ${this.repo}@${this.ref}`);
-
-    // Build inputs payload
-    const inputs: Record<string, string> = {
-      buildGuid,
-      image,
-      commands: Buffer.from(commands).toString('base64'),
-      mountdir,
-      workingdir,
-    };
-
-    // Add environment variables as a JSON input
-    if (environment.length > 0) {
-      inputs.environment = JSON.stringify(environment.map((element) => ({ name: element.name, value: element.value })));
-    }
-
-    // Record the time before dispatch to identify the run
-    const beforeDispatch = new Date().toISOString();
-
-    // Dispatch the workflow
-    const inputsJson = JSON.stringify(inputs).replace(/'/g, "'\\''");
-    try {
-      await OrchestratorSystem.Run(
-        `GH_TOKEN=${this.token} gh api repos/${this.repo}/actions/workflows/${this.workflow}/dispatches -X POST -f ref='${this.ref}' -f "inputs=${inputsJson}"`,
-      );
-      OrchestratorLogger.log(`[GitHubActions] Workflow dispatched`);
-    } catch (error: any) {
-      throw new Error(`Failed to dispatch workflow: ${error.message || error}`);
-    }
-
-    // Poll for the run to appear
-    OrchestratorLogger.log(`[GitHubActions] Waiting for workflow run to start...`);
-    let attempts = 0;
-    const maxAttempts = 30;
-
-    while (attempts < maxAttempts) {
-      attempts++;
-      await new Promise((resolve) => setTimeout(resolve, 10_000));
-
-      try {
-        const runsJson = await OrchestratorSystem.Run(
-          `GH_TOKEN=${this.token} gh api "repos/${this.repo}/actions/workflows/${this.workflow}/runs?created=>${beforeDispatch}&per_page=5" --jq '.workflow_runs[0] | {id, status, conclusion}'`,
-          true,
-        );
-
-        const run = JSON.parse(runsJson.trim());
-        if (run.id) {
-          this.runId = run.id;
-          OrchestratorLogger.log(`[GitHubActions] Run started: ${this.runId} (status: ${run.status})`);
-          break;
-        }
-      } catch {
-        // Run not yet available
-      }
-    }
-
-    if (!this.runId) {
-      throw new Error(`Workflow run did not start within ${maxAttempts * 10}s`);
-    }
-
-    // Poll until completion and stream logs (with maximum duration guard)
-    let status = 'in_progress';
-    const pollingStartTime = Date.now();
-    const runUrl = `https://github.com/${this.repo}/actions/runs/${this.runId}`;
-
-    while (status === 'in_progress' || status === 'queued') {
-      const elapsedMs = Date.now() - pollingStartTime;
-      if (elapsedMs >= MAX_POLLING_DURATION_MS) {
-        const hours = Math.round(MAX_POLLING_DURATION_MS / 3_600_000);
-        const message = `GitHub Actions workflow did not complete within ${hours} hours. Run URL: ${runUrl}`;
-        core.error(message);
-        throw new Error(message);
-      }
-
-      await new Promise((resolve) => setTimeout(resolve, 15_000));
-
-      try {
-        const statusJson = await OrchestratorSystem.Run(
-          `GH_TOKEN=${this.token} gh api repos/${this.repo}/actions/runs/${this.runId} --jq '{status, conclusion}'`,
-          true,
-        );
-
-        const result = JSON.parse(statusJson.trim());
-        status = result.status;
-
-        if (status === 'completed') {
-          OrchestratorLogger.log(`[GitHubActions] Run ${this.runId} completed: ${result.conclusion}`);
-
-          if (result.conclusion !== 'success') {
-            throw new Error(`Workflow run failed with conclusion: ${result.conclusion}`);
-          }
-
-          break;
-        }
-
-        OrchestratorLogger.log(`[GitHubActions] Run ${this.runId} status: ${status}`);
-      } catch (error: any) {
-        if (error.message && error.message.includes('conclusion')) {
-          throw error;
-        }
-        if (error.message && error.message.includes('did not complete within')) {
-          throw error;
-        }
-        OrchestratorLogger.logWarning(`[GitHubActions] Status check error: ${error.message || error}`);
-      }
-    }
-
-    // Fetch logs
-    try {
-      const logs = await OrchestratorSystem.Run(
-        `GH_TOKEN=${this.token} gh run view ${this.runId} --repo ${this.repo} --log`,
-        true,
-      );
-
-      return logs;
-    } catch {
-      return `Run ${this.runId} completed successfully (logs unavailable)`;
-    }
-  }
-
-  async cleanupWorkflow(
-    // eslint-disable-next-line no-unused-vars
-    buildParameters: BuildParameters,
-    // eslint-disable-next-line no-unused-vars
-    branchName: string,
-    // eslint-disable-next-line no-unused-vars
-    defaultSecretsArray: { ParameterKey: string; EnvironmentVariable: string; ParameterValue: string }[],
-  ): Promise<void> {
-    OrchestratorLogger.log(`[GitHubActions] Cleanup complete (no resources to tear down)`);
-  }
-
-  async garbageCollect(
-    // eslint-disable-next-line no-unused-vars
-    filter: string,
-    // eslint-disable-next-line no-unused-vars
-    previewOnly: boolean,
-    // eslint-disable-next-line no-unused-vars
-    olderThan: Number,
-    // eslint-disable-next-line no-unused-vars
-    fullCache: boolean,
-    // eslint-disable-next-line no-unused-vars
-    baseDependencies: boolean,
-  ): Promise<string> {
-    return '';
-  }
-
-  async listResources(): Promise<ProviderResource[]> {
-    if (!this.repo || !this.token) return [];
-
-    try {
-      const runnersJson = await OrchestratorSystem.Run(
-        `GH_TOKEN=${this.token} gh api repos/${this.repo}/actions/runners --jq '.runners[] | .name'`,
-        true,
-      );
-
-      return runnersJson
-        .trim()
-        .split('\n')
-        .filter(Boolean)
-        .map((name) => {
-          const resource = new ProviderResource();
-          resource.Name = name.trim();
-
-          return resource;
-        });
-    } catch {
-      return [];
-    }
-  }
-
-  async listWorkflow(): Promise<ProviderWorkflow[]> {
-    if (!this.repo || !this.token) return [];
-
-    try {
-      const runsJson = await OrchestratorSystem.Run(
-        `GH_TOKEN=${this.token} gh api repos/${this.repo}/actions/runs?per_page=10 --jq '.workflow_runs[] | .name'`,
-        true,
-      );
-
-      return runsJson
-        .trim()
-        .split('\n')
-        .filter(Boolean)
-        .map((name) => {
-          const workflow = new ProviderWorkflow();
-          workflow.Name = name.trim();
-
-          return workflow;
-        });
-    } catch {
-      return [];
-    }
-  }
-
-  async watchWorkflow(): Promise<string> {
-    if (!this.runId) return 'No active run to watch';
-
-    try {
-      return await OrchestratorSystem.Run(
-        `GH_TOKEN=${this.token} gh run watch ${this.runId} --repo ${this.repo}`,
-        true,
-      );
-    } catch {
-      return '';
-    }
-  }
-}
-export default GitHubActionsProvider;
--- a/src/model/orchestrator/providers/gitlab-ci/gitlab-ci-provider.test.ts
+++ b/src/model/orchestrator/providers/gitlab-ci/gitlab-ci-provider.test.ts
@@ -1,329 +0,0 @@
-import GitLabCIProvider from '.';
-import BuildParameters from '../../../build-parameters';
-import { OrchestratorSystem } from '../../services/core/orchestrator-system';
-import OrchestratorLogger from '../../services/core/orchestrator-logger';
-import * as core from '@actions/core';
-
-jest.mock('../../services/core/orchestrator-system');
-jest.mock('../../services/core/orchestrator-logger');
-jest.mock('@actions/core', () => ({
-  info: jest.fn(),
-  warning: jest.fn(),
-  error: jest.fn(),
-  setOutput: jest.fn(),
-  getInput: jest.fn(() => ''),
-}));
-
-const mockRun = OrchestratorSystem.Run as jest.MockedFunction<typeof OrchestratorSystem.Run>;
-const mockLog = OrchestratorLogger.log as jest.MockedFunction<typeof OrchestratorLogger.log>;
-const mockLogWarning = OrchestratorLogger.logWarning as jest.MockedFunction<typeof OrchestratorLogger.logWarning>;
-
-function createBuildParameters(overrides: Partial<BuildParameters> = {}): BuildParameters {
-  return {
-    gitlabProjectId: 'my-group/my-project',
-    gitlabTriggerToken: 'glptt-test-token-456',
-    gitlabApiUrl: 'https://gitlab.example.com',
-    gitlabRef: 'main',
-    ...overrides,
-  } as BuildParameters;
-}
-
-// Override setTimeout to execute callbacks immediately so polling loops complete fast
-const originalSetTimeout = global.setTimeout;
-beforeAll(() => {
-  global.setTimeout = ((fn: (...args: any[]) => void, _ms?: number, ...args: any[]) => {
-    return originalSetTimeout(fn, 0, ...args);
-  }) as any;
-});
-afterAll(() => {
-  global.setTimeout = originalSetTimeout;
-});
-
-describe('GitLabCIProvider', () => {
-  let provider: GitLabCIProvider;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    provider = new GitLabCIProvider(createBuildParameters());
-  });
-
-  describe('constructor', () => {
-    it('strips trailing slashes from apiUrl', () => {
-      const params = createBuildParameters({ gitlabApiUrl: 'https://gitlab.example.com///' });
-      const p = new GitLabCIProvider(params);
-      expect(p).toBeDefined();
-    });
-
-    it('defaults apiUrl to https://gitlab.com when not provided', () => {
-      const params = createBuildParameters({ gitlabApiUrl: undefined });
-      const p = new GitLabCIProvider(params);
-      expect(p).toBeDefined();
-    });
-
-    it('defaults ref to main when not provided', () => {
-      const params = createBuildParameters({ gitlabRef: undefined });
-      const p = new GitLabCIProvider(params);
-      expect(p).toBeDefined();
-    });
-  });
-
-  describe('setupWorkflow', () => {
-    it('verifies project access via curl and logs success', async () => {
-      mockRun.mockResolvedValueOnce('');
-
-      await provider.setupWorkflow('guid-123', createBuildParameters(), 'main', []);
-
-      expect(mockRun).toHaveBeenCalledTimes(1);
-      const command = mockRun.mock.calls[0][0];
-      expect(command).toContain('curl -sf');
-      expect(command).toContain('PRIVATE-TOKEN: glptt-test-token-456');
-      expect(command).toContain('gitlab.example.com/api/v4/projects/');
-      expect(command).toContain(encodeURIComponent('my-group/my-project'));
-      expect(mockLog).toHaveBeenCalledWith(expect.stringContaining('Project access verified'));
-    });
-
-    it('throws when projectId is not configured', async () => {
-      const params = createBuildParameters({ gitlabProjectId: '' });
-      provider = new GitLabCIProvider(params);
-
-      await expect(provider.setupWorkflow('guid-123', params, 'main', [])).rejects.toThrow(
-        'gitlabProjectId and gitlabTriggerToken are required',
-      );
-    });
-
-    it('throws when triggerToken is not configured', async () => {
-      const params = createBuildParameters({ gitlabTriggerToken: '' });
-      provider = new GitLabCIProvider(params);
-
-      await expect(provider.setupWorkflow('guid-123', params, 'main', [])).rejects.toThrow(
-        'gitlabProjectId and gitlabTriggerToken are required',
-      );
-    });
-
-    it('throws descriptive error when project access check fails', async () => {
-      mockRun.mockRejectedValueOnce(new Error('401 Unauthorized'));
-
-      await expect(provider.setupWorkflow('guid-123', createBuildParameters(), 'main', [])).rejects.toThrow(
-        'Failed to access GitLab project my-group/my-project',
-      );
-    });
-  });
-
-  describe('runTaskInWorkflow', () => {
-    it('triggers pipeline and returns job logs on success', async () => {
-      // Pipeline trigger response
-      mockRun.mockResolvedValueOnce(JSON.stringify({ id: 5001, status: 'pending' }));
-      // Status poll returns success
-      mockRun.mockResolvedValueOnce(JSON.stringify({ status: 'success' }));
-      // Jobs list
-      mockRun.mockResolvedValueOnce(
-        JSON.stringify([
-          { id: 10001, name: 'build-unity', status: 'success' },
-          { id: 10002, name: 'test-unity', status: 'success' },
-        ]),
-      );
-      // Job traces
-      mockRun.mockResolvedValueOnce('Building Unity project...\nDone.');
-      mockRun.mockResolvedValueOnce('Running tests...\nAll passed.');
-
-      const result = await provider.runTaskInWorkflow(
-        'guid-gl1',
-        'unityci/editor:2021.3',
-        'echo build',
-        '/mount',
-        '/work',
-        [],
-        [],
-      );
-
-      expect(result).toContain('build-unity');
-      expect(result).toContain('test-unity');
-      expect(result).toContain('Building Unity project');
-      expect(result).toContain('Running tests');
-
-      // Verify trigger command
-      const triggerCommand = mockRun.mock.calls[0][0];
-      expect(triggerCommand).toContain('trigger/pipeline');
-      expect(triggerCommand).toContain(`token=${createBuildParameters().gitlabTriggerToken}`);
-      expect(triggerCommand).toContain('ref=main');
-    });
-
-    it('passes build variables including base64-encoded commands', async () => {
-      mockRun.mockResolvedValueOnce(JSON.stringify({ id: 5002, status: 'success' }));
-      mockRun.mockResolvedValueOnce(JSON.stringify({ status: 'success' }));
-      mockRun.mockResolvedValueOnce(JSON.stringify([]));
-
-      await provider.runTaskInWorkflow(
-        'guid-vars',
-        'ubuntu:20.04',
-        'make build',
-        '/mnt/data',
-        '/workspace',
-        [{ name: 'UNITY_VERSION', value: '2021.3.1f1' } as any],
-        [],
-      );
-
-      const triggerCommand = mockRun.mock.calls[0][0];
-      const expectedB64 = Buffer.from('make build').toString('base64');
-      expect(triggerCommand).toContain(`variables[BUILD_COMMANDS]=${expectedB64}`);
-      expect(triggerCommand).toContain('variables[BUILD_GUID]=guid-vars');
-      expect(triggerCommand).toContain('variables[BUILD_IMAGE]=ubuntu:20.04');
-      expect(triggerCommand).toContain('variables[MOUNT_DIR]=/mnt/data');
-      expect(triggerCommand).toContain('variables[WORKING_DIR]=/workspace');
-      expect(triggerCommand).toContain('variables[UNITY_VERSION]=2021.3.1f1');
-    });
-
-    it('throws when pipeline trigger fails', async () => {
-      mockRun.mockRejectedValueOnce(new Error('404 Not Found'));
-
-      await expect(provider.runTaskInWorkflow('guid-err', 'img', 'cmd', '/m', '/w', [], [])).rejects.toThrow(
-        'Failed to trigger pipeline',
-      );
-    });
-
-    it('throws when pipeline finishes with failure status', async () => {
-      mockRun.mockResolvedValueOnce(JSON.stringify({ id: 5003, status: 'pending' }));
-      mockRun.mockResolvedValueOnce(JSON.stringify({ status: 'failed' }));
-
-      await expect(provider.runTaskInWorkflow('guid-fail', 'img', 'cmd', '/m', '/w', [], [])).rejects.toThrow(
-        'Pipeline 5003 finished with status: failed',
-      );
-    });
-
-    it('throws when pipeline is canceled', async () => {
-      mockRun.mockResolvedValueOnce(JSON.stringify({ id: 5004, status: 'pending' }));
-      mockRun.mockResolvedValueOnce(JSON.stringify({ status: 'canceled' }));
-
-      await expect(provider.runTaskInWorkflow('guid-cancel', 'img', 'cmd', '/m', '/w', [], [])).rejects.toThrow(
-        'Pipeline 5004 finished with status: canceled',
-      );
-    });
-
-    it('handles job log fetch failures gracefully', async () => {
-      mockRun.mockResolvedValueOnce(JSON.stringify({ id: 5005, status: 'success' }));
-      mockRun.mockResolvedValueOnce(JSON.stringify({ status: 'success' }));
-      mockRun.mockResolvedValueOnce(JSON.stringify([{ id: 20001, name: 'build', status: 'success' }]));
-      // Job trace fetch fails
-      mockRun.mockRejectedValueOnce(new Error('trace unavailable'));
-
-      const result = await provider.runTaskInWorkflow('guid-nologs', 'img', 'cmd', '/m', '/w', [], []);
-
-      expect(result).toContain('build');
-      expect(result).toContain('logs unavailable');
-    });
-
-    it('returns fallback message when entire job fetch fails', async () => {
-      mockRun.mockResolvedValueOnce(JSON.stringify({ id: 5006, status: 'success' }));
-      mockRun.mockResolvedValueOnce(JSON.stringify({ status: 'success' }));
-      // Jobs list fails
-      mockRun.mockRejectedValueOnce(new Error('API error'));
-
-      const result = await provider.runTaskInWorkflow('guid-noapi', 'img', 'cmd', '/m', '/w', [], []);
-
-      expect(result).toContain('Pipeline 5006 completed successfully');
-      expect(result).toContain('logs unavailable');
-    });
-
-    it('continues polling through status check errors until completion', async () => {
-      mockRun.mockResolvedValueOnce(JSON.stringify({ id: 5007, status: 'pending' }));
-      // First status check fails
-      mockRun.mockRejectedValueOnce(new Error('network blip'));
-      // Second status check succeeds
-      mockRun.mockResolvedValueOnce(JSON.stringify({ status: 'success' }));
-      // Jobs/logs
-      mockRun.mockResolvedValueOnce(JSON.stringify([]));
-
-      await provider.runTaskInWorkflow('guid-retry', 'img', 'cmd', '/m', '/w', [], []);
-
-      expect(mockLogWarning).toHaveBeenCalledWith(expect.stringContaining('Status check error'));
-    });
-
-    it('throws timeout error when polling exceeds maximum duration', async () => {
-      const realDateNow = Date.now;
-      let callCount = 0;
-
-      // Trigger pipeline succeeds
-      mockRun.mockResolvedValueOnce(JSON.stringify({ id: 5008, status: 'running' }));
-      // Status always returns running
-      mockRun.mockImplementation(() => Promise.resolve(JSON.stringify({ status: 'running' })));
-
-      // After first call, simulate 5 hours elapsed
-      Date.now = () => {
-        callCount++;
-        if (callCount <= 1) return realDateNow.call(Date);
-        return realDateNow.call(Date) + 14_400_001; // 4 hours + 1ms
-      };
-
-      try {
-        await expect(provider.runTaskInWorkflow('guid-poll-timeout', 'img', 'cmd', '/m', '/w', [], [])).rejects.toThrow(
-          'did not complete within 4 hours',
-        );
-
-        expect(core.error).toHaveBeenCalledWith(expect.stringContaining('did not complete within 4 hours'));
-      } finally {
-        Date.now = realDateNow;
-      }
-    });
-  });
-
-  describe('cleanupWorkflow', () => {
-    it('completes without error and logs cleanup message', async () => {
-      await provider.cleanupWorkflow(createBuildParameters(), 'main', []);
-      expect(mockLog).toHaveBeenCalledWith(expect.stringContaining('Cleanup complete'));
-    });
-  });
-
-  describe('garbageCollect', () => {
-    it('returns empty string (no-op)', async () => {
-      const result = await provider.garbageCollect('', false, 0, false, false);
-      expect(result).toBe('');
-    });
-  });
-
-  describe('listResources', () => {
-    it('returns empty array (not implemented)', async () => {
-      const resources = await provider.listResources();
-      expect(resources).toEqual([]);
-    });
-  });
-
-  describe('listWorkflow', () => {
-    it('returns recent pipeline names when credentials are available', async () => {
-      mockRun.mockResolvedValueOnce(
-        JSON.stringify([
-          { id: 100, status: 'success' },
-          { id: 101, status: 'failed' },
-        ]),
-      );
-
-      const workflows = await provider.listWorkflow();
-
-      expect(workflows).toHaveLength(2);
-      expect(workflows[0].Name).toBe('Pipeline #100 (success)');
-      expect(workflows[1].Name).toBe('Pipeline #101 (failed)');
-    });
-
-    it('returns empty array when credentials are missing', async () => {
-      const params = createBuildParameters({ gitlabProjectId: '' });
-      provider = new GitLabCIProvider(params);
-
-      const workflows = await provider.listWorkflow();
-      expect(workflows).toEqual([]);
-      expect(mockRun).not.toHaveBeenCalled();
-    });
-
-    it('returns empty array when API call fails', async () => {
-      mockRun.mockRejectedValueOnce(new Error('API error'));
-
-      const workflows = await provider.listWorkflow();
-      expect(workflows).toEqual([]);
-    });
-  });
-
-  describe('watchWorkflow', () => {
-    it('returns empty string (not implemented)', async () => {
-      const result = await provider.watchWorkflow();
-      expect(result).toBe('');
-    });
-  });
-});
--- a/src/model/orchestrator/providers/gitlab-ci/index.ts
+++ b/src/model/orchestrator/providers/gitlab-ci/index.ts
@@ -1,224 +0,0 @@
-import * as core from '@actions/core';
-import BuildParameters from '../../../build-parameters';
-import { OrchestratorSystem } from '../../services/core/orchestrator-system';
-import OrchestratorEnvironmentVariable from '../../options/orchestrator-environment-variable';
-import OrchestratorLogger from '../../services/core/orchestrator-logger';
-import { ProviderInterface } from '../provider-interface';
-import OrchestratorSecret from '../../options/orchestrator-secret';
-import { ProviderResource } from '../provider-resource';
-import { ProviderWorkflow } from '../provider-workflow';
-
-const MAX_POLLING_DURATION_MS = 14_400_000; // 4 hours
-
-/**
- * GitLab CI provider — triggers builds as GitLab CI pipelines
- * via the GitLab API.
- *
- * Use case: Teams using GitLab CI, hybrid GitHub/GitLab setups,
- * or GitLab runners with Unity licenses.
- */
-class GitLabCIProvider implements ProviderInterface {
-  private buildParameters: BuildParameters;
-  private projectId: string;
-  private triggerToken: string;
-  private apiUrl: string;
-  private ref: string;
-  private pipelineId: number = 0;
-
-  constructor(buildParameters: BuildParameters) {
-    this.buildParameters = buildParameters;
-    this.projectId = buildParameters.gitlabProjectId || '';
-    this.triggerToken = buildParameters.gitlabTriggerToken || '';
-    this.apiUrl = (buildParameters.gitlabApiUrl || 'https://gitlab.com').replace(/\/+$/, '');
-    this.ref = buildParameters.gitlabRef || 'main';
-  }
-
-  async setupWorkflow(
-    // eslint-disable-next-line no-unused-vars
-    buildGuid: string,
-    // eslint-disable-next-line no-unused-vars
-    buildParameters: BuildParameters,
-    // eslint-disable-next-line no-unused-vars
-    branchName: string,
-    // eslint-disable-next-line no-unused-vars
-    defaultSecretsArray: { ParameterKey: string; EnvironmentVariable: string; ParameterValue: string }[],
-  ): Promise<void> {
-    OrchestratorLogger.log(`[GitLabCI] Setting up pipeline trigger for project ${this.projectId}`);
-
-    if (!this.projectId || !this.triggerToken) {
-      throw new Error('gitlabProjectId and gitlabTriggerToken are required for the gitlab-ci provider');
-    }
-
-    // Verify project access
-    const encodedProject = encodeURIComponent(this.projectId);
-    try {
-      await OrchestratorSystem.Run(
-        `curl -sf -H "PRIVATE-TOKEN: ${this.triggerToken}" "${this.apiUrl}/api/v4/projects/${encodedProject}" -o /dev/null`,
-      );
-      OrchestratorLogger.log(`[GitLabCI] Project access verified`);
-    } catch (error: any) {
-      throw new Error(`Failed to access GitLab project ${this.projectId}: ${error.message || error}`);
-    }
-  }
-
-  async runTaskInWorkflow(
-    buildGuid: string,
-    image: string,
-    commands: string,
-    mountdir: string,
-    workingdir: string,
-    environment: OrchestratorEnvironmentVariable[],
-    // eslint-disable-next-line no-unused-vars
-    secrets: OrchestratorSecret[],
-  ): Promise<string> {
-    OrchestratorLogger.log(`[GitLabCI] Triggering pipeline on project ${this.projectId}@${this.ref}`);
-
-    const encodedProject = encodeURIComponent(this.projectId);
-
-    // Build variables for the pipeline
-    const pipelineVariables: string[] = [
-      `-f "variables[BUILD_GUID]=${buildGuid}"`,
-      `-f "variables[BUILD_IMAGE]=${image}"`,
-      `-f "variables[BUILD_COMMANDS]=${Buffer.from(commands).toString('base64')}"`,
-      `-f "variables[MOUNT_DIR]=${mountdir}"`,
-      `-f "variables[WORKING_DIR]=${workingdir}"`,
-    ];
-
-    for (const element of environment) {
-      pipelineVariables.push(`-f "variables[${element.name}]=${element.value}"`);
-    }
-
-    // Trigger pipeline
-    try {
-      const response = await OrchestratorSystem.Run(
-        `curl -sf -X POST "${this.apiUrl}/api/v4/projects/${encodedProject}/trigger/pipeline" -f "token=${
-          this.triggerToken
-        }" -f "ref=${this.ref}" ${pipelineVariables.join(' ')}`,
-      );
-
-      const pipeline = JSON.parse(response);
-      this.pipelineId = pipeline.id;
-      OrchestratorLogger.log(`[GitLabCI] Pipeline triggered: ${this.pipelineId} (status: ${pipeline.status})`);
-    } catch (error: any) {
-      throw new Error(`Failed to trigger pipeline: ${error.message || error}`);
-    }
-
-    // Poll until completion (with maximum duration guard)
-    let status = 'pending';
-    const terminalStatuses = new Set(['success', 'failed', 'canceled', 'skipped']);
-    const pollingStartTime = Date.now();
-    const pipelineUrl = `${this.apiUrl}/${this.projectId}/-/pipelines/${this.pipelineId}`;
-
-    while (!terminalStatuses.has(status)) {
-      const elapsedMs = Date.now() - pollingStartTime;
-      if (elapsedMs >= MAX_POLLING_DURATION_MS) {
-        const hours = Math.round(MAX_POLLING_DURATION_MS / 3_600_000);
-        const message = `GitLab CI pipeline did not complete within ${hours} hours. Pipeline URL: ${pipelineUrl}`;
-        core.error(message);
-        throw new Error(message);
-      }
-
-      await new Promise((resolve) => setTimeout(resolve, 15_000));
-
-      try {
-        const statusResponse = await OrchestratorSystem.Run(
-          `curl -sf -H "PRIVATE-TOKEN: ${this.triggerToken}" "${this.apiUrl}/api/v4/projects/${encodedProject}/pipelines/${this.pipelineId}"`,
-          true,
-        );
-
-        const pipelineStatus = JSON.parse(statusResponse);
-        status = pipelineStatus.status;
-        OrchestratorLogger.log(`[GitLabCI] Pipeline ${this.pipelineId} status: ${status}`);
-      } catch (error: any) {
-        OrchestratorLogger.logWarning(`[GitLabCI] Status check error: ${error.message || error}`);
-      }
-    }
-
-    if (status !== 'success') {
-      throw new Error(`Pipeline ${this.pipelineId} finished with status: ${status}`);
-    }
-
-    // Fetch job logs
-    try {
-      const jobsResponse = await OrchestratorSystem.Run(
-        `curl -sf -H "PRIVATE-TOKEN: ${this.triggerToken}" "${this.apiUrl}/api/v4/projects/${encodedProject}/pipelines/${this.pipelineId}/jobs"`,
-        true,
-      );
-
-      const jobs = JSON.parse(jobsResponse);
-      const logs: string[] = [];
-
-      for (const job of jobs) {
-        try {
-          const jobLog = await OrchestratorSystem.Run(
-            `curl -sf -H "PRIVATE-TOKEN: ${this.triggerToken}" "${this.apiUrl}/api/v4/projects/${encodedProject}/jobs/${job.id}/trace"`,
-            true,
-          );
-          logs.push(`=== Job: ${job.name} (${job.status}) ===\n${jobLog}`);
-        } catch {
-          logs.push(`=== Job: ${job.name} (${job.status}) === (logs unavailable)`);
-        }
-      }
-
-      return logs.join('\n\n');
-    } catch {
-      return `Pipeline ${this.pipelineId} completed successfully (logs unavailable)`;
-    }
-  }
-
-  async cleanupWorkflow(
-    // eslint-disable-next-line no-unused-vars
-    buildParameters: BuildParameters,
-    // eslint-disable-next-line no-unused-vars
-    branchName: string,
-    // eslint-disable-next-line no-unused-vars
-    defaultSecretsArray: { ParameterKey: string; EnvironmentVariable: string; ParameterValue: string }[],
-  ): Promise<void> {
-    OrchestratorLogger.log(`[GitLabCI] Cleanup complete`);
-  }
-
-  async garbageCollect(
-    // eslint-disable-next-line no-unused-vars
-    filter: string,
-    // eslint-disable-next-line no-unused-vars
-    previewOnly: boolean,
-    // eslint-disable-next-line no-unused-vars
-    olderThan: Number,
-    // eslint-disable-next-line no-unused-vars
-    fullCache: boolean,
-    // eslint-disable-next-line no-unused-vars
-    baseDependencies: boolean,
-  ): Promise<string> {
-    return '';
-  }
-
-  async listResources(): Promise<ProviderResource[]> {
-    return [];
-  }
-
-  async listWorkflow(): Promise<ProviderWorkflow[]> {
-    if (!this.projectId || !this.triggerToken) return [];
-
-    try {
-      const encodedProject = encodeURIComponent(this.projectId);
-      const response = await OrchestratorSystem.Run(
-        `curl -sf -H "PRIVATE-TOKEN: ${this.triggerToken}" "${this.apiUrl}/api/v4/projects/${encodedProject}/pipelines?per_page=10"`,
-        true,
-      );
-
-      return JSON.parse(response).map((pipeline: any) => {
-        const workflow = new ProviderWorkflow();
-        workflow.Name = `Pipeline #${pipeline.id} (${pipeline.status})`;
-
-        return workflow;
-      });
-    } catch {
-      return [];
-    }
-  }
-
-  async watchWorkflow(): Promise<string> {
-    return '';
-  }
-}
-export default GitLabCIProvider;
--- a/src/model/orchestrator/providers/provider-loader.ts
+++ b/src/model/orchestrator/providers/provider-loader.ts
@@ -62,6 +62,8 @@ export default async function loadProvider(
          'local-docker': './docker',
          'local-system': './local',
          local: './local',
+          'gcp-cloud-run': './gcp-cloud-run',
+          'azure-aci': './azure-aci',
        };

        modulePath = providerModuleMap[providerSource] || providerSource;
@@ -136,7 +138,7 @@ export class ProviderLoader {
   * @returns string[] - Array of available provider names
   */
  static getAvailableProviders(): string[] {
-    return ['aws', 'k8s', 'test', 'local-docker', 'local-system', 'local'];
+    return ['aws', 'k8s', 'test', 'local-docker', 'local-system', 'local', 'gcp-cloud-run', 'azure-aci'];
  }

  /**
--- a/src/model/orchestrator/providers/provider-selection.test.ts
+++ b/src/model/orchestrator/providers/provider-selection.test.ts
@@ -1,164 +0,0 @@
-import BuildParameters from '../../build-parameters';
-import RemotePowershellProvider from './remote-powershell';
-import GitHubActionsProvider from './github-actions';
-import GitLabCIProvider from './gitlab-ci';
-import AnsibleProvider from './ansible';
-
-/**
- * Tests for provider selection logic in Orchestrator.setProvider.
- *
- * These tests verify that the correct provider class is instantiated based on
- * the providerStrategy field in BuildParameters. Rather than invoking the full
- * Orchestrator.setProvider (which has heavy dependencies on OrchestratorOptions,
- * AWS detection, etc.), we test the provider constructors directly to verify
- * they produce the right provider type from the same build parameters the
- * orchestrator switch statement uses.
- */
-describe('Provider Selection', () => {
-  describe('remote-powershell provider', () => {
-    it('creates RemotePowershellProvider from build parameters', () => {
-      const params = {
-        providerStrategy: 'remote-powershell',
-        remotePowershellHost: 'build-server.local',
-        remotePowershellTransport: 'wsman',
-        remotePowershellCredential: 'user:pass',
-      } as BuildParameters;
-
-      const provider = new RemotePowershellProvider(params);
-
-      expect(provider).toBeInstanceOf(RemotePowershellProvider);
-      expect(provider.constructor.name).toBe('RemotePowershellProvider');
-    });
-  });
-
-  describe('github-actions provider', () => {
-    it('creates GitHubActionsProvider from build parameters', () => {
-      const params = {
-        providerStrategy: 'github-actions',
-        githubActionsRepo: 'org/repo',
-        githubActionsWorkflow: 'ci.yml',
-        githubActionsToken: 'ghp_token',
-        githubActionsRef: 'main',
-      } as BuildParameters;
-
-      const provider = new GitHubActionsProvider(params);
-
-      expect(provider).toBeInstanceOf(GitHubActionsProvider);
-      expect(provider.constructor.name).toBe('GitHubActionsProvider');
-    });
-  });
-
-  describe('gitlab-ci provider', () => {
-    it('creates GitLabCIProvider from build parameters', () => {
-      const params = {
-        providerStrategy: 'gitlab-ci',
-        gitlabProjectId: 'group/project',
-        gitlabTriggerToken: 'glptt-token',
-        gitlabApiUrl: 'https://gitlab.com',
-        gitlabRef: 'main',
-      } as BuildParameters;
-
-      const provider = new GitLabCIProvider(params);
-
-      expect(provider).toBeInstanceOf(GitLabCIProvider);
-      expect(provider.constructor.name).toBe('GitLabCIProvider');
-    });
-  });
-
-  describe('ansible provider', () => {
-    it('creates AnsibleProvider from build parameters', () => {
-      const params = {
-        providerStrategy: 'ansible',
-        ansibleInventory: '/etc/ansible/hosts',
-        ansiblePlaybook: '/playbooks/build.yml',
-        ansibleExtraVars: '',
-        ansibleVaultPassword: '',
-      } as BuildParameters;
-
-      const provider = new AnsibleProvider(params);
-
-      expect(provider).toBeInstanceOf(AnsibleProvider);
-      expect(provider.constructor.name).toBe('AnsibleProvider');
-    });
-  });
-
-  describe('provider strategy routing', () => {
-    it('each provider strategy maps to a distinct provider class', () => {
-      const strategies: Record<string, new (params: BuildParameters) => any> = {
-        'remote-powershell': RemotePowershellProvider,
-        'github-actions': GitHubActionsProvider,
-        'gitlab-ci': GitLabCIProvider,
-        ansible: AnsibleProvider,
-      };
-
-      const params = {
-        remotePowershellHost: 'host',
-        remotePowershellTransport: 'wsman',
-        remotePowershellCredential: '',
-        githubActionsRepo: 'org/repo',
-        githubActionsWorkflow: 'ci.yml',
-        githubActionsToken: 'token',
-        githubActionsRef: 'main',
-        gitlabProjectId: 'proj',
-        gitlabTriggerToken: 'tok',
-        gitlabApiUrl: 'https://gitlab.com',
-        gitlabRef: 'main',
-        ansibleInventory: '/inv',
-        ansiblePlaybook: '/pb.yml',
-        ansibleExtraVars: '',
-        ansibleVaultPassword: '',
-      } as BuildParameters;
-
-      const instances = Object.entries(strategies).map(([strategy, ProviderClass]) => {
-        const provider = new ProviderClass(params);
-        return { strategy, className: provider.constructor.name };
-      });
-
-      // Verify all four strategies produce different provider classes
-      const classNames = instances.map((i) => i.className);
-      const uniqueClassNames = new Set(classNames);
-      expect(uniqueClassNames.size).toBe(4);
-
-      // Verify expected mapping
-      expect(instances.find((i) => i.strategy === 'remote-powershell')!.className).toBe('RemotePowershellProvider');
-      expect(instances.find((i) => i.strategy === 'github-actions')!.className).toBe('GitHubActionsProvider');
-      expect(instances.find((i) => i.strategy === 'gitlab-ci')!.className).toBe('GitLabCIProvider');
-      expect(instances.find((i) => i.strategy === 'ansible')!.className).toBe('AnsibleProvider');
-    });
-
-    it('all providers implement ProviderInterface methods', () => {
-      const params = {
-        remotePowershellHost: 'host',
-        githubActionsRepo: 'org/repo',
-        githubActionsWorkflow: 'ci.yml',
-        githubActionsToken: 'token',
-        gitlabProjectId: 'proj',
-        gitlabTriggerToken: 'tok',
-        ansibleInventory: '/inv',
-      } as BuildParameters;
-
-      const providers = [
-        new RemotePowershellProvider(params),
-        new GitHubActionsProvider(params),
-        new GitLabCIProvider(params),
-        new AnsibleProvider(params),
-      ];
-
-      const requiredMethods = [
-        'setupWorkflow',
-        'runTaskInWorkflow',
-        'cleanupWorkflow',
-        'garbageCollect',
-        'listResources',
-        'listWorkflow',
-        'watchWorkflow',
-      ];
-
-      for (const provider of providers) {
-        for (const method of requiredMethods) {
-          expect(typeof (provider as any)[method]).toBe('function');
-        }
-      }
-    });
-  });
-});
--- a/src/model/orchestrator/providers/remote-powershell/index.ts
+++ b/src/model/orchestrator/providers/remote-powershell/index.ts
@@ -1,166 +0,0 @@
-import BuildParameters from '../../../build-parameters';
-import { OrchestratorSystem } from '../../services/core/orchestrator-system';
-import OrchestratorEnvironmentVariable from '../../options/orchestrator-environment-variable';
-import OrchestratorLogger from '../../services/core/orchestrator-logger';
-import { ProviderInterface } from '../provider-interface';
-import OrchestratorSecret from '../../options/orchestrator-secret';
-import { ProviderResource } from '../provider-resource';
-import { ProviderWorkflow } from '../provider-workflow';
-
-/**
- * Remote PowerShell provider — executes Unity builds on remote machines
- * via PowerShell Remoting (WinRM or SSH).
- *
- * Use case: Teams with dedicated build machines not part of a CI system.
- */
-class RemotePowershellProvider implements ProviderInterface {
-  private buildParameters: BuildParameters;
-  private host: string;
-  private transport: string;
-  private credential: string;
-  private sessionId: string = '';
-
-  constructor(buildParameters: BuildParameters) {
-    this.buildParameters = buildParameters;
-    this.host = buildParameters.remotePowershellHost || '';
-    this.transport = buildParameters.remotePowershellTransport || 'wsman';
-    this.credential = buildParameters.remotePowershellCredential || '';
-  }
-
-  async setupWorkflow(
-    buildGuid: string,
-    // eslint-disable-next-line no-unused-vars
-    buildParameters: BuildParameters,
-    // eslint-disable-next-line no-unused-vars
-    branchName: string,
-    // eslint-disable-next-line no-unused-vars
-    defaultSecretsArray: { ParameterKey: string; EnvironmentVariable: string; ParameterValue: string }[],
-  ): Promise<void> {
-    OrchestratorLogger.log(`[RemotePowershell] Setting up remote session to ${this.host} via ${this.transport}`);
-
-    if (!this.host) {
-      throw new Error('remotePowershellHost is required for the remote-powershell provider');
-    }
-
-    // Test connectivity
-    const testCommand = this.buildPwshCommand(`Test-WSMan -ComputerName "${this.host}" -ErrorAction Stop`);
-    try {
-      await OrchestratorSystem.Run(testCommand);
-      OrchestratorLogger.log(`[RemotePowershell] Connection test passed`);
-    } catch (error: any) {
-      throw new Error(`Failed to connect to remote host ${this.host}: ${error.message || error}`);
-    }
-
-    this.sessionId = buildGuid;
-    OrchestratorLogger.log(`[RemotePowershell] Session ${this.sessionId} ready`);
-  }
-
-  async runTaskInWorkflow(
-    buildGuid: string,
-    image: string,
-    commands: string,
-    mountdir: string,
-    workingdir: string,
-    environment: OrchestratorEnvironmentVariable[],
-    secrets: OrchestratorSecret[],
-  ): Promise<string> {
-    OrchestratorLogger.log(`[RemotePowershell] Executing task on ${this.host}`);
-
-    // Build environment variable block for remote session
-    const environmentBlock = environment.map((element) => `$env:${element.name} = '${element.value}'`).join('; ');
-
-    const secretBlock = secrets
-      .map((secret) => `$env:${secret.EnvironmentVariable} = '${secret.ParameterValue}'`)
-      .join('; ');
-
-    // Wrap commands for remote execution
-    const remoteScript = [environmentBlock, secretBlock, `Set-Location "${workingdir}"`, commands]
-      .filter(Boolean)
-      .join('; ');
-
-    const invokeCommand = this.buildInvokeCommand(remoteScript);
-
-    try {
-      const output = await OrchestratorSystem.Run(invokeCommand);
-      OrchestratorLogger.log(`[RemotePowershell] Task completed successfully`);
-
-      return output;
-    } catch (error: any) {
-      OrchestratorLogger.logWarning(`[RemotePowershell] Task failed: ${error.message || error}`);
-      throw error;
-    }
-  }
-
-  async cleanupWorkflow(
-    // eslint-disable-next-line no-unused-vars
-    buildParameters: BuildParameters,
-    // eslint-disable-next-line no-unused-vars
-    branchName: string,
-    // eslint-disable-next-line no-unused-vars
-    defaultSecretsArray: { ParameterKey: string; EnvironmentVariable: string; ParameterValue: string }[],
-  ): Promise<void> {
-    OrchestratorLogger.log(`[RemotePowershell] Cleaning up session ${this.sessionId}`);
-
-    // Remote sessions are stateless per invocation — no cleanup needed
-  }
-
-  async garbageCollect(
-    // eslint-disable-next-line no-unused-vars
-    filter: string,
-    // eslint-disable-next-line no-unused-vars
-    previewOnly: boolean,
-    // eslint-disable-next-line no-unused-vars
-    olderThan: Number,
-    // eslint-disable-next-line no-unused-vars
-    fullCache: boolean,
-    // eslint-disable-next-line no-unused-vars
-    baseDependencies: boolean,
-  ): Promise<string> {
-    OrchestratorLogger.log(`[RemotePowershell] Garbage collection not supported for remote PowerShell provider`);
-
-    return '';
-  }
-
-  async listResources(): Promise<ProviderResource[]> {
-    const resource = new ProviderResource();
-    resource.Name = this.host;
-
-    return [resource];
-  }
-
-  async listWorkflow(): Promise<ProviderWorkflow[]> {
-    return [];
-  }
-
-  async watchWorkflow(): Promise<string> {
-    return '';
-  }
-
-  private buildPwshCommand(script: string): string {
-    return `pwsh -NoProfile -NonInteractive -Command "${script.replace(/"/g, '\\"')}"`;
-  }
-
-  private buildInvokeCommand(remoteScript: string): string {
-    const escapedScript = remoteScript.replace(/"/g, '\\"').replace(/'/g, "''");
-
-    if (this.transport === 'ssh') {
-      return `pwsh -NoProfile -NonInteractive -Command "Invoke-Command -HostName '${this.host}' -ScriptBlock { ${escapedScript} }"`;
-    }
-
-    // WinRM (default)
-    // Split on the FIRST colon only — passwords may contain colons
-    let credentialPart = '';
-    if (this.credential) {
-      const colonIndex = this.credential.indexOf(':');
-      if (colonIndex === -1) {
-        throw new Error('remotePowershellCredential must be in "username:password" format (no colon found)');
-      }
-      const user = this.credential.substring(0, colonIndex);
-      const pass = this.credential.substring(colonIndex + 1);
-      credentialPart = `-Credential (New-Object PSCredential('${user}', (ConvertTo-SecureString '${pass}' -AsPlainText -Force)))`;
-    }
-
-    return `pwsh -NoProfile -NonInteractive -Command "Invoke-Command -ComputerName '${this.host}' ${credentialPart} -ScriptBlock { ${escapedScript} }"`;
-  }
-}
-export default RemotePowershellProvider;
--- a/src/model/orchestrator/providers/remote-powershell/remote-powershell-provider.test.ts
+++ b/src/model/orchestrator/providers/remote-powershell/remote-powershell-provider.test.ts
@@ -1,264 +0,0 @@
-import RemotePowershellProvider from '.';
-import BuildParameters from '../../../build-parameters';
-import { OrchestratorSystem } from '../../services/core/orchestrator-system';
-import OrchestratorLogger from '../../services/core/orchestrator-logger';
-
-jest.mock('../../services/core/orchestrator-system');
-jest.mock('../../services/core/orchestrator-logger');
-
-const mockRun = OrchestratorSystem.Run as jest.MockedFunction<typeof OrchestratorSystem.Run>;
-const mockLog = OrchestratorLogger.log as jest.MockedFunction<typeof OrchestratorLogger.log>;
-const mockLogWarning = OrchestratorLogger.logWarning as jest.MockedFunction<typeof OrchestratorLogger.logWarning>;
-
-function createBuildParameters(overrides: Partial<BuildParameters> = {}): BuildParameters {
-  return {
-    remotePowershellHost: 'build-server-01.internal',
-    remotePowershellTransport: 'wsman',
-    remotePowershellCredential: 'admin:P@ssw0rd!',
-    ...overrides,
-  } as BuildParameters;
-}
-
-describe('RemotePowershellProvider', () => {
-  let provider: RemotePowershellProvider;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    provider = new RemotePowershellProvider(createBuildParameters());
-  });
-
-  describe('constructor', () => {
-    it('defaults transport to wsman when not specified', () => {
-      const params = createBuildParameters({ remotePowershellTransport: undefined });
-      const p = new RemotePowershellProvider(params);
-      expect(p).toBeDefined();
-    });
-
-    it('accepts ssh transport', () => {
-      const params = createBuildParameters({ remotePowershellTransport: 'ssh' });
-      const p = new RemotePowershellProvider(params);
-      expect(p).toBeDefined();
-    });
-  });
-
-  describe('setupWorkflow', () => {
-    it('tests WinRM connectivity via Test-WSMan and logs success', async () => {
-      mockRun.mockResolvedValueOnce('wsman output');
-
-      await provider.setupWorkflow('guid-123', createBuildParameters(), 'main', []);
-
-      expect(mockRun).toHaveBeenCalledTimes(1);
-      const command = mockRun.mock.calls[0][0];
-      expect(command).toContain('pwsh -NoProfile -NonInteractive');
-      expect(command).toContain('Test-WSMan');
-      expect(command).toContain('build-server-01.internal');
-      expect(mockLog).toHaveBeenCalledWith(expect.stringContaining('Connection test passed'));
-    });
-
-    it('sets session ID to the build GUID', async () => {
-      mockRun.mockResolvedValueOnce('');
-
-      await provider.setupWorkflow('my-build-guid', createBuildParameters(), 'main', []);
-
-      expect(mockLog).toHaveBeenCalledWith(expect.stringContaining('my-build-guid'));
-      expect(mockLog).toHaveBeenCalledWith(expect.stringContaining('ready'));
-    });
-
-    it('throws when host is not configured', async () => {
-      const params = createBuildParameters({ remotePowershellHost: '' });
-      provider = new RemotePowershellProvider(params);
-
-      await expect(provider.setupWorkflow('guid-123', params, 'main', [])).rejects.toThrow(
-        'remotePowershellHost is required',
-      );
-    });
-
-    it('throws descriptive error when connectivity test fails', async () => {
-      mockRun.mockRejectedValueOnce(new Error('WinRM service not running'));
-
-      await expect(provider.setupWorkflow('guid-123', createBuildParameters(), 'main', [])).rejects.toThrow(
-        'Failed to connect to remote host build-server-01.internal',
-      );
-    });
-  });
-
-  describe('runTaskInWorkflow', () => {
-    it('constructs WinRM Invoke-Command with credential and returns output', async () => {
-      mockRun.mockResolvedValueOnce('Build succeeded!');
-
-      const result = await provider.runTaskInWorkflow(
-        'guid-run1',
-        'unused-image',
-        'Unity.exe -batchmode -buildTarget Win64',
-        '/mount',
-        'C:\\Projects\\MyGame',
-        [],
-        [],
-      );
-
-      expect(result).toBe('Build succeeded!');
-
-      const command = mockRun.mock.calls[0][0];
-      expect(command).toContain('pwsh -NoProfile -NonInteractive');
-      expect(command).toContain("Invoke-Command -ComputerName 'build-server-01.internal'");
-      expect(command).toContain('-Credential');
-      expect(command).toContain('New-Object PSCredential');
-      expect(command).toContain('-ScriptBlock');
-      expect(command).toContain('Set-Location');
-    });
-
-    it('constructs SSH Invoke-Command when transport is ssh', async () => {
-      const params = createBuildParameters({ remotePowershellTransport: 'ssh' });
-      provider = new RemotePowershellProvider(params);
-      mockRun.mockResolvedValueOnce('SSH build output');
-
-      const result = await provider.runTaskInWorkflow('guid-ssh', 'img', 'build', '/m', '/w', [], []);
-
-      expect(result).toBe('SSH build output');
-
-      const command = mockRun.mock.calls[0][0];
-      expect(command).toContain("Invoke-Command -HostName 'build-server-01.internal'");
-      expect(command).not.toContain('-ComputerName');
-      expect(command).not.toContain('-Credential');
-    });
-
-    it('includes environment variables in the remote script block', async () => {
-      mockRun.mockResolvedValueOnce('output');
-
-      const env = [
-        { name: 'UNITY_LICENSE', value: 'license-data-abc' },
-        { name: 'BUILD_TARGET', value: 'StandaloneWindows64' },
-      ];
-
-      await provider.runTaskInWorkflow('guid-env', 'img', 'build-cmd', '/m', '/w', env as any, []);
-
-      const command = mockRun.mock.calls[0][0];
-      expect(command).toContain('$env:UNITY_LICENSE');
-      expect(command).toContain('$env:BUILD_TARGET');
-    });
-
-    it('includes secrets in the remote script block', async () => {
-      mockRun.mockResolvedValueOnce('output');
-
-      const secrets = [{ ParameterKey: 'key1', EnvironmentVariable: 'SECRET_KEY', ParameterValue: 'secret-val-123' }];
-
-      await provider.runTaskInWorkflow('guid-sec', 'img', 'build-cmd', '/m', '/w', [], secrets as any);
-
-      const command = mockRun.mock.calls[0][0];
-      expect(command).toContain('$env:SECRET_KEY');
-    });
-
-    it('does not include credential in plaintext log output when using WinRM', async () => {
-      mockRun.mockResolvedValueOnce('output');
-
-      await provider.runTaskInWorkflow('guid-cred', 'img', 'cmd', '/m', '/w', [], []);
-
-      // The credential is used via ConvertTo-SecureString, not logged directly
-      const command = mockRun.mock.calls[0][0];
-      expect(command).toContain('ConvertTo-SecureString');
-      expect(command).toContain('-AsPlainText -Force');
-    });
-
-    it('omits credential part when no credential is configured (WinRM)', async () => {
-      const params = createBuildParameters({ remotePowershellCredential: '' });
-      provider = new RemotePowershellProvider(params);
-      mockRun.mockResolvedValueOnce('output');
-
-      await provider.runTaskInWorkflow('guid-nocred', 'img', 'cmd', '/m', '/w', [], []);
-
-      const command = mockRun.mock.calls[0][0];
-      expect(command).toContain("Invoke-Command -ComputerName 'build-server-01.internal'");
-      expect(command).not.toContain('-Credential');
-      expect(command).not.toContain('PSCredential');
-    });
-
-    it('throws and logs warning when remote execution fails', async () => {
-      const execError = new Error('Remote execution failed: access denied');
-      mockRun.mockRejectedValueOnce(execError);
-
-      await expect(provider.runTaskInWorkflow('guid-fail', 'img', 'cmd', '/m', '/w', [], [])).rejects.toThrow(
-        'Remote execution failed',
-      );
-
-      expect(mockLogWarning).toHaveBeenCalledWith(expect.stringContaining('Task failed'));
-    });
-
-    it('preserves passwords containing colons when splitting credentials', async () => {
-      const params = createBuildParameters({
-        remotePowershellCredential: 'admin:P@ss:w0rd:with:colons!',
-      });
-      provider = new RemotePowershellProvider(params);
-      mockRun.mockResolvedValueOnce('output');
-
-      await provider.runTaskInWorkflow('guid-colon', 'img', 'cmd', '/m', '/w', [], []);
-
-      const command = mockRun.mock.calls[0][0];
-      expect(command).toContain("PSCredential('admin'");
-      expect(command).toContain("ConvertTo-SecureString 'P@ss:w0rd:with:colons!'");
-    });
-
-    it('throws when credential has no colon separator', async () => {
-      const params = createBuildParameters({
-        remotePowershellCredential: 'nocolonhere',
-      });
-      provider = new RemotePowershellProvider(params);
-
-      await expect(provider.runTaskInWorkflow('guid-badcred', 'img', 'cmd', '/m', '/w', [], [])).rejects.toThrow(
-        'username:password',
-      );
-    });
-
-    it('sets working directory in the remote script', async () => {
-      mockRun.mockResolvedValueOnce('output');
-
-      await provider.runTaskInWorkflow('guid-wd', 'img', 'cmd', '/m', 'D:\\Builds\\Project', [], []);
-
-      const command = mockRun.mock.calls[0][0];
-      expect(command).toContain('Set-Location');
-      expect(command).toContain('D:\\Builds\\Project');
-    });
-  });
-
-  describe('cleanupWorkflow', () => {
-    it('completes without error and logs session cleanup', async () => {
-      // Setup first to set sessionId
-      mockRun.mockResolvedValueOnce('');
-      await provider.setupWorkflow('guid-cleanup', createBuildParameters(), 'main', []);
-
-      await provider.cleanupWorkflow(createBuildParameters(), 'main', []);
-
-      expect(mockLog).toHaveBeenCalledWith(expect.stringContaining('Cleaning up session'));
-    });
-  });
-
-  describe('garbageCollect', () => {
-    it('returns empty string and logs not-supported message', async () => {
-      const result = await provider.garbageCollect('', false, 0, false, false);
-      expect(result).toBe('');
-      expect(mockLog).toHaveBeenCalledWith(expect.stringContaining('not supported'));
-    });
-  });
-
-  describe('listResources', () => {
-    it('returns the configured host as a resource', async () => {
-      const resources = await provider.listResources();
-
-      expect(resources).toHaveLength(1);
-      expect(resources[0].Name).toBe('build-server-01.internal');
-    });
-  });
-
-  describe('listWorkflow', () => {
-    it('returns empty array (not implemented)', async () => {
-      const workflows = await provider.listWorkflow();
-      expect(workflows).toEqual([]);
-    });
-  });
-
-  describe('watchWorkflow', () => {
-    it('returns empty string (not implemented)', async () => {
-      const result = await provider.watchWorkflow();
-      expect(result).toBe('');
-    });
-  });
-});
Author	SHA1	Message	Date
frostebite	c5fd895bd6	fix: replace orchestrator-develop branch references with main The orchestrator-develop branch no longer exists. Update all fallback clone commands and test fixtures to use main instead. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-09 20:09:49 +00:00
frostebite	302a250b3d	ci: set macOS builds to continue-on-error Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-05 23:34:08 +00:00
frostebite	d17b099593	style: format changed files with prettier Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-05 07:52:11 +00:00
frostebite	f4bc5d20c4	feat(orchestrator): multi-storage support for GCP and Azure providers Both providers now support four storage backends via gcpStorageType / azureStorageType: GCP Cloud Run: - gcs-fuse: Mount GCS bucket as POSIX filesystem (unlimited, best for large sequential I/O) - gcs-copy: Copy artifacts in/out via gsutil (simpler, no FUSE overhead) - nfs: Filestore NFS mount (true POSIX, good random I/O, up to 100 TiB) - in-memory: tmpfs (fastest, volatile, up to 32 GiB) Azure ACI: - azure-files: SMB file share mount (up to 100 TiB, premium throughput) - blob-copy: Copy artifacts in/out via az storage blob (no mount overhead) - azure-files-nfs: NFS 4.1 file share mount (true POSIX, no SMB lock overhead) - in-memory: emptyDir tmpfs (fastest, volatile, limited by container memory) New inputs: gcpStorageType, gcpFilestoreIp, gcpFilestoreShare, azureStorageType, azureBlobContainer. Constructor validates storage config and warns on missing prerequisites (e.g. NFS requires VPC connector/subnet). Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-05 07:07:20 +00:00
frostebite	d8563369e1	feat(orchestrator): add experimental GCP Cloud Run and Azure ACI providers Add two new cloud provider implementations for the orchestrator, both marked as experimental: - GCP Cloud Run Jobs (`providerStrategy: gcp-cloud-run`): Executes Unity builds as Cloud Run Jobs with GCS FUSE for large artifact storage. Supports configurable machine types, service accounts, and VPC connectors. 7 new inputs (gcpProject, gcpRegion, gcpBucket, gcpMachineType, gcpDiskSizeGb, gcpServiceAccount, gcpVpcConnector). - Azure Container Instances (`providerStrategy: azure-aci`): Executes Unity builds as ACI containers with Azure File Shares (Premium FileStorage) for large artifact storage up to 100 TiB. Supports configurable CPU/memory, VNet integration, and subscription targeting. 9 new inputs (azureResourceGroup, azureLocation, azureStorageAccount, azureFileShareName, azureSubscriptionId, azureCpu, azureMemoryGb, azureDiskSizeGb, azureSubnetId). Both providers use their respective CLIs (gcloud, az) for infrastructure management and support garbage collection of old build resources. No tests included as these require real cloud infrastructure to validate. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-05 07:00:09 +00:00