diff --git a/README.md b/README.md
new file mode 120000
index 0000000..ac8bf0b
--- /dev/null
+++ b/README.md
@@ -0,0 +1 @@
+src/main/resources/Documentation/about.md
\ No newline at end of file
diff --git a/src/main/java/com/amd/gerrit/plugins/manifestsubscription/ManifestSubscription.java b/src/main/java/com/amd/gerrit/plugins/manifestsubscription/ManifestSubscription.java
new file mode 100644
index 0000000..0376815
--- /dev/null
+++ b/src/main/java/com/amd/gerrit/plugins/manifestsubscription/ManifestSubscription.java
@@ -0,0 +1,447 @@
+// Copyright (C) 2015 Advanced Micro Devices, Inc.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.amd.gerrit.plugins.manifestsubscription;
+
+import com.amd.gerrit.plugins.manifestsubscription.manifest.Manifest;
+import com.google.common.collect.*;
+import com.google.gerrit.extensions.annotations.PluginName;
+import com.google.gerrit.extensions.events.GitReferenceUpdatedListener;
+import com.google.gerrit.extensions.events.LifecycleListener;
+import com.google.gerrit.reviewdb.client.Project;
+import com.google.gerrit.server.git.GitRepositoryManager;
+import com.google.gerrit.server.git.MetaDataUpdate;
+import com.google.gerrit.server.git.ProjectConfig;
+import com.google.gerrit.server.project.ProjectCache;
+import com.google.inject.Inject;
+import org.eclipse.jgit.errors.ConfigInvalidException;
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.Repository;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.xml.bind.JAXBException;
+import java.io.IOException;
+import java.util.*;
+
+public class ManifestSubscription implements
+    GitReferenceUpdatedListener, LifecycleListener {
+  private static final Logger log =
+      LoggerFactory.getLogger(ManifestSubscription.class);
+
+  private static final String KEY_BRANCH = "branch";
+  private static final String KEY_STORE = "store";
+
+  private static final String STORE_BRANCH_PREFIX = "refs/heads/m/";
+
+  private final String pluginName;
+
+  private final MetaDataUpdate.Server metaDataUpdateFactory;
+  private final GitRepositoryManager gitRepoManager;
+  private final ProjectCache projectCache;
+
+  /**
+   * source project lookup
+   * manifest source project name, plugin config
+   **/
+  private Map<String, PluginProjectConfig> enabledManifestSource = Maps.newHashMap();
+
+  /**
+   * manifest store lookup
+   * repo name, branch (branchPath), Manifest
+   */
+  private Table<String, String, Manifest> manifestStores = HashBasedTable.create();
+
+  /**
+   * lookup
+   * subscribed project name and branch, manifest dest store, <manifest dest branch Project>
+   **/
+  private Table<ProjectBranchKey, String, Map<String, Set<
+      com.amd.gerrit.plugins.manifestsubscription.manifest.Project>>> subscribedRepos = HashBasedTable.create();
+
+  public Set<String> getEnabledManifestSource() {
+    return ImmutableSet.copyOf(enabledManifestSource.keySet());
+  }
+
+  public Set<ProjectBranchKey> getSubscribedProjects() {
+    return ImmutableSet.copyOf(subscribedRepos.rowKeySet());
+  }
+
+  @Override
+  public void start() {
+    ProjectConfig config;
+    for (Project.NameKey p : projectCache.all()) {
+      //TODO parallelize parsing/load up?
+      try {
+        config = ProjectConfig.read(metaDataUpdateFactory.create(p));
+        loadStoreFromProjectConfig(p.toString(), config);
+
+      } catch (IOException | ConfigInvalidException | JAXBException e) {
+        log.error(e.toString());
+        e.printStackTrace();
+      }
+    }
+  }
+
+  @Override
+  public void stop() {
+
+  }
+
+  @Inject
+  ManifestSubscription(MetaDataUpdate.Server metaDataUpdateFactory,
+                       GitRepositoryManager gitRepoManager,
+                       @PluginName String pluginName,
+                       ProjectCache projectCache) {
+    this.metaDataUpdateFactory = metaDataUpdateFactory;
+    this.gitRepoManager = gitRepoManager;
+    this.pluginName = pluginName;
+    this.projectCache = projectCache;
+  }
+
+  @Override
+  public void onGitReferenceUpdated(Event event) {
+    String projectName = event.getProjectName();
+    String refName = event.getRefName();
+    String branchName = refName.startsWith("refs/heads/") ?
+        refName.substring(11) : "";
+    ProjectBranchKey pbKey = new ProjectBranchKey(projectName, branchName);
+
+    if ("refs/meta/config".equals(refName)) {
+      // possible change in enabled repos
+      processProjectConfigChange(event);
+    } else if (enabledManifestSource.containsKey(projectName) &&
+        enabledManifestSource.get(projectName)
+            .getBranches().contains(branchName)) {
+      processManifestChange(event, projectName, branchName);
+
+    } else if (subscribedRepos.containsRow(pbKey)) {
+      // Manifest store and branch
+      Map<String, Map<String, Set<
+          com.amd.gerrit.plugins.manifestsubscription.manifest.Project>>>
+          destinations = subscribedRepos.row(pbKey);
+
+      for (String store : destinations.keySet()) {
+        for (String storeBranch : destinations.get(store).keySet()) {
+          Set<com.amd.gerrit.plugins.manifestsubscription.manifest.Project> ps
+              = destinations.get(store).get(storeBranch);
+
+          Manifest manifest = manifestStores.get(store, storeBranch);
+          // these are project from the above manifest previously
+          // cached in the lookup table
+          for (com.amd.gerrit.plugins.manifestsubscription.manifest.Project
+              updateProject : ps) {
+            updateProject.setRevision(event.getNewObjectId());
+          }
+
+          try {
+            updateManifest(store, STORE_BRANCH_PREFIX + storeBranch, manifest);
+          } catch (JAXBException | IOException e) {
+            e.printStackTrace();
+          }
+
+        }
+      }
+
+      //updates in subscribed repos
+    }
+
+
+  }
+
+  private void updateProjectRev(String projectName, String branch, String rev,
+                                List<com.amd.gerrit.plugins.
+                                    manifestsubscription.manifest.Project> projects) {
+    //TODO optimize to not have to iterate through manifest?
+    for (com.amd.gerrit.plugins.manifestsubscription.manifest.Project project : projects) {
+      if (Objects.equals(projectName, project.getName()) &&
+          Objects.equals(branch, project.getUpstream())) {
+        project.setRevision(rev);
+      }
+
+      if (project.getProject().size() > 0) {
+        updateProjectRev(projectName, branch, rev, project.getProject());
+      }
+    }
+
+  }
+
+  private void processManifestChange(Event event,
+                                     String projectName, String branchName) {
+    try {
+      VersionedManifests versionedManifests = parseManifests(event);
+      processManifestChange(versionedManifests, projectName, branchName);
+    } catch (JAXBException | IOException | ConfigInvalidException e) {
+      e.printStackTrace();
+    }
+
+  }
+
+  private void processManifestChange(VersionedManifests versionedManifests,
+                                     String projectName, String branchName) {
+    //possible manifest update in subscribing repos
+    //TODO Fix, right now update all manifest every time
+    //TODO even when only one of the manifest has changed
+
+    try {
+      if (versionedManifests != null) {
+        CanonicalManifest cManifest = new CanonicalManifest(versionedManifests);
+        Set<String> manifests = versionedManifests.getManifestPaths();
+        Manifest manifest;
+        String store = enabledManifestSource.get(projectName).getStore();
+        Table<String, String, String> lookup = HashBasedTable.create();
+
+        // Remove old manifest from subscription if destination store and branch
+        // matches manifest source being updated
+        // TODO again, this assume 1-1 map between store and manifest store
+        Map<String,
+            Set<com.amd.gerrit.plugins.manifestsubscription.manifest.Project>> branchPaths;
+        for (Table.Cell<ProjectBranchKey, String,
+            Map<String,
+                Set<com.amd.gerrit.plugins.manifestsubscription.manifest.Project>>> cell :
+            subscribedRepos.cellSet()) {
+          if (store.equals(cell.getColumnKey())) {
+            branchPaths = cell.getValue();
+
+            Iterator<String> iter = branchPaths.keySet().iterator();
+            String branchPath;
+            while (iter.hasNext()) {
+              branchPath = iter.next();
+              if (branchPath.startsWith(branchName)) {
+                iter.remove();
+                manifestStores.remove(store, branchPath);
+              }
+            }
+          }
+        }
+
+        //TODO need to make sure remote is pointing to this server?
+        //TODO this may be impossible
+        //TODO only monitor projects without 'remote' attribute / only using default?
+
+        for (String path : manifests) {
+          String bp = branchName + "/" + path;
+          try {
+            manifest = cManifest.getCanonicalManifest(path);
+
+            VersionedManifests.affixManifest(gitRepoManager, manifest, lookup);
+
+            watchCanonicalManifest(manifest, store, bp);
+            //save manifest
+            //TODO added the m/ to the ref to to work around LOCK_FAILURE error of creating master/bla/bla
+            //TODO (because default master ref already exists) better solution?
+            updateManifest(store, STORE_BRANCH_PREFIX + bp, manifest);
+
+          } catch (ManifestReadException e) {
+            e.printStackTrace();
+          }
+
+        }
+
+      }
+    } catch (JAXBException | IOException e) {
+      e.printStackTrace();
+    }
+
+  }
+
+  private void watchCanonicalManifest(Manifest manifest, String store,
+                                      String branchPath) {
+    String defaultBranch;
+    if (manifest.getDefault() != null &&
+        manifest.getDefault().getRevision() != null) {
+      defaultBranch = manifest.getDefault().getRevision();
+    } else {
+      defaultBranch = "";
+    }
+
+    manifestStores.put(store, branchPath, manifest);
+
+    List<com.amd.gerrit.plugins.manifestsubscription.manifest.Project> projects
+        = manifest.getProject();
+    watchProjectsInCanonicalManifest(store, branchPath, defaultBranch, projects);
+  }
+
+  private void watchProjectsInCanonicalManifest(String store, String branchPath,
+                                                String defaultBranch,
+                                                List<com.amd.gerrit.plugins.manifestsubscription.manifest.Project> projects) {
+    ProjectBranchKey pbKey;
+    for (com.amd.gerrit.plugins.manifestsubscription.manifest.Project project : projects) {
+      if (manifestStores.containsRow(project.getName()) &&
+          !manifestStores.row(project.getName()).isEmpty()) {
+        // Skip if it's one of the repo for storing
+        // manifest to avoid infinite loop
+        // This is a bit too general, but it's done to avoid the complexity
+        // of actually tracing out the loop
+        // i.e. manifest1->store2 --> manifest2->store1
+        continue;
+      }
+
+      // Make sure revision is branch ref w/o refs/heads
+      String branch = project.getRevision() == null ?
+          defaultBranch : (project.getUpstream() != null ?
+          project.getUpstream() : project.getRevision());
+      pbKey = new ProjectBranchKey(project.getName(),
+          Repository.shortenRefName(branch));
+
+
+      //TODO only update manifests that changed
+      if (!subscribedRepos.contains(pbKey, store)) {
+        subscribedRepos.put(pbKey, store,
+            Maps.<String, Set<com.amd.gerrit.plugins.manifestsubscription.manifest.Project>>newHashMap());
+      }
+
+
+      Map<String,
+          Set<com.amd.gerrit.plugins.manifestsubscription.manifest.Project>> ps;
+      ps = subscribedRepos.get(pbKey, store);
+      if (!ps.containsKey(branchPath)) {
+        ps.put(branchPath,
+            Sets.<com.amd.gerrit.plugins.manifestsubscription.manifest.Project>newHashSet());
+      }
+      ps.get(branchPath).add(project);
+
+      if (project.getProject().size() > 0) {
+        watchProjectsInCanonicalManifest(store, branchPath, defaultBranch,
+            project.getProject());
+      }
+    }
+  }
+
+  private void processProjectConfigChange(Event event) {
+    Project.NameKey p = new Project.NameKey(event.getProjectName());
+
+    //TODO test two separate project configured to the same store
+    try {
+      ProjectConfig oldCfg = parseConfig(p, event.getOldObjectId());
+      ProjectConfig newCfg = parseConfig(p, event.getNewObjectId());
+
+      //TODO selectively update changes instead of complete reset
+      if (oldCfg != null) {
+        String oldStore =
+            oldCfg.getPluginConfig(pluginName).getString(KEY_STORE);
+
+        if (oldStore != null && !oldStore.isEmpty()) {
+          //TODO FIX assume unique store for each manifest source (1-1 map)
+          manifestStores.row(oldStore).clear();
+          enabledManifestSource.remove(event.getProjectName());
+
+          Iterator<Table.Cell<ProjectBranchKey, String, Map<String,
+              Set<com.amd.gerrit.plugins.manifestsubscription.manifest.Project>>>> iter =
+              subscribedRepos.cellSet().iterator();
+          while (iter.hasNext()) {
+            if (oldStore.equals(iter.next().getColumnKey())) {
+              iter.remove();
+            }
+          }
+        }
+      }
+
+      if (newCfg != null) {
+        loadStoreFromProjectConfig(event.getProjectName(), newCfg);
+
+      }
+    } catch (IOException | ConfigInvalidException | JAXBException e) {
+      e.printStackTrace();
+    }
+  }
+
+  private void loadStoreFromProjectConfig(String projectName,
+                                          ProjectConfig config)
+      throws JAXBException, IOException, ConfigInvalidException {
+    String newStore =
+        config.getPluginConfig(pluginName).getString(KEY_STORE);
+
+    if (newStore != null) {
+      newStore = newStore.trim();
+      if (!newStore.isEmpty()) {
+        Set<String> branches = Sets.newHashSet(
+            config.getPluginConfig(pluginName)
+                .getStringList(KEY_BRANCH));
+
+        if (branches.size() > 0) {
+          PluginProjectConfig ppc = new PluginProjectConfig(newStore, branches);
+
+          enabledManifestSource.put(projectName, ppc);
+          Project.NameKey nameKey = new Project.NameKey(projectName);
+          VersionedManifests versionedManifests;
+          for (String branch : branches) {
+            versionedManifests = parseManifests(nameKey, branch);
+            processManifestChange(versionedManifests, projectName, branch);
+          }
+        }
+      }
+    }
+  }
+
+  private ProjectConfig parseConfig(Project.NameKey p, String idStr)
+      throws IOException, ConfigInvalidException {
+    ObjectId id = ObjectId.fromString(idStr);
+    if (ObjectId.zeroId().equals(id)) {
+      return null;
+    }
+    return ProjectConfig.read(metaDataUpdateFactory.create(p), id);
+  }
+
+  private VersionedManifests parseManifests(Event event)
+      throws JAXBException, IOException, ConfigInvalidException {
+    Project.NameKey p = new Project.NameKey(event.getProjectName());
+    return parseManifests(p, event.getRefName());
+  }
+
+  private VersionedManifests parseManifests(Project.NameKey p, String refName)
+      throws IOException, JAXBException, ConfigInvalidException {
+
+    MetaDataUpdate update = metaDataUpdateFactory.create(p);
+    VersionedManifests vManifests = new VersionedManifests(refName);
+    vManifests.load(update);
+
+    return vManifests;
+  }
+
+  private void updateManifest(String projectName, String refName,
+                              Manifest manifest)
+      throws JAXBException, IOException {
+    Project.NameKey p = new Project.NameKey(projectName);
+    MetaDataUpdate update = metaDataUpdateFactory.create(p);
+    VersionedManifests vManifests = new VersionedManifests(refName);
+
+    //TODO find a better way to detect no branch
+    boolean refExists = true;
+    try {
+      vManifests.load(update);
+    } catch (Exception e) {
+      refExists = false;
+    }
+
+    if (refExists) {
+      Map<String, Manifest> entry = Maps.newHashMapWithExpectedSize(1);
+      entry.put("default.xml", manifest);
+      vManifests.setManifests(entry);
+      vManifests.commit(update);
+    } else {
+      vManifests = new VersionedManifests("master");
+      try {
+        vManifests.load(update);
+      } catch (ConfigInvalidException e) {
+        e.printStackTrace();
+      }
+      Map<String, Manifest> entry = Maps.newHashMapWithExpectedSize(1);
+      entry.put("default.xml", manifest);
+      vManifests.setManifests(entry);
+      vManifests.commitToNewRef(update, refName);
+    }
+  }
+
+}
diff --git a/src/main/java/com/amd/gerrit/plugins/manifestsubscription/Module.java b/src/main/java/com/amd/gerrit/plugins/manifestsubscription/Module.java
index e73bdf2..ff8c3b0 100644
--- a/src/main/java/com/amd/gerrit/plugins/manifestsubscription/Module.java
+++ b/src/main/java/com/amd/gerrit/plugins/manifestsubscription/Module.java
@@ -14,11 +14,22 @@
 
 package com.amd.gerrit.plugins.manifestsubscription;
 
