Include 'fixedId' key when printing service ids

runtime/vm/service/service.md

 # Dart VM Service Protocol 0.0
 
 This document describes _version 0.0_ of the Dart VM Service Protocol.
 This protocol is used to communicate with a running Dart Virtual
 Machine.
 
 To use the Service Protocol, start the VM with the *--observe* flag.
 The VM will start a webserver which services protocol requests via WebSocket.
 It is possible to make HTTP (non-WebSocket) requests,
 but this does not allow access to VM _events_ and is not documented
@@ skipping 246 matching lines @@
 
 Many responses returned by the Service Protocol have an _id_ property.
 This is an identifier used to request an object from an isolate using
 the [getObject](#getobject) RPC.  If two responses have the same _id_ then they
 refer to the same object.  The converse is not true: the same object
 may sometimes be returned with two different values for _id_.
 
 The _id_ property should be treated as an opaque string by the client:
 it is not meant to be parsed.
 
-An id can be either _temporary_ or _permanent_:
+An id can be either _temporary_ or _fixed_:
 
 * A _temporary_ id can expire over time.  The VM allocates certain ids
   in a ring which evicts old ids over time.
 
-* A _permanent_ id will never expire, but the object it refers to may
-  be collected.  The VM uses permanent ids for objects like scripts,
+* A _fixed_ id will never expire, but the object it refers to may
+  be collected.  The VM uses fixed ids for objects like scripts,
   libraries, and classes.
 
-TODO: Describe how to distinguish temporary/permanent
+If an id is fixed, the _fixedId_ property will be true. If an id is temporary
+the _fixedId_ property will be omitted.
 
 Sometimes a temporary id may expire.  In this case, some RPCs may return
 an _Expired_ [Sentinel](#sentinel) to indicate this.
 
 The object referred to by an id may be collected by the VM's garbage
 collector.  In this case, some RPCs may return a _Collected_ [Sentinel](#sentinel)
 to indicate this.
 
 Many objects also have a _name_ property.  This is provided so that
 objects can be displayed in a way that a Dart language programmer
@@ skipping 436 matching lines @@
   @Instance|Sentinel value;
 }
 ```
 
 A _BoundField_ represents a field bound to a particular value in an
 _Instance_.
 
 If the field is uninitialized, the _value_ will be the
 _NotInitialized_ [Sentinel](#sentinel).
 
-If the field is being initialized, the _value_ will be the 
+If the field is being initialized, the _value_ will be the
 _BeingInitialized_ [Sentinel](#sentinel).
 
 ### BoundVariable
 
 ```
 class BoundVariable {
   string name;
   @Instance|Sentinel value;
 }
 ```
@@ skipping 92 matching lines @@
   @Class[] classes;
 }
 ```
 
 ### Code
 
 ```
 class @Code extends @Object {
   // A name for this code object.
   string name;
-  
+
   // What kind of code object is this?
   CodeKind kind;
 }
 ```
 
 _@Code_ is a reference to a _Code_ object.
 
 ```
 class @Code extends @Object {
   // A name for this code object.
   string name;
-  
+
   // What kind of code object is this?
   CodeKind kind;
 }
 ```
 
 A _Code_ object represents compiled code in the Dart VM.
 
 ### CodeCoverage
 
 TODO
@@ skipping 631 matching lines @@
 
 We use a _Sentinel_ instead of an [error](#errors) for these cases because
 they do not represent a problematic condition.  They are normal.
 
 ### SentinelType
 
 ```
 enum SentinelType {
   // Indicates that the object referred to has been collected by the GC.
   Collected,
-  
+
   // Indicates that an object id has expired.
   Expired,
-  
+
   // Indicates that a variable or field has not been initialized.
   NotInitialized,
-  
+
   // Indicates that a variable or field is in the process of being initialized.
   BeingInitialized,
-  
+
   // Indicates that a variable has been eliminated by the optimizing compiler.
   OptimizedOut
 }
 ```
 
 A _SentinelType_ is used to distinguish different kinds of _Sentinel_ objects.
 
 ### Script
 
 ```
@@ skipping 166 matching lines @@
   string name;
 }
 ```
 
 _@TypeArguments_ is a reference to a _TypeArguments_ object.
 
 ```
 class TypeArguments extends Object {
   // A name for this type argument list.
   string name;
-  
+
   // A list of types.
   @Type[] types;
 }
 ```
 
 A _TypeArguments_ object represents the type argument vector for some
 instantiated generic type.
 
 ### Response
 
@@ skipping 53 matching lines @@
   // A list of isolates running in the VM.
   @Isolate[] isolates
 }
 ```
 
 ## Revision History
 
 version | comments
 ------- | --------
 0.0 | draft