diff --git a/ProcessMaker/Http/Controllers/Api/EnvironmentVariablesController.php b/ProcessMaker/Http/Controllers/Api/EnvironmentVariablesController.php
index b599f49795..ffd892d65d 100644
--- a/ProcessMaker/Http/Controllers/Api/EnvironmentVariablesController.php
+++ b/ProcessMaker/Http/Controllers/Api/EnvironmentVariablesController.php
@@ -104,10 +104,15 @@ public function index(Request $request)
      */
     public function store(Request $request)
     {
-        $request->validate(EnvironmentVariable::rules(), EnvironmentVariable::messages());
-        $environment_variable = EnvironmentVariable::create($request->all());
+        $data = $this->prepareAssetLinkInput($request->all());
+        validator($data, EnvironmentVariable::rules(), EnvironmentVariable::messages())->validate();
+        $linkedAsset = EnvironmentVariable::validateAssetLinkConsistency($data);
+        if ($linkedAsset) {
+            $data['value'] = (string) $linkedAsset->id;
+        }
+        $environment_variable = EnvironmentVariable::create($data);
         // Register the Event
-        EnvironmentVariablesCreated::dispatch($request->all());
+        EnvironmentVariablesCreated::dispatch($data);
 
         return new EnvironmentVariableResource($environment_variable);
     }