+import com.google.gerrit.extensions.events.GitReferenceUpdatedListener;
+import com.google.gerrit.extensions.events.LifecycleListener;
+import com.google.gerrit.extensions.registration.DynamicSet;
 import com.google.inject.AbstractModule;
+import com.google.inject.Scopes;
 
 class Module extends AbstractModule {
+
   @Override
   protected void configure() {
-    // TODO
+
+    bind(ManifestSubscription.class).in(Scopes.SINGLETON);
+
+    DynamicSet.bind(binder(), LifecycleListener.class)
+        .to(ManifestSubscription.class);
+    DynamicSet.bind(binder(), GitReferenceUpdatedListener.class)
+        .to(ManifestSubscription.class);
   }
 }
diff --git a/src/main/java/com/amd/gerrit/plugins/manifestsubscription/PluginProjectConfig.java b/src/main/java/com/amd/gerrit/plugins/manifestsubscription/PluginProjectConfig.java
new file mode 100644
index 0000000..bad5797
--- /dev/null
+++ b/src/main/java/com/amd/gerrit/plugins/manifestsubscription/PluginProjectConfig.java
@@ -0,0 +1,43 @@
+// Copyright (C) 2015 Advanced Micro Devices, Inc.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.amd.gerrit.plugins.manifestsubscription;
+
+import java.util.Set;
+
+public class PluginProjectConfig {
+  private String store;
+  private Set<String> branches;
+
+  public PluginProjectConfig(String store, Set<String> branches) {
+    this.store = store;
+    this.branches = branches;
+  }
+
+  public String getStore() {
+    return store;
+  }
+
+  public void setStore(String store) {
+    this.store = store;
+  }
+
+  public Set<String> getBranches() {
+    return branches;
+  }
+
+  public void setBranches(Set<String> branches) {
+    this.branches = branches;
+  }
+}
diff --git a/src/main/java/com/amd/gerrit/plugins/manifestsubscription/ProjectBranchKey.java b/src/main/java/com/amd/gerrit/plugins/manifestsubscription/ProjectBranchKey.java
new file mode 100644
index 0000000..13734c6
--- /dev/null
+++ b/src/main/java/com/amd/gerrit/plugins/manifestsubscription/ProjectBranchKey.java
@@ -0,0 +1,49 @@
+// Copyright (C) 2015 Advanced Micro Devices, Inc.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.amd.gerrit.plugins.manifestsubscription;
+
+import java.util.Objects;
+
+public class ProjectBranchKey {
+  private String project;
+  private String branch;
+
+  public ProjectBranchKey(String project, String branch) {
+    this.project = project;
+    this.branch = branch;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    ProjectBranchKey that = (ProjectBranchKey) o;
+    return Objects.equals(project, that.project) &&
+        Objects.equals(branch, that.branch);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(project, branch);
+  }
+
+  @Override
+  public String toString() {
+    return com.google.common.base.Objects.toStringHelper(this)
+        .add("project", project)
+        .add("branch", branch)
+        .toString();
+  }
+}
diff --git a/src/main/java/com/amd/gerrit/plugins/manifestsubscription/VersionedManifests.java b/src/main/java/com/amd/gerrit/plugins/manifestsubscription/VersionedManifests.java
index 5cf3466..b7ea26e 100644
--- a/src/main/java/com/amd/gerrit/plugins/manifestsubscription/VersionedManifests.java
+++ b/src/main/java/com/amd/gerrit/plugins/manifestsubscription/VersionedManifests.java
@@ -39,6 +39,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 public class VersionedManifests extends VersionedMetaData implements ManifestProvider {
   private String refName;
@@ -50,6 +51,10 @@
     this.manifests = manifests;
   }
 
