anchor.diff:                  return! subscription.CompleteAsync(token.MessageLockId)
           }
   
  -and [<AutoSerializable(true)>] 
  -    JobLeaseToken private (configurationId : ConfigurationId, jobId : string, 
  -                            messageLockId : Guid, parentJobId : string, 
  -                            offset : int64 option, targetWorker : string option, 
  -                            deliveryCount : int, dequeueTime : DateTimeOffset) = 
  -
  -    member this.ConfigurationId = configurationId
  -    member this.TargetWorker = targetWorker
  -    member this.MessageLockId = messageLockId
  -    member this.DeliveryCount = deliveryCount
  -    member this.ParentJobId = parentJobId
  -    member ths.Id = jobId
  -    member this.DequeueTime = dequeueTime
  +[<AutoSerializable(true); DataContract>]
  +type JobLeaseToken private (info : JobLeaseTokenInfo)  = 
  +    let [<DataMember(Name="info")>] info = info
  +
  +    member ths.Id               = info.JobId
  +    member this.ConfigurationId = info.ConfigurationId
  +    member this.TargetWorker    = info.TargetWorker
  +    member this.MessageLockId   = info.MessageLockId
  +    member this.DeliveryCount   = info.DeliveryCount
  +    member this.ParentJobId     = info.ParentJobId
  +    member this.DequeueTime     = info.DequeueTime
   
       interface ICloudJobLeaseToken with
  -        member this.DeclareCompleted() : Async<unit> = JobLeaseMonitor.Complete(this)
  +        member this.DeclareCompleted() : Async<unit> = 
  +            async {
  +                do! JobLeaseMonitor.Complete(info)
  +                let record = new JobRecord(info.ParentJobId, info.JobId)
  +                record.Status <- nullable(int JobStatus.Completed)
  +                record.CompletionTime <- nullable(DateTimeOffset.Now)
  +                let! _record = Table.merge info.ConfigurationId info.ConfigurationId.RuntimeTable record
  +                return ()
  +            }
           
           member this.DeclareFaulted(arg1 : ExceptionDispatchInfo) : Async<unit> = 
               async { 
  -                // TODO : Update record
  -                return! JobLeaseMonitor.Complete(this) }
  +                do! JobLeaseMonitor.Complete(info)
  +                let record = new JobRecord(info.ParentJobId, info.JobId)
  +                record.Status <- nullable(int JobStatus.Faulted)
  +                record.CompletionTime <- nullable(DateTimeOffset.Now)
  +                let! _record = Table.merge info.ConfigurationId info.ConfigurationId.RuntimeTable record
  +                return () 
  +            }
           
           member this.FaultInfo : JobFaultInfo = failwith "Not implemented yet"
           
           member this.GetJob() : Async<CloudJob> = 
               async { 
  -                let blob = Blob.FromPath(configurationId, parentJobId, jobId)
  +                let blob = Blob.FromPath(info.ConfigurationId, info.ParentJobId, info.JobId)
                   use! stream = blob.OpenRead()
                   let _pos = 
  -                    match offset with
  +                    match info.Offset with
                       | Some pos -> stream.Seek(pos, SeekOrigin.Begin)
                       | _ -> 0L
                   return Configuration.Pickler.Deserialize<CloudJob>(stream)
               }
           
  -        member this.Id : string = jobId
  +        member this.Id : string = info.JobId
           
           member this.JobType : JobType = failwith "Not implemented yet"
           
           member this.Size : int64 = failwith "Not implemented yet"
           
           member this.TargetWorker : IWorkerId option = 
  -            match targetWorker with
  +            match info.TargetWorker with
               | None -> None
               | Some w -> Some(WorkerId(w) :> _)
           
  -        member this.TaskEntry : ICloudTaskCompletionSource = TaskCompletionSource(configurationId, parentJobId) :> _
  +        member this.TaskEntry : ICloudTaskCompletionSource = TaskCompletionSource(info.ConfigurationId, info.ParentJobId) :> _
           
           member this.Type : string = failwith "Not implemented yet"
       
  
positive.code:         let lockToken = message.LockToken
          let body = message.GetBody<string>()
          let dequeueTime = DateTimeOffset.Now
          new JobLeaseToken(config, body, lockToken, parentId, streamPos, affinity, deliveryCount, dequeueTime)
  
  
  /// Local queue subscription client
  [<AutoSerializable(false)>]
  
negative.code:                              }
                           renewLoop())
      
      static member Complete(token : JobLeaseTokenInfo) : Async<unit> = 
          async { 
              let config = token.ConfigurationId
              match token.TargetWorker with
  