@@ -172,14 +177,22 @@ public function show(EnvironmentVariable $environment_variable)
      */
     public function update(EnvironmentVariable $environment_variable, Request $request)
     {
-        $fields = ['name', 'description'];
-        if ($request->filled('value')) {
+        $data = $this->prepareAssetLinkInput($request->all());
+        // Validate the request, passing in the existing variable to tweak unique rule on name
+        validator($data, EnvironmentVariable::rules($environment_variable), EnvironmentVariable::messages())->validate();
+        $linkedAsset = EnvironmentVariable::validateAssetLinkConsistency($data);
+
+        $fields = ['name', 'description', 'asset_type', 'do_not_update'];
+        if ($linkedAsset) {
+            // Guarantee value is always the selected asset's ID on this instance.
+            $data['value'] = (string) $linkedAsset->id;
+            $fields[] = 'value';
+        } elseif (array_key_exists('value', $data) && $data['value'] !== null && $data['value'] !== '') {
             $fields[] = 'value';
         }
-        // Validate the request, passing in the existing variable to tweak unique rule on name
-        $request->validate(EnvironmentVariable::rules($environment_variable));
+
         $original = $environment_variable->getOriginal();
-        $environment_variable->fill($request->only($fields));
+        $environment_variable->fill(collect($data)->only($fields)->all());
         $environment_variable->save();
 
         $changes = $environment_variable->getChanges();
@@ -190,6 +203,18 @@ public function update(EnvironmentVariable $environment_variable, Request $reque
         return new EnvironmentVariableResource($environment_variable);
     }
 
+    /**
+     * Normalize empty asset_type to null.
+     */
+    private function prepareAssetLinkInput(array $data): array
+    {
+        if (array_key_exists('asset_type', $data) && $data['asset_type'] === '') {
+            $data['asset_type'] = null;
+        }
+
+        return $data;
+    }
+
     /**
      * @OA\Delete(
      *     path="/environment_variables/{environment_variable_id}",
diff --git a/ProcessMaker/ImportExport/DependentType.php b/ProcessMaker/ImportExport/DependentType.php
index acd2db4e9b..f5000fe6a9 100644
--- a/ProcessMaker/ImportExport/DependentType.php
+++ b/ProcessMaker/ImportExport/DependentType.php
@@ -22,6 +22,8 @@ abstract class DependentType
 
     const ENVIRONMENT_VARIABLE_VALUE = 'environment_variables_value';
 
+    const ENVIRONMENT_VARIABLE_ASSET = 'environment_variable_asset';
+
     const SCRIPT_EXECUTORS = 'script_executors';
 
     const SUB_PROCESSES = 'sub_processes';
diff --git a/ProcessMaker/ImportExport/Exporters/EnvironmentVariableExporter.php b/ProcessMaker/ImportExport/Exporters/EnvironmentVariableExporter.php
index 2161c90b46..ed1637ad45 100644
--- a/ProcessMaker/ImportExport/Exporters/EnvironmentVariableExporter.php
+++ b/ProcessMaker/ImportExport/Exporters/EnvironmentVariableExporter.php
@@ -2,7 +2,13 @@
 
 namespace ProcessMaker\ImportExport\Exporters;
 
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Support\Facades\Log;
+use ProcessMaker\Enums\ExporterMap;
 use ProcessMaker\ImportExport\DependentType;
+use ProcessMaker\ImportExport\Manifest;
+use ProcessMaker\ImportExport\Options;
+use ProcessMaker\ImportExport\Psudomodels\Psudomodel;
 
 class EnvironmentVariableExporter extends ExporterBase
 {
@@ -14,13 +20,75 @@ class EnvironmentVariableExporter extends ExporterBase
 
     public $incrementStringSeparator = '_';
 
+    public function __construct(
+        Model|Psudomodel|null $model,
+        Manifest $manifest,
+        Options $options,
+        $ignoreExplicitDiscard
+    ) {
+        parent::__construct($model, $manifest, $options, $ignoreExplicitDiscard);
+
+        // PHP does not allow closures as property defaults.
+        $this->discard = fn ($envVar) => (bool) ($envVar->do_not_update ?? false);
+    }
+
     public function export() : void
     {
         $this->addReference(DependentType::ENVIRONMENT_VARIABLE_VALUE, $this->model->value);
+
+        if (!$this->model->hasLinkedAsset()) {
+            return;
+        }
+
+        $asset = $this->model->resolveLinkedAsset();
+        if (!$asset) {
+            Log::warning('EnvironmentVariableExporter: linked asset not found during export', [
+                'environment_variable' => $this->model->name,
+                'asset_type' => $this->model->asset_type,
+                'value' => $this->model->value,
+            ]);
+
+            return;
+        }
+
+        $exporterClass = ExporterMap::getExporterClassForModel($asset);
+        if (!$exporterClass) {
+            Log::warning('EnvironmentVariableExporter: no exporter registered for linked asset', [
+                'environment_variable' => $this->model->name,
+                'asset_type' => $this->model->asset_type,
+            ]);
+
+            return;
+        }
+
+        $this->addDependent(DependentType::ENVIRONMENT_VARIABLE_ASSET, $asset, $exporterClass);
     }
 
     public function import() : bool
     {
+        foreach ($this->getDependents(DependentType::ENVIRONMENT_VARIABLE_ASSET, true) as $dependent) {
+            $asset = $dependent->model;
+            if ($asset && $asset->exists) {
+                $this->model->asset_type = get_class($asset);
+                $this->model->value = (string) $asset->id;
+
+                return $this->model->save();
+            }
+        }
+
+        if ($this->model->asset_type) {
+            // Linked in source, but asset was not imported and was not found on target.
+            $this->logger?->addWarning(__(
+                'Asset linked to environment variable ":env_variable" was missing on import; link and value were cleared',
+                ['env_variable' => $this->model->name]
+            ));
+            $this->model->asset_type = null;
+            $this->model->value = '';
+
+            return $this->model->save();
+        }
+
+        // Standard case (non-linked) env var: restore secret/value from export.
         $this->model->value = $this->getReference(DependentType::ENVIRONMENT_VARIABLE_VALUE);
 
         return $this->model->save();
diff --git a/ProcessMaker/ImportExport/Exporters/ExporterBase.php b/ProcessMaker/ImportExport/Exporters/ExporterBase.php
index f4ac9c4d90..e951581bee 100644
--- a/ProcessMaker/ImportExport/Exporters/ExporterBase.php
+++ b/ProcessMaker/ImportExport/Exporters/ExporterBase.php
@@ -47,6 +47,12 @@ abstract class ExporterBase implements ExporterInterface
 
     public $hidden = false;
 
+    /**
+     * When true (or a callable returning true), this asset is explicitly discarded.
+     * Callables receive the model: fn (Model $model): bool
+     *
+     * @var bool|callable
+     */
     public $discard = false;
 
     public static $forceUpdate = false;
@@ -135,7 +141,7 @@ public function uuid() : string
 
     public function include() : bool
     {
-        if ($this->discard) { // Explicit Discard (not from passed-in options)
+        if ($this->isExplicitlyDiscarded()) { // Explicit Discard (not from passed-in options)
             if (!$this->ignoreExplicitDiscard) {
                 return false;
             }
@@ -148,6 +154,40 @@ public function include() : bool
         return true;
     }
 
+    /**
+     * Resolve $discard whether it is a boolean or a callable checked against the model.
+     */
+    public function isExplicitlyDiscarded(): bool
+    {
+        if (is_callable($this->discard)) {
+            return (bool) ($this->discard)($this->model);
+        }
+
+        return (bool) $this->discard;
+    }
+
+    /**
+     * Import-time check: should an existing target model be discarded (not overwritten)?
+     *
+     * Only callables are evaluated here. Boolean `$discard = true` (Users/Groups) is an
+     * export-time flag handled by include(), not an import-time skip.
+     * Psudomodels (e.g. Signal) are never discarded by this path.
+     */
+    public static function shouldDiscardExistingModelDuringImport(Model|Psudomodel|null $model): bool
+    {
+        if (!$model instanceof Model || !$model->exists) {
+            return false;
+        }
+
+        $exporter = new static($model, new Manifest(), new Options([]), false);
+
+        if (!is_callable($exporter->discard)) {
+            return false;
+        }
+
+        return (bool) ($exporter->discard)($model);
+    }
+
     public function addDependent(string $type, Model|Psudomodel $dependentModel, string $exporterClass, $meta = null)
     {
         $uuid = $dependentModel->uuid;
@@ -304,7 +344,7 @@ public function toArray()
             'hidden' => $this->hidden,
             'mode' => $this->mode,
             'saveAssetsMode' => $this->saveAssetsMode,
-            'explicit_discard' => $this->discard,
+            'explicit_discard' => $this->isExplicitlyDiscarded(),
             'dependents' => array_map(fn ($d) => $d->toArray(), $this->dependents),
             'name' => $this->getName($this->model),
             'description' => $this->getDescription(),
diff --git a/ProcessMaker/ImportExport/Manifest.php b/ProcessMaker/ImportExport/Manifest.php
index 494d3197b5..ac5372b777 100644
--- a/ProcessMaker/ImportExport/Manifest.php
+++ b/ProcessMaker/ImportExport/Manifest.php
@@ -158,6 +158,11 @@ public static function getModel($uuid, $assetInfo, $mode, $exporterClass, $isRoo
             $mode = 'discard';
         }
 
+        // Per-asset explicit discard (e.g. env vars with do_not_update on the target).
+        if ($model && $exporterClass::shouldDiscardExistingModelDuringImport($model)) {
+            $mode = 'discard';
+        }
+
         if ($exporterClass::$forceUpdate) {
             $mode = 'update';
         }
diff --git a/ProcessMaker/Models/EnvironmentVariable.php b/ProcessMaker/Models/EnvironmentVariable.php
index 8aaea1cf0c..2cee3a1597 100644
--- a/ProcessMaker/Models/EnvironmentVariable.php
+++ b/ProcessMaker/Models/EnvironmentVariable.php
@@ -3,8 +3,11 @@
 namespace ProcessMaker\Models;
 
 use Exception;
+use Illuminate\Database\Eloquent\Model;
 use Illuminate\Support\Facades\Log;
 use Illuminate\Validation\Rule;
+use Illuminate\Validation\ValidationException;
+use ProcessMaker\Enums\ExporterMap;
 use ProcessMaker\Traits\Exportable;
 
 /**
@@ -13,6 +16,8 @@
  *   @OA\Property(property="name", type="string"),
  *   @OA\Property(property="description", type="string"),
  *   @OA\Property(property="value", type="string"),
+ *   @OA\Property(property="asset_type", type="string", nullable=true),
+ *   @OA\Property(property="do_not_update", type="boolean"),
  * ),
  * @OA\Schema(
  *   schema="EnvironmentVariable",
@@ -36,12 +41,27 @@ class EnvironmentVariable extends ProcessMakerModel
         'name',
         'description',
         'value',
+        'asset_type',
+        'do_not_update',
+    ];
+
+    protected $casts = [
+        'do_not_update' => 'boolean',
     ];
 
     protected $hidden = [
         'value',
     ];
 
+    protected static function boot()
+    {
+        parent::boot();
+
+        static::saving(function (self $environmentVariable) {
+            $environmentVariable->normalizeAssetLink();
+        });
+    }
+
     /**
      * Store the encrypted version of the variable value here
      */
@@ -74,21 +94,118 @@ public static function rules($existing = null)
     {
         $unique = Rule::unique('environment_variables')->ignore($existing);
         $validVariableName = '/^[a-zA-Z][a-zA-Z_$0-9]*$/';
+        $allowedAssetTypes = self::allowedAssetTypes();
 
         return [
             'description' => 'required',
-            'value' => 'nullable',
+            'value' => [
+                'nullable',
+                'required_with:asset_type',
+            ],
             'name' => ['required', "regex:{$validVariableName}", $unique],
+            'asset_type' => [
+                'nullable',
+                'string',
+                Rule::in($allowedAssetTypes),
+            ],
+            'do_not_update' => 'boolean',
         ];
     }
 
+    /**
+     * Validate that asset_type + value resolve to an existing asset of that type.
+     *
+     * @return Model|null The resolved asset when a link is present
+     */
+    public static function validateAssetLinkConsistency(array $data): ?Model
+    {
+        $assetType = $data['asset_type'] ?? null;
+        $value = $data['value'] ?? null;
+
+        if (!$assetType) {
+            return null;
+        }
+
+        if ($value === null || $value === '') {
+            throw ValidationException::withMessages([
+                'value' => [trans('environmentVariables.validation.value.required_with_asset_type')],
+            ]);
+        }
+
+        if (!class_exists($assetType)) {
+            throw ValidationException::withMessages([
+                'asset_type' => [__('The selected asset type is not available.')],
+            ]);
+        }
+
+        if (!in_array($assetType, self::allowedAssetTypes(), true)) {
+            throw ValidationException::withMessages([
+                'asset_type' => [__('The selected asset type is not allowed.')],
+            ]);
+        }
+
+        $asset = $assetType::find($value);
+        if (!$asset) {
+            throw ValidationException::withMessages([
+                'value' => [trans('environmentVariables.validation.value.not_found_for_type')],
+            ]);
+        }
+
+        // Guard against class hierarchy mismatches (e.g. subclass stored under a parent type).
+        if (get_class($asset) !== $assetType) {
+            throw ValidationException::withMessages([
+                'asset_type' => [trans('environmentVariables.validation.asset_type.mismatch')],
+            ]);
+        }
+
+        return $asset;
+    }
+
     public static function messages()
     {
         return [
             'name.regex' => trans('environmentVariables.validation.name.invalid_variable_name'),
+            'value.required_with' => trans('environmentVariables.validation.value.required_with_asset_type'),
         ];
     }
 
+    /**
+     * Exportable model classes that may be linked to an environment variable.
+     */
+    public static function allowedAssetTypes(): array
+    {
+        return collect(ExporterMap::TYPES)
+            ->map(fn (array $type) => $type[0])
+            ->filter(fn (string $class) => class_exists($class))
+            ->values()
+            ->all();
+    }
+
+    public function resolveLinkedAsset(): ?Model
+    {
+        if (!$this->hasLinkedAsset() || !class_exists($this->asset_type)) {
+            return null;
+        }
+
+        if ($this->value === null || $this->value === '') {
+            return null;
+        }
+
+        return $this->asset_type::find($this->value);
+    }
+
+    public function hasLinkedAsset(): bool
+    {
+        return !empty($this->asset_type);
+    }
+
+    protected function normalizeAssetLink(): void
+    {
+        if ($this->asset_type === '') {
+            $this->asset_type = null;
+        }
+    }
+
     public static function getMetricsApiEndpoint()
     {
         $variable = self::where('name', 'METRICS_API_ENDPOINT')->first();
diff --git a/database/factories/ProcessMaker/Models/EnvironmentVariableFactory.php b/database/factories/ProcessMaker/Models/EnvironmentVariableFactory.php
index 9c63ccdf2f..fbdf253ce9 100644
--- a/database/factories/ProcessMaker/Models/EnvironmentVariableFactory.php
+++ b/database/factories/ProcessMaker/Models/EnvironmentVariableFactory.php
@@ -18,6 +18,7 @@ public function definition()
             'name' => $this->faker->word(),
             'description' => $this->faker->sentence(),
             'value' => $this->faker->sentence(),
+            'do_not_update' => false,
         ];
     }
 }
diff --git a/database/migrations/2026_07_20_000000_add_asset_link_to_environment_variables_table.php b/database/migrations/2026_07_20_000000_add_asset_link_to_environment_variables_table.php
new file mode 100644
index 0000000000..370df325dd
--- /dev/null
+++ b/database/migrations/2026_07_20_000000_add_asset_link_to_environment_variables_table.php
@@ -0,0 +1,28 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::table('environment_variables', function (Blueprint $table) {
+            $table->string('asset_type')->nullable()->after('value');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('environment_variables', function (Blueprint $table) {
+            $table->dropColumn(['asset_type']);
+        });
+    }
+};
diff --git a/database/migrations/2026_07_23_000000_add_do_not_update_to_environment_variables_table.php b/database/migrations/2026_07_23_000000_add_do_not_update_to_environment_variables_table.php
new file mode 100644
index 0000000000..122397d593
--- /dev/null
+++ b/database/migrations/2026_07_23_000000_add_do_not_update_to_environment_variables_table.php
@@ -0,0 +1,28 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::table('environment_variables', function (Blueprint $table) {
+            $table->boolean('do_not_update')->default(false)->after('asset_type');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('environment_variables', function (Blueprint $table) {
+            $table->dropColumn('do_not_update');
+        });
+    }
+};
diff --git a/resources/js/processes/environment-variables/assetTypes.js b/resources/js/processes/environment-variables/assetTypes.js
new file mode 100644
index 0000000000..e03a0892bf
--- /dev/null
+++ b/resources/js/processes/environment-variables/assetTypes.js
@@ -0,0 +1,54 @@
+/**
+ * Exportable asset types that can be linked to an environment variable.
+ * apiPath is the local API listing endpoint used by the asset picker.
+ */
+export default [
+  {
+    class: "ProcessMaker\\Models\\Process",
+    label: "Process",
+    apiPath: "processes",
+    nameField: "name",
+  },
+  {
+    class: "ProcessMaker\\Models\\Screen",
+    label: "Screen",
+    apiPath: "screens",
+    nameField: "title",
+  },
+  {
+    class: "ProcessMaker\\Models\\Script",
+    label: "Script",
+    apiPath: "scripts",
+    nameField: "title",
+  },
+  {
+    class: "ProcessMaker\\Plugins\\Collections\\Models\\Collection",
+    label: "Collection",
+    apiPath: "collections",
+    nameField: "name",
+  },
+  {
+    class: "ProcessMaker\\Packages\\Connectors\\DataSources\\Models\\DataSource",
+    label: "Data Connector",
+    apiPath: "data_sources",
+    nameField: "name",
+  },
+  {
+    class: "ProcessMaker\\Package\\PackageDecisionEngine\\Models\\DecisionTable",
+    label: "Decision Table",
+    apiPath: "decision_tables",
+    nameField: "title",
+  },
+  {
+    class: "ProcessMaker\\Package\\PackageAi\\Models\\FlowGenie",
+    label: "FlowGenie",
+    apiPath: "package-ai/flow_genies",
+    nameField: "name",
+  },
+  {
+    class: "ProcessMaker\\Package\\PackagePmBlocks\\Models\\PmBlock",
+    label: "PM Block",
+    apiPath: "pm-blocks",
+    nameField: "name",
+  },
+];
diff --git a/resources/js/processes/environment-variables/components/AssetLinkFields.vue b/resources/js/processes/environment-variables/components/AssetLinkFields.vue
new file mode 100644
index 0000000000..4164373a7c
--- /dev/null
+++ b/resources/js/processes/environment-variables/components/AssetLinkFields.vue
@@ -0,0 +1,233 @@
+<template>
+  <div>
+    <b-form-group
+      :label="$t('Asset Type')"
+      :description="$t('Optional. If set, the value is the ID of the selected asset and it will be exported with scripts that use this variable.')"
+      :invalid-feedback="errorMessage('asset_type', errors)"
+      :state="errorState('asset_type', errors)"
+    >
+      <b-form-select
+        v-model="localAssetType"
+        :options="assetTypeOptions"
+        :state="errorState('asset_type', errors)"
+        name="asset_type"
+        @change="onAssetTypeChange"
+      />
+    </b-form-group>
+
+    <b-form-group
+      v-if="localAssetType"
+      :label="$t('Asset')"
+      :invalid-feedback="errorMessage('value', errors)"
+      :state="errorState('value', errors)"
+    >
+      <multiselect
+        v-model="selectedAsset"
+        :options="assetOptions"
+        :loading="isLoadingAssets"
+        :placeholder="$t('Type to search')"
+        :show-labels="false"
+        :internal-search="false"
+        :options-limit="20"
+        track-by="id"
+        :label="nameField"
+        @search-change="loadAssets"
+        @input="onAssetSelected"
+      />
+    </b-form-group>
+
+    <b-form-group
+      v-if="!localAssetType"
+      :label="$t('Value')"
+      :invalid-feedback="errorMessage('value', errors)"
+      :state="errorState('value', errors)"
+    >
+      <b-form-textarea
+        v-model="localValue"
+        autocomplete="off"
+        rows="10"
+        :state="errorState('value', errors)"
+        name="value"
+        @input="emitValue"
+      />
+      <small v-if="valueHint" class="form-text text-muted">{{ valueHint }}</small>
+    </b-form-group>
+
+    <b-form-group
+      v-else
+      :label="$t('Value')"
+      :invalid-feedback="errorMessage('value', errors)"
+      :state="errorState('value', errors)"
+    >
+      <b-form-input
+        :value="derivedValueLabel"
+        plaintext
+        readonly
+      />
+      <small class="form-text text-muted">
+        {{ $t('Value is set automatically to the selected asset ID.') }}
+      </small>
+    </b-form-group>
+  </div>
+</template>
+
+<script>
+import { Multiselect } from "@processmaker/vue-multiselect";
+import { FormErrorsMixin } from "SharedComponents";
+import assetTypes from "../assetTypes";
+
+export default {
+  components: { Multiselect },
+  mixins: [FormErrorsMixin],
+  props: {
+    assetType: {
+      type: String,
+      default: null,
+    },
+    value: {
+      type: [String, Number],
+      default: "",
+    },
+    errors: {
+      type: Object,
+      default: () => ({}),
+    },
+    valueHint: {
+      type: String,
+      default: "",
+    },
+  },
+  data() {
+    return {
+      localAssetType: this.assetType || "",
+      localValue: this.value || "",
+      selectedAsset: null,
+      assetOptions: [],
+      isLoadingAssets: false,
+      assetTypes,
+    };
+  },
+  computed: {
+    assetTypeOptions() {
+      return [
+        { value: "", text: this.$t("None") },
+        ...this.assetTypes.map((type) => ({
+          value: type.class,
+          text: this.$t(type.label),
+        })),
+      ];
+    },
+    selectedTypeConfig() {
+      return this.assetTypes.find((type) => type.class === this.localAssetType) || null;
+    },
+    nameField() {
+      return this.selectedTypeConfig?.nameField || "name";
+    },
+    derivedValueLabel() {
+      if (this.selectedAsset) {
+        const name = this.selectedAsset[this.nameField] || this.selectedAsset.name || "";
+        return `${this.selectedAsset.id}${name ? ` (${name})` : ""}`;
+      }
+      return this.$t("Select an asset");
+    },
+  },
+  watch: {
+    assetType(next) {
+      this.localAssetType = next || "";
+      if (this.localAssetType && this.value) {
+        this.loadSelectedAsset();
+      }
+    },
+    value(next) {
+      if (this.localAssetType && next) {
+        this.loadSelectedAsset();
+      }
+    },
+  },
+  mounted() {
+    if (this.localAssetType && this.value) {
+      this.loadSelectedAsset();
+    } else if (this.localAssetType) {
+      this.loadAssets("");
+    }
+  },
+  methods: {
+    onAssetTypeChange() {
+      this.selectedAsset = null;
+      this.assetOptions = [];
+      this.$emit("update:assetType", this.localAssetType || null);
+      this.$emit("update:value", this.localAssetType ? "" : this.localValue);
+      if (this.localAssetType) {
+        this.loadAssets("");
+      }
+    },
+    onAssetSelected(asset) {
+      this.$emit("update:assetType", this.localAssetType || null);
+      this.$emit("update:value", asset ? String(asset.id) : "");
+    },
+    emitValue() {
+      this.$emit("update:value", this.localValue);
+    },
+    loadAssets(query) {
+      if (!this.selectedTypeConfig) {
+        return;
+      }
+      this.isLoadingAssets = true;
+      ProcessMaker.apiClient
+        .get(this.selectedTypeConfig.apiPath, {
+          params: {
+            filter: query || "",
+            per_page: 20,
+            order_by: this.nameField,
+            order_direction: "asc",
+          },
+        })
+        .then((response) => {
+          this.assetOptions = response.data.data || [];
+        })
+        .catch(() => {
+          this.assetOptions = [];
+        })
+        .finally(() => {
+          this.isLoadingAssets = false;
+        });
+    },
+    loadSelectedAsset() {
+      if (!this.selectedTypeConfig || !this.value) {
+        return;
+      }
+      const assetId = String(this.value);
+      this.isLoadingAssets = true;
+      ProcessMaker.apiClient
+        .get(this.selectedTypeConfig.apiPath, {
+          params: {
+            filter: "",
+            per_page: 50,
+          },
+        })
+        .then((response) => {
+          const items = response.data.data || [];
+          this.assetOptions = items;
+          this.selectedAsset = items.find((item) => String(item.id) === assetId) || null;
+          if (!this.selectedAsset) {
+            this.selectedAsset = {
+              id: assetId,
+              [this.nameField]: assetId,
+            };
+            this.assetOptions = [this.selectedAsset, ...items];
+          }
+        })
+        .catch(() => {
+          this.selectedAsset = {
+            id: assetId,
+            [this.nameField]: assetId,
+          };
+          this.assetOptions = [this.selectedAsset];
+        })
+        .finally(() => {
+          this.isLoadingAssets = false;
+        });
+    },
+  },
+};
+</script>
diff --git a/resources/js/processes/environment-variables/components/CreateEnvironmentVariableModal.vue b/resources/js/processes/environment-variables/components/CreateEnvironmentVariableModal.vue
index b8ec2f81df..ca604e149e 100644
--- a/resources/js/processes/environment-variables/components/CreateEnvironmentVariableModal.vue
+++ b/resources/js/processes/environment-variables/components/CreateEnvironmentVariableModal.vue
@@ -36,28 +36,23 @@
           name="description"
         ></b-form-textarea>
       </b-form-group>
-      <b-form-group
-        :label="$t('Value')"
-        :invalid-feedback="errorMessage('value', errors)"
-        :state="errorState('value', errors)"
-      >
-        <b-form-textarea
-          v-model="value"
-          autocomplete="off"
-          rows="10"
-          :state="errorState('value', errors)"
-          name="value"
-        ></b-form-textarea>
-      </b-form-group>
+      <asset-link-fields
+        :asset-type.sync="assetType"
+        :value.sync="value"
+        :errors="errors"
+      />
+      <do-not-update-switch v-model="doNotUpdate" />
     </modal>
   </div>
 </template>
 
 <script>
   import { FormErrorsMixin, Modal, Required } from "SharedComponents";
+  import AssetLinkFields from "./AssetLinkFields.vue";
+  import DoNotUpdateSwitch from "./DoNotUpdateSwitch.vue";
 
   export default {
-    components: { Modal, Required },
+    components: { Modal, Required, AssetLinkFields, DoNotUpdateSwitch },
     mixins: [ FormErrorsMixin ],
     data: function() {
       return {
@@ -65,6 +60,8 @@
         name: '',
         description: '',
         value: '',
+        assetType: null,
+        doNotUpdate: false,
         disabled: false,
       }
     },
@@ -73,7 +70,10 @@
         this.name = '';
         this.description = '';
         this.value = '';
+        this.assetType = null;
+        this.doNotUpdate = false;
         this.errors = {};
+        this.disabled = false;
       },
       onSubmit() {
         this.errors = {};
@@ -85,7 +85,9 @@
         ProcessMaker.apiClient.post('environment_variables', {
           name: this.name,
           description: this.description,
-          value: this.value
+          value: this.value,
+          asset_type: this.assetType,
+          do_not_update: this.doNotUpdate,
         })
           .then(response => {
             ProcessMaker.alert(this.$t('The environment variable was created.'), 'success');
diff --git a/resources/js/processes/environment-variables/components/DoNotUpdateSwitch.vue b/resources/js/processes/environment-variables/components/DoNotUpdateSwitch.vue
new file mode 100644
index 0000000000..d327d71bdc
--- /dev/null
+++ b/resources/js/processes/environment-variables/components/DoNotUpdateSwitch.vue
@@ -0,0 +1,32 @@
+<template>
+  <div class="do-not-update-switch pt-3 mt-2 border-top">
+    <div class="d-flex align-items-start">
+      <b-form-checkbox
+        class="mt-1"
+        switch
+        :checked="value"
+        @input="$emit('input', $event)"
+      />
+      <div class="ml-2">
+        <div class="font-weight-bold">
+          <i class="fas fa-lock text-primary mr-1" aria-hidden="true"></i>
+          {{ $t("Do not overwrite this environment variable on import/DevLink") }}
+        </div>
+        <small class="form-text text-muted mb-0">
+          {{ $t("When enabled, the value of this variable will not be overwritten during imports or DevLink synchronization, even if a variable with the same name exists in the source environment.") }}
+        </small>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script>
+export default {
+  props: {
+    value: {
+      type: Boolean,
+      default: false,
+    },
+  },
+};
+</script>
diff --git a/resources/js/processes/environment-variables/edit.js b/resources/js/processes/environment-variables/edit.js
new file mode 100644
index 0000000000..952d56956f
--- /dev/null
+++ b/resources/js/processes/environment-variables/edit.js
@@ -0,0 +1,64 @@
+import Vue from "vue";
+import AssetLinkFields from "./components/AssetLinkFields.vue";
+import DoNotUpdateSwitch from "./components/DoNotUpdateSwitch.vue";
+
+const initial = window.ProcessMaker.EnvironmentVariableEdit || {};
+
+new Vue({
+  el: "#editEnvironmentVariable",
+  components: {
+    AssetLinkFields,
+    DoNotUpdateSwitch,
+  },
+  data() {
+    return {
+      formData: {
+        id: initial.id,
+        name: initial.name,
+        description: initial.description,
+        value: initial.value || null,
+        asset_type: initial.asset_type || null,
+        do_not_update: !!initial.do_not_update,
+      },
+      errors: {
+        name: null,
+        description: null,
+        value: null,
+        asset_type: null,
+      },
+    };
+  },
+  methods: {
+    resetErrors() {
+      this.errors = {
+        name: null,
+        description: null,
+        value: null,
+        asset_type: null,
+      };
+    },
+    onClose() {
+      window.location.href = "/designer/environment-variables";
+    },
+    onUpdate() {
+      this.resetErrors();
+      const payload = {
+        name: this.formData.name,
+        description: this.formData.description,
+        asset_type: this.formData.asset_type,
+        value: this.formData.value,
+        do_not_update: this.formData.do_not_update,
+      };
+      ProcessMaker.apiClient.put(`environment_variables/${this.formData.id}`, payload)
+        .then(() => {
+          ProcessMaker.alert(this.$t("The environment variable was saved."), "success");
+          this.onClose();
+        })
+        .catch((error) => {
+          if (error.response && error.response.status === 422) {
+            this.errors = error.response.data.errors;
+          }
+        });
+    },
+  },
+});
diff --git a/resources/lang/en/environmentVariables.php b/resources/lang/en/environmentVariables.php
index 6ccf15a249..94f305b391 100644
--- a/resources/lang/en/environmentVariables.php
+++ b/resources/lang/en/environmentVariables.php
@@ -5,5 +5,13 @@
         'name' => [
             'invalid_variable_name' => 'Name has to start with a letter and can contain only letters, numbers, and underscores (_).',
         ],
+        'asset_type' => [
+            'mismatch' => 'The selected asset does not match the specified asset type.',
+        ],
+        'value' => [
+            'required_with_asset_type' => 'A value (asset ID) is required when an asset type is set.',
+            'not_found_for_type' => 'The selected asset could not be found for the specified asset type.',
+            'must_match_asset_id' => 'The value must match the ID of the selected asset.',
+        ],
     ],
 ];
diff --git a/resources/views/processes/environment-variables/edit.blade.php b/resources/views/processes/environment-variables/edit.blade.php
index ebcac047b2..4288228451 100644
--- a/resources/views/processes/environment-variables/edit.blade.php
+++ b/resources/views/processes/environment-variables/edit.blade.php
@@ -32,12 +32,13 @@
                         {{ html()->textarea('description')->class('form-control')->attribute('v-model', 'formData.description')->attribute('v-bind:class', '{\'form-control\':true, \'is-invalid\':errors.description}')->rows(3)->required()->attribute('aria-required', 'true') }}
                         <div class="invalid-feedback" role="alert" v-for="description in errors.description">@{{description}}</div>
                     </div>
-                    <div class="form-group">
-                        {{ html()->label(__('Value'), 'value') }}
-                        {{ html()->textarea('value')->class('form-control')->attribute('v-model', 'formData.value')->attribute('v-bind:class', '{\'form-control\':true, \'is-invalid\':errors.description}')->rows(3)->required()->attribute('aria-required', 'true') }}
-                        <small class="form-text text-muted">{{__('For security purposes, this field will always appear empty') }}</small>
-                        <div class="invalid-feedback" role="alert" v-for="value in errors.value">@{{value}}</div>
-                    </div>
+                    <asset-link-fields
+                        :asset-type.sync="formData.asset_type"
+                        :value.sync="formData.value"
+                        :errors="errors"
+                        value-hint="{{ __('For security purposes, this field will always appear empty') }}"
+                    ></asset-link-fields>
+                    <do-not-update-switch v-model="formData.do_not_update"></do-not-update-switch>
                     <br>
                     <div class="text-right">
                         {{ html()->button(__('Cancel'), 'button')->class('btn btn-outline-secondary')->attribute('@click', 'onClose') }}
@@ -51,48 +52,15 @@
 
 @section('js')
     <script>
-        new Vue({
-            el: '#editEnvironmentVariable',
-            data() {
-                return {
-                    formData: {
-                        id: @json($environmentVariable->id),
-                        name: @json($environmentVariable->name),
-                        description: @json($environmentVariable->description),
-                        value: null,
-                    },
-                    errors: {
-                        'name': null,
-                        'description': null,
-                        'value': null
-                    }
-                }
-            },
-            methods: {
-                resetErrors() {
-                    this.errors = Object.assign({}, {
-                        name: this.name,
-                        description: this.description,
-                        value: this.value
-                    });
-                },
-                onClose() {
-                    window.location.href = '/designer/environment-variables';
-                },
-                onUpdate() {
-                    this.resetErrors();
-                    ProcessMaker.apiClient.put('environment_variables/' + this.formData.id, this.formData)
-                        .then(response => {
-                            ProcessMaker.alert(this.$t('The environment variable was saved.'), 'success');
-                            this.onClose();
-                        })
-                        .catch(error => {
-                            if (error.response.status && error.response.status === 422) {
-                                this.errors = error.response.data.errors;
-                            }
-                        });
-                }
-            }
-        });
+        window.ProcessMaker.EnvironmentVariableEdit = {
+            id: @json($environmentVariable->id),
+            name: @json($environmentVariable->name),
+            description: @json($environmentVariable->description),
+            asset_type: @json($environmentVariable->asset_type),
+            // Safe to expose when linked: value is the asset numeric ID, not a secret.
+            value: @json($environmentVariable->asset_type ? $environmentVariable->value : null),
+            do_not_update: @json((bool) $environmentVariable->do_not_update),
+        };
     </script>
+    <script src="{{mix('js/processes/environment-variables/edit.js')}}"></script>
 @endsection
diff --git a/tests/Feature/Api/EnvironmentVariablesTest.php b/tests/Feature/Api/EnvironmentVariablesTest.php
index eb6b17f28f..b00f5c7674 100644
--- a/tests/Feature/Api/EnvironmentVariablesTest.php
+++ b/tests/Feature/Api/EnvironmentVariablesTest.php
@@ -6,6 +6,8 @@
 use Illuminate\Support\Facades\Artisan;
 use Illuminate\Support\Facades\Hash;
 use ProcessMaker\Models\EnvironmentVariable;
+use ProcessMaker\Models\Screen;
+use ProcessMaker\Models\Script;
 use ProcessMaker\Models\User;
 use Tests\Feature\Shared\RequestHelper;
 use Tests\TestCase;
@@ -161,6 +163,50 @@ public function test_it_should_successfully_update_an_environment_variable()
         $this->assertEquals('newvalue', $variable->value);
     }
 
+    /** @test */
+    public function test_it_should_create_an_environment_variable_with_do_not_update()
+    {
+        $data = [
+            'name' => 'protectedVar',
+            'description' => 'protected description',
+            'value' => 'secret',
+            'do_not_update' => true,
+        ];
+
+        $response = $this->apiCall('POST', self::API_TEST_VARIABLES, $data);
+
+        $response->assertStatus(201);
+        $response->assertJsonFragment(['do_not_update' => true]);
+        $this->assertDatabaseHas('environment_variables', [
+            'name' => 'protectedVar',
+            'do_not_update' => true,
+        ]);
+    }
+
+    /** @test */
+    public function test_it_should_update_do_not_update_flag()
+    {
+        $variable = EnvironmentVariable::factory()->create([
+            'name' => 'testname',
+            'value' => 'testvalue',
+            'do_not_update' => false,
+        ]);
+
+        $data = [
+            'name' => 'testname',
+            'description' => 'updated description',
+            'do_not_update' => true,
+        ];
+        $response = $this->apiCall('PUT', self::API_TEST_VARIABLES . '/' . $variable->id, $data);
+
+        $response->assertStatus(200);
+        $response->assertJsonFragment(['do_not_update' => true]);
+        $this->assertDatabaseHas('environment_variables', [
+            'id' => $variable->id,
+            'do_not_update' => true,
+        ]);
+    }
+
     /** @test */
     public function test_it_should_return_paginated_environment_variables_during_index()
     {
@@ -255,4 +301,124 @@ public function testCreationOfMetricVariable()
             'name' => 'METRICS_API_ENDPOINT',
         ]);
     }
+
+    /** @test */
+    public function test_it_should_create_an_environment_variable_linked_to_an_asset()
+    {
+        $screen = Screen::factory()->create();
+
+        $response = $this->apiCall('POST', self::API_TEST_VARIABLES, [
+            'name' => 'MY_SCREEN_ID',
+            'description' => 'Linked screen id',
+            'asset_type' => Screen::class,
+            'value' => (string) $screen->id,
+        ]);
+
+        $response->assertStatus(201);
+        $response->assertJsonFragment([
+            'name' => 'MY_SCREEN_ID',
+            'asset_type' => Screen::class,
+        ]);
+
+        $variable = EnvironmentVariable::where('name', 'MY_SCREEN_ID')->firstOrFail();
+        $this->assertEquals((string) $screen->id, $variable->value);
+        $this->assertEquals(Screen::class, $variable->asset_type);
+    }
+
+    /** @test */
+    public function test_it_should_reject_invalid_asset_link()
+    {
+        $response = $this->apiCall('POST', self::API_TEST_VARIABLES, [
+            'name' => 'MY_SCREEN_ID',
+            'description' => 'Linked screen id',
+            'asset_type' => Screen::class,
+            'value' => '999999',
+        ]);
+
+        $response->assertStatus(422);
+        $response->assertJsonValidationErrors(['value']);
+    }
+
+    /** @test */
+    public function test_it_should_update_environment_variable_asset_link()
+    {
+        $screen = Screen::factory()->create();
+        $variable = EnvironmentVariable::factory()->create([
+            'name' => 'MY_SCREEN_ID',
+            'value' => 'old-value',
+        ]);
+
+        $response = $this->apiCall('PUT', self::API_TEST_VARIABLES . '/' . $variable->id, [
+            'name' => 'MY_SCREEN_ID',
+            'description' => 'Linked screen id',
+            'asset_type' => Screen::class,
+            'value' => (string) $screen->id,
+        ]);
+
+        $response->assertStatus(200);
+        $variable->refresh();
+        $this->assertEquals((string) $screen->id, $variable->value);
+        $this->assertEquals(Screen::class, $variable->asset_type);
+    }
+
+    /** @test */
+    public function test_update_rejects_value_not_found_for_asset_type()
+    {
+        $variable = EnvironmentVariable::factory()->create([
+            'name' => 'MY_SCREEN_ID',
+            'value' => 'old-value',
+        ]);
+
+        $response = $this->apiCall('PUT', self::API_TEST_VARIABLES . '/' . $variable->id, [
+            'name' => 'MY_SCREEN_ID',
+            'description' => 'Linked screen id',
+            'asset_type' => Screen::class,
+            'value' => '999999',
+        ]);
+
+        $response->assertStatus(422);
+        $response->assertJsonValidationErrors(['value']);
+    }
+
+    /** @test */
+    public function test_update_accepts_value_matching_selected_asset_id()
+    {
+        $screen = Screen::factory()->create();
+        $variable = EnvironmentVariable::factory()->create([
+            'name' => 'MY_SCREEN_ID',
+            'value' => 'old-value',
+        ]);
+
+        $response = $this->apiCall('PUT', self::API_TEST_VARIABLES . '/' . $variable->id, [
+            'name' => 'MY_SCREEN_ID',
+            'description' => 'Linked screen id',
+            'asset_type' => Screen::class,
+            'value' => (string) $screen->id,
+        ]);
+
+        $response->assertStatus(200);
+        $variable->refresh();
+        $this->assertEquals((string) $screen->id, $variable->value);
+    }
+
+    /** @test */
+    public function test_update_rejects_value_id_of_wrong_asset_type()
+    {
+        $script = Script::factory()->create();
+        $variable = EnvironmentVariable::factory()->create([
+            'name' => 'MY_SCREEN_ID',
+            'value' => 'old-value',
+        ]);
+
+        // Script ID with Screen type — pair is inconsistent.
+        $response = $this->apiCall('PUT', self::API_TEST_VARIABLES . '/' . $variable->id, [
+            'name' => 'MY_SCREEN_ID',
+            'description' => 'Linked screen id',
+            'asset_type' => Screen::class,
+            'value' => (string) $script->id,
+        ]);
+
+        $response->assertStatus(422);
+        $response->assertJsonValidationErrors(['value']);
+    }
 }