+  public Set<String> getManifestPaths() {
+    return manifests.keySet();
+  }
+
   public Map<String, Manifest> getManifests() {
     return Collections.unmodifiableMap(manifests);
   }
@@ -88,6 +93,11 @@
     Manifest manifest;
 
     RevWalk rw = new RevWalk(reader);
+
+    // This happens when someone configured a invalid branch name
+    if (getRevision() == null) {
+      throw new ConfigInvalidException(refName);
+    }
     RevCommit r = rw.parseCommit(getRevision());
     TreeWalk treewalk = new TreeWalk(reader);
     treewalk.addTree(r.getTree());
diff --git a/src/main/resources/Documentation/about.md b/src/main/resources/Documentation/about.md
new file mode 100644
index 0000000..ac28edd
--- /dev/null
+++ b/src/main/resources/Documentation/about.md
@@ -0,0 +1,65 @@
+This plugin allows users to monitor git-repo manifests in manifest repositories
+and generate rev-specific manifests (similar to "repo manifest -o") and store
+them to a separate git repository (configurable.)
+
+> **Warning: this plugin is currently under development and is targeting 2.9.1**
+
+The rev-specific manifest of each source manifest is stored in its own branch
+with the following naming convention:
+m/\<source manifest branch\>/\<source manifest path\>
+
+The name of the rev-specific manifest is default.xml
+
+For example, if the source manifests are
+branch: master
+file: default.xml
+file: dev.xml
+file: upstream-mirror.xml
+
+There will be three *branches* in the destination repository with these names:
+m/master/default.xml
+m/master/dev.xml
+m/master/upstream-mirror.xml
+
+If a tag is placed at the start of one of these branches, "git describe" can be
+used to provide system-level version metadata.  One can also use "git bisect" on
+the branches to identify system-level regression.
+
+* Enabled by project.config in the manifest project to be monitored
+* Manifest class is generated from 'repo help manifest' DTD using JAXB
+* \<include\>s are expanded similar to "repo manifest -o" (only works for
+manifests in the same source manifest repository reference by relative path)
+* Supports \<remove-project\>
+* Circular update loop is prevented by not monitoring any of the rev-specific
+manifest repositories
+* Projects in the manifests are assumed to be on the server.  (There is no check
+currently so it's a potential source of error.)
+
+
+```
+xjc -dtd -d gen -p com.amd.gerrit.plugins.manifestsubscription.manifest manifest.dtd
+```
+
+Manifest represent raw XML
+CanonicalManifest resolve <include> and <remove-project>
+
+* TODO: keep parsed manifest in memory for quick lookup
+* TODO: monitor all manifest branch if no branch is specified
+* TODO: ssh command to check what is being monitored
+* TODO: stright mode, only monitor projects using default (no remote)
+* TODO: split mode (store all manifests in same branch strcuture as source instead of flattening the underlying file strcuture)
+* TODO: not monitor non-local projects
+
+* TODO: make sure no circular dependencies (project with manifest subscription is not in the
+manifest being monitored.)
+* TODO: support changes in manifest
+
+* resolve relative path in include
+* supports include tag in manifest
+
+* TODO: check project.config on newkly created project
+
+* TODO: include an external manifest DTD or XML schema/XSD
+* generates/xjc classes from DTD/XSD at build time
+* TODO add test verify include manifest have original project
+* TODO sub dir include manifest have same level include working
diff --git a/src/main/resources/Documentation/config.md b/src/main/resources/Documentation/config.md
index bde3084..78c3ce4 100644
--- a/src/main/resources/Documentation/config.md
+++ b/src/main/resources/Documentation/config.md
@@ -1 +1,11 @@
-TODO: config documentation
+In the manifest project's project.config in refs/meta/config, set the following:
+
+```
+[plugin "manifest-subscription"]
+  store = "repo/name/on/the/server"
+  branch = "branch-being-monitored-in-this-repo"
+  branch = "another-branch-being-monitored-in-this-repo"
+  branch = "master"
+```
+
+There should be only one value for store.  More than one value for branch.
\ No newline at end of file
diff --git a/src/test/java/com/amd/gerrit/plugins/manifestsubscription/VersionedManifestsTest.java b/src/test/java/com/amd/gerrit/plugins/manifestsubscription/VersionedManifestsTest.java
index dff6e8d..2799435 100644
--- a/src/test/java/com/amd/gerrit/plugins/manifestsubscription/VersionedManifestsTest.java
+++ b/src/test/java/com/amd/gerrit/plugins/manifestsubscription/VersionedManifestsTest.java
@@ -46,6 +46,19 @@
     db = createBareRepository();
     util = new TestRepository<>(db);
   }
+  @Test
+  public void testVersionedManifestsReadFromNonManifestGit() throws Exception {
+    RevCommit rev = util.commit(util.tree(
+        util.file("nonxml.txt",
+            util.blob(IOUtils.toByteArray(
+                getClass().getResourceAsStream("/nonxml.txt"))))
+    ));
+
+    VersionedManifests versionedManifests =
+        new VersionedManifests("master");
+
+    versionedManifests.load(db, rev);
+  }
 
   @Test
   public void testVersionedManifestsReadFromGit() throws Exception {