Create an object with a return value

First return num; has no effect in your code. The object returned by the function is this. If a constructor function does not return an object explicitly, it will always implicitly return this (see step 3 in the MDN documentation).

That said, there are two methods you could override, namely, toString ^[MDN] and valueOf ^[MDN]:

function MyNumber(n){
  this.num = n;
}

MyNumber.prototype.add = function(x){
    return this.num + x; // or `this + x` since we implemented `valueOf`
};

// Is called whenever the object has to be converted to a string
// e.g. alert(myNumber) ; myNumber + " is the answer to all questions"
MyNumber.prototype.toString = function() {
    return this.valueOf().toString(); // or `this.num.toString()`
};

// Is called whenever the object has to be converted to a primitive value
// e.g. myNumber + 42 ; myNumber == 42
MyNumber.prototype.valueOf = function() {
    return this.num;
};

The added benefit of overwriting valueOf is that JavaScript will call this method also internally the convert to object to a primitive value.

For example, using an instance as operand in normal addition would work too (instead of calling .add):

> var n = new MyNumber(7);
> n + 10
  17

That said, if you just want to create a wrapper for primitive types, then don't do that.

As pimvdb mentions in his comment, strict comparison would fail (for example). That is to be expected and one of the reasons why to avoid the object versions of primitive values (Number, String, Boolean) (i.e. "foo" === new String("foo") is false as well). Objects simply don't behave like primitives and mixing these creates more complicated code.

To be able to reuse the Number you'll need to return the reference to the function in the constructor:

var number = function(n) {

  var num = n;

  this.add = function(x){
    return num + x;
  };

  this.value = function() {
      return num;
  };
}

Override toString:

number = function(n){

  var num = n;

  this.add = function(x){
    return num + x;
  };

  this.toString = function(){
    return num;
  };

  return num;

}

If I get this right, you want an object to behave as, well, an object except for when it is passed to a function? the variable seven in your example is an object, so there's no way it'll simply return 7 when referenced anywhere.

What's more, num is essentially a private variable. So using for...in and JSON.stringify trickery won't do you any good. What you should do is either make the num variable an object property (this.num) or create a member function (this.getNum(){return num};).

After that, you can use the property/method freely:

alert(seven.num);//alerts 7, but requires num to be declared as a property
alert(seven.getNum());//alerts 7, requires the method

I'd suggest using a method in this case, since you're obviously using this function both as a constructor and a regular function (Which, might I add, isn't a very good idea).
On a slightly pedantic note: it is custom to capitalize the first letter of a constructor, and not to use names that might collide with JS native types (String, Number, Object, Function...)

function MyNumber(n)
{
    this.num = n;//as a property
    this.add = function(x)
    {
        return this.num + x;
    }
}

var seven = new MyNumber(7);
alert(seven.num);//alerts 7

Though, if num shouldn't be altered -I'm guessing that's the case here- an extra function is the route I'd take:

function MyNumber(n)
{
    var num = n;
    this.add = function(x)
    {
        return num + x;
    };
    this.getNum = function()
    {
        return num;
    };
}
alert(seven.getNum());

If you're still planning on using the constructor as a regular function, you're best of checking how the function/constructor was called:

function MyNumber(n)
{
    var num = n;
    if (!(this instanceof MyNumber))
    {//not called as constructor
        return num;//or a function, or something else (treat this as a closure)
    }
    //Same code as above goes here
}

I might be going a bit off topic here, but I can't help but think that you might want to read up on closures, objects and constructors in JavaScript.