diff --git a/tests/Feature/ImportExport/Exporters/ScriptExporterTest.php b/tests/Feature/ImportExport/Exporters/ScriptExporterTest.php
index 5dcbb6b564..437eb5e912 100644
--- a/tests/Feature/ImportExport/Exporters/ScriptExporterTest.php
+++ b/tests/Feature/ImportExport/Exporters/ScriptExporterTest.php
@@ -4,12 +4,16 @@
 
 use Database\Seeders\CategorySystemSeeder;
 use Illuminate\Support\Facades\DB;
+use ProcessMaker\ImportExport\DependentType;
 use ProcessMaker\ImportExport\Exporters\ScriptExporter;
+use ProcessMaker\ImportExport\Logger;
 use ProcessMaker\ImportExport\Options;
 use ProcessMaker\Models\EnvironmentVariable;
+use ProcessMaker\Models\Screen;
 use ProcessMaker\Models\Script;
 use ProcessMaker\Models\ScriptCategory;
 use ProcessMaker\Models\User;
+use ReflectionClass;
 use Tests\Feature\ImportExport\HelperTrait;
 use Tests\TestCase;
 
@@ -151,6 +155,63 @@ public function testRunAsUserIdNull()
         $this->assertNull($script->run_as_user_id);
     }
 
+    /**
+     * When the target env var has do_not_update, import must preserve its value.
+     */
+    public function testDoNotUpdateEnvironmentVariablePreservedOnImport()
+    {
+        DB::beginTransaction();
+        $protected = EnvironmentVariable::factory()->create([
+            'name' => 'PROTECTED_API_TOKEN',
+            'description' => 'source description',
+            'value' => 'source-secret',
+            'do_not_update' => false,
+        ]);
+        $unprotected = EnvironmentVariable::factory()->create([
+            'name' => 'PLAIN_CONFIG',
+            'description' => 'source plain',
+            'value' => 'source-plain',
+            'do_not_update' => false,
+        ]);
+        $script = Script::factory()->create([
+            'title' => 'script with protected env',
+            'code' => '<?php $a = getenv(\'PROTECTED_API_TOKEN\'); $b = getenv(\'PLAIN_CONFIG\'); return [];',
+        ]);
+
+        $payload = $this->export($script, ScriptExporter::class);
+        DB::rollBack();
+
+        $targetProtected = EnvironmentVariable::factory()->create([
+            'name' => 'PROTECTED_API_TOKEN',
+            'description' => 'target description',
+            'value' => 'keep-me',
+            'do_not_update' => true,
+        ]);
+        $targetUnprotected = EnvironmentVariable::factory()->create([
+            'name' => 'PLAIN_CONFIG',
+            'description' => 'target plain',
+            'value' => 'replace-me',
+            'do_not_update' => false,
+        ]);
+
+        $options = new Options([
+            $script->uuid => ['mode' => 'update'],
+            $protected->uuid => ['mode' => 'update'],
+            $unprotected->uuid => ['mode' => 'update'],
+        ]);
+        $this->import($payload, $options);
+
+        $targetProtected->refresh();
+        $targetUnprotected->refresh();
+
+        $this->assertEquals('keep-me', $targetProtected->value);
+        $this->assertEquals('target description', $targetProtected->description);
+        $this->assertTrue($targetProtected->do_not_update);
+
+        $this->assertEquals('source-plain', $targetUnprotected->value);
+        $this->assertEquals('source plain', $targetUnprotected->description);
+    }
+
     /**
      * Test that the environment variables are duplicated when they are used in the script
      * and the import options are set to create a copy
@@ -191,4 +252,192 @@ public function testWithDuplicatedEnvVariable()
         $this->assertDatabaseHas('environment_variables', ['name' => $environmentVariable1->name . '_2']);
         $this->assertDatabaseHas('environment_variables', ['name' => $environmentVariable2->name . '_2']);
         $this->assertDatabaseMissing('environment_variables', ['name' => $environmentVariable3->name . '_2']);
-    }}
+    }
+
+    public function testLinkedAssetRemappedOnImportUpdateMode()
+    {
+        $screen = Screen::factory()->create(['title' => 'Linked Screen']);
+        $environmentVariable = EnvironmentVariable::factory()->create([
+            'name' => 'MY_SCREEN_ID',
+            'description' => 'Screen id for scripts',
+            'asset_type' => Screen::class,
+            'value' => (string) $screen->id,
+        ]);
+        $script = Script::factory()->create([
+            'title' => 'script with linked env var',
+            'code' => '<?php $screenId = getenv(\'MY_SCREEN_ID\'); return [];',
+        ]);
+
+        $payload = $this->export($script, ScriptExporter::class);
+
+        $envVarPayload = collect($payload['export'])->first(function ($asset) {
+            return ($asset['model'] ?? null) === EnvironmentVariable::class;
+        });
+        $this->assertNotNull($envVarPayload);
+        $this->assertTrue(
+            collect($envVarPayload['dependents'])->pluck('type')->contains(DependentType::ENVIRONMENT_VARIABLE_ASSET)
+        );
+
+        // Simulate a stale numeric ID on the target instance before update import.
+        DB::table('environment_variables')
+            ->where('id', $environmentVariable->id)
+            ->update(['value' => encrypt('999999')]);
+        $this->assertEquals('999999', $environmentVariable->fresh()->value);
+
+        $options = new Options([
+            $script->uuid => ['mode' => 'update'],
+            $environmentVariable->uuid => ['mode' => 'update'],
+            $screen->uuid => ['mode' => 'update'],
+        ]);
+        $this->import($payload, $options);
+
+        $screen->refresh();
+        $environmentVariable->refresh();
+
+        $this->assertEquals(1, Screen::where('title', 'Linked Screen')->count());
+        $this->assertEquals(1, EnvironmentVariable::where('name', 'MY_SCREEN_ID')->count());
+        $this->assertEquals(Screen::class, $environmentVariable->asset_type);
+        $this->assertEquals((string) $screen->id, $environmentVariable->value);
+    }
+
+    public function testLinkedAssetRemappedOnImportCopyMode()
+    {
+        $screen = Screen::factory()->create(['title' => 'Linked Screen']);
+        $environmentVariable = EnvironmentVariable::factory()->create([
+            'name' => 'MY_SCREEN_ID',
+            'description' => 'Screen id for scripts',
+            'asset_type' => Screen::class,
+            'value' => (string) $screen->id,
+        ]);
+        $script = Script::factory()->create([
+            'title' => 'script with linked env var',
+            'code' => '<?php $screenId = getenv(\'MY_SCREEN_ID\'); return [];',
+        ]);
+
+        $originalScreenUuid = $screen->uuid;
+        $originalScreenId = $screen->id;
+        $originalEnvUuid = $environmentVariable->uuid;
+
+        $payload = $this->export($script, ScriptExporter::class);
+
+        $options = new Options([
+            $script->uuid => ['mode' => 'copy'],
+            $environmentVariable->uuid => ['mode' => 'copy'],
+            $screen->uuid => ['mode' => 'copy'],
+        ]);
+        $this->import($payload, $options);
+
+        // Originals remain unchanged.
+        $screen->refresh();
+        $environmentVariable->refresh();
+        $this->assertEquals($originalScreenUuid, $screen->uuid);
+        $this->assertEquals((string) $originalScreenId, $environmentVariable->value);
+        $this->assertEquals(Screen::class, $environmentVariable->asset_type);
+        $this->assertEquals($originalEnvUuid, $environmentVariable->uuid);
+
+        $copiedScreen = Screen::where('title', 'Linked Screen 2')->firstOrFail();
+        $copiedVariable = EnvironmentVariable::where('name', 'MY_SCREEN_ID_2')->firstOrFail();
+
+        $this->assertNotEquals($originalScreenUuid, $copiedScreen->uuid);
+        $this->assertNotEquals($originalEnvUuid, $copiedVariable->uuid);
+        $this->assertEquals(Screen::class, $copiedVariable->asset_type);
+        $this->assertEquals((string) $copiedScreen->id, $copiedVariable->value);
+    }
+
+    /**
+     * Scenario A: linked asset is discarded but already exists on target — remap value to that asset.
+     */
+    public function testLinkedAssetRemappedWhenDiscardedButExistsOnTarget()
+    {
+        $screen = Screen::factory()->create(['title' => 'Existing Linked Screen']);
+        $environmentVariableName = 'MY_SCREEN_ID';
+        $environmentVariable = EnvironmentVariable::factory()->create([
+            'name' => $environmentVariableName,
+            'description' => 'Screen id for scripts',
+            'asset_type' => Screen::class,
+            'value' => (string) $screen->id,
+        ]);
+        $script = Script::factory()->create([
+            'title' => 'script with linked env var discard exists',
+            'code' => '<?php $screenId = getenv(\'MY_SCREEN_ID\'); return [];',
+        ]);
+
+        $payload = $this->export($script, ScriptExporter::class);
+
+        // Stale value before import; asset itself stays and is discarded (not updated).
+        DB::table('environment_variables')
+            ->where('id', $environmentVariable->id)
+            ->update(['value' => encrypt('999999')]);
+
+        $options = new Options([
+            $script->uuid => ['mode' => 'update'],
+            $environmentVariable->uuid => ['mode' => 'update'],
+            $screen->uuid => ['mode' => 'discard'],
+        ]);
+        $this->import($payload, $options);
+
+        $screen->refresh();
+        // Get the environment variable by name after import
+        $environmentVariable = EnvironmentVariable::where('name', $environmentVariableName)->firstOrFail();
+
+        $this->assertEquals(1, Screen::whereLike('title', 'Existing Linked Screen%')->count());
+        $this->assertEquals(Screen::class, $environmentVariable->asset_type);
+        $this->assertEquals((string) $screen->id, $environmentVariable->value);
+    }
+
+    /**
+     * Scenario B: linked asset is missing on target — clear link and value, warn in import summary.
+     */
+    public function testLinkedAssetClearedWhenMissingOnImport()
+    {
+        $screen = Screen::factory()->create(['title' => 'Missing Linked Screen']);
+        $environmentVariableName = 'MY_SCREEN_ID';
+        $environmentVariable = EnvironmentVariable::factory()->create([
+            'name' => $environmentVariableName,
+            'description' => 'Screen id for scripts',
+            'asset_type' => Screen::class,
+            'value' => (string) $screen->id,
+        ]);
+        $script = Script::factory()->create([
+            'title' => 'script with linked env var missing asset',
+            'code' => '<?php $screenId = getenv(\'MY_SCREEN_ID\'); return [];',
+        ]);
+
+        $payload = $this->export($script, ScriptExporter::class);
+        $screenUuid = $screen->uuid;
+
+        // Remove the asset from the target instance before import.
+        $screen->delete();
+        $this->assertNull(Screen::where('uuid', $screenUuid)->first());
+
+        $logger = new Logger();
+        $options = new Options([
+            $script->uuid => ['mode' => 'update'],
+            $environmentVariable->uuid => ['mode' => 'update'],
+            $screenUuid => ['mode' => 'discard'],
+        ]);
+        $this->import($payload, $options, $logger);
+
+        // Get the environment variable by name after import
+        $environmentVariable = EnvironmentVariable::where('name', $environmentVariableName)->firstOrFail();
+
+        $this->assertNull($environmentVariable->asset_type);
+        $this->assertSame('', $environmentVariable->value);
+
+        $warnings = $this->getLoggerWarnings($logger);
+        $expectedWarning = __(
+            'Asset linked to environment variable ":env_variable" was missing on import; link and value were cleared',
+            ['env_variable' => 'MY_SCREEN_ID']
+        );
+        $this->assertContains($expectedWarning, $warnings);
+    }
+
+    private function getLoggerWarnings(Logger $logger): array
+    {
+        $reflection = new ReflectionClass($logger);
+        $property = $reflection->getProperty('warnings');
+        $property->setAccessible(true);
+
+        return $property->getValue($logger);
+    }
+}
diff --git a/tests/Feature/ImportExport/HelperTrait.php b/tests/Feature/ImportExport/HelperTrait.php
index 2b985453e7..f10061833a 100644
--- a/tests/Feature/ImportExport/HelperTrait.php
+++ b/tests/Feature/ImportExport/HelperTrait.php
@@ -75,12 +75,14 @@ public function export($model, $exporterClass, $options = null, $ignoreExplicitE
         return $exporter->payload();
     }
 
-    public function import($payload, $options = null)
+    public function import($payload, $options = null, $logger = null)
     {
         $options = $options ?: new Options([]);
-        $importer = new Importer($payload, $options);
+        $importer = new Importer($payload, $options, $logger);
         $importer->previewImport();
         $importer->doImport();
+
+        return $importer;
     }
 
     public function makeOptions($options = [])
diff --git a/webpack.mix.js b/webpack.mix.js
index 39dfe16484..bb38ecedd0 100644
--- a/webpack.mix.js
+++ b/webpack.mix.js
@@ -122,6 +122,7 @@ mix
   .js("resources/js/processes/scripts/preview.js", "public/js/processes/scripts")
   .js("resources/js/processes/export/index.js", "public/js/processes/export")
   .js("resources/js/processes/environment-variables/index.js", "public/js/processes/environment-variables")
+  .js("resources/js/processes/environment-variables/edit.js", "public/js/processes/environment-variables")
   .js("resources/js/processes/import/index.js", "public/js/processes/import")
   .js("resources/js/processes/screens/index.js", "public/js/processes/screens")
   .js("resources/js/processes/screens/edit.js", "public/js/processes/screens")