diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..d8b8329
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,7 @@
+*.iml
+/.DS_Store
+/.gradle
+/.idea
+/build
+/captures
+/local.properties
diff --git a/bakutoolkit/.gitignore b/bakutoolkit/.gitignore
new file mode 100644
index 0000000..796b96d
--- /dev/null
+++ b/bakutoolkit/.gitignore
@@ -0,0 +1 @@
+/build
diff --git a/bakutoolkit/build.gradle b/bakutoolkit/build.gradle
new file mode 100644
index 0000000..492104f
--- /dev/null
+++ b/bakutoolkit/build.gradle
@@ -0,0 +1,70 @@
+apply plugin: 'com.android.library'
+/*
+You might have to download JDK8 and set JAVA8_HOME (or set the jdk to Java 8 via Project Structure).
+For detailed instructions, see https://github.com/evant/gradle-retrolambda
+ */
+apply plugin: 'me.tatarka.retrolambda'
+
+android {
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+    compileSdkVersion 21
+    buildToolsVersion "21.1.2"
+
+    defaultConfig {
+        minSdkVersion 21
+        targetSdkVersion 21
+        versionCode 1
+        versionName "1.0"
+    }
+}
+
+dependencies {
+    provided(
+            /* If the application wishes to use support libraries, it should include them as compile
+            dependencies in its own build.gradle. */
+            'com.android.support:appcompat-v7:23.0.1',
+
+            'org.glassfish:javax.annotation:10.0-b28',
+            /*
+            https://projectlombok.org/setup/android.html
+            Follow Android Studio instructions at the bottom of the page to install the Lombok
+            Plugin.
+             */
+            'org.projectlombok:lombok:1.16.6',
+            'org.slf4j:slf4j-api:1.7.12'
+    )
+
+
+    testCompile(
+            'org.mockito:mockito-core:1.10.19',
+            'org.powermock:powermock-module-junit4:1.6.3',
+            'org.slf4j:slf4j-simple:1.7.12'
+    )
+
+    testCompile('org.powermock:powermock-api-mockito:1.6.3') {
+        exclude module: 'mockito-all'
+    }
+
+    compile(
+            //'com.android.support:appcompat-v7:23.1.0',
+            'com.jakewharton.rxbinding:rxbinding:0.3.0',
+            'io.reactivex:rxandroid:1.0.1',
+            'io.reactivex:rxjava:1.0.16',
+            'io.reactivex:rxjava-async-util:0.21.0',
+            'io.v:vanadium:0.1',
+            'io.v:vanadium-android:0.1',
+            'net.sourceforge.streamsupport:streamsupport:1.3.2'
+    )
+    compile fileTree(dir: 'libs', include: ['*.jar'])
+
+    /*
+    Word of caution: for local unit tests, Android log statements fail with
+    UnsatisfiedLinkError (hence the slf4j-simple implementation for testCompile).
+
+    Applications should include a suitable runtime binding, such as
+    apk ('org.slf4j:slf4j-android:1.7.12')
+    */
+}
diff --git a/bakutoolkit/proguard-rules.pro b/bakutoolkit/proguard-rules.pro
new file mode 100644
index 0000000..25805d2
--- /dev/null
+++ b/bakutoolkit/proguard-rules.pro
@@ -0,0 +1,17 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in /usr/local/google/home/rosswang/.android-sdk/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
diff --git a/bakutoolkit/src/androidTest/java/io/v/baku/toolkit/ApplicationTest.java b/bakutoolkit/src/androidTest/java/io/v/baku/toolkit/ApplicationTest.java
new file mode 100644
index 0000000..d9ffa3f
--- /dev/null
+++ b/bakutoolkit/src/androidTest/java/io/v/baku/toolkit/ApplicationTest.java
@@ -0,0 +1,13 @@
+package io.v.baku.toolkit;
+
+import android.app.Application;
+import android.test.ApplicationTestCase;
+
+/**
+ * <a href="http://d.android.com/tools/testing/testing_android.html">Testing Fundamentals</a>
+ */
+public class ApplicationTest extends ApplicationTestCase<Application> {
+    public ApplicationTest() {
+        super(Application.class);
+    }
+}
\ No newline at end of file
diff --git a/bakutoolkit/src/lombok.config b/bakutoolkit/src/lombok.config
new file mode 100644
index 0000000..6c54391
--- /dev/null
+++ b/bakutoolkit/src/lombok.config
@@ -0,0 +1,5 @@
+# This works for compile but not in the IDE; use @Accessors(prefix = "m") instead.
+lombok.accessors.prefix += m
+
+# Required for Android Studio
+lombok.anyConstructor.suppressConstructorProperties = true
diff --git a/bakutoolkit/src/main/AndroidManifest.xml b/bakutoolkit/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..5916f9b
--- /dev/null
+++ b/bakutoolkit/src/main/AndroidManifest.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="io.v.baku.toolkit">
+
+    <application
+        android:allowBackup="true"
+        android:label="@string/app_name"
+        android:supportsRtl="true">
+        <service
+            android:name="io.v.debug.SyncbaseAndroidService"
+            android:enabled="true"
+            android:exported="true" />
+
+    </application>
+
+</manifest>
diff --git a/bakutoolkit/src/main/java/io/v/baku/toolkit/BakuActivity.java b/bakutoolkit/src/main/java/io/v/baku/toolkit/BakuActivity.java
new file mode 100644
index 0000000..1c0f34d
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/baku/toolkit/BakuActivity.java
@@ -0,0 +1,50 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.baku.toolkit;
+
+import android.os.Bundle;
+import android.os.PersistableBundle;
+
+import io.v.baku.toolkit.bind.SyncbaseBinding;
+import lombok.Getter;
+import lombok.experimental.Accessors;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * A default application of {@link BakuActivityTrait} extending {@link android.app.Activity}. Most
+ * activities with distributed state should inherit from this.
+ */
+@Accessors(prefix = "m")
+@Slf4j
+public abstract class BakuActivity extends VActivity implements BakuActivityMixin {
+    @Getter
+    private BakuActivityTrait mBakuActivityTrait;
+
+    protected BakuActivityTrait createBakuActivityTrait() {
+        return new BakuActivityTrait(getVAndroidContextTrait());
+    }
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        mBakuActivityTrait = createBakuActivityTrait();
+    }
+
+    @Override
+    public void onCreate(Bundle savedInstanceState, PersistableBundle persistentState) {
+        super.onCreate(savedInstanceState, persistentState);
+        mBakuActivityTrait = createBakuActivityTrait();
+    }
+
+    @Override
+    protected void onDestroy() {
+        mBakuActivityTrait.close();
+        super.onDestroy();
+    }
+
+    public <T> SyncbaseBinding.Builder<T> binder() {
+        return getBakuActivityTrait().binder();
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/baku/toolkit/BakuActivityMixin.java b/bakutoolkit/src/main/java/io/v/baku/toolkit/BakuActivityMixin.java
new file mode 100644
index 0000000..0362740
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/baku/toolkit/BakuActivityMixin.java
@@ -0,0 +1,12 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.baku.toolkit;
+
+/**
+ * An optional convenience interface for classes mixing in {@link BakuActivityTrait}.
+ */
+public interface BakuActivityMixin {
+    BakuActivityTrait getBakuActivityTrait();
+}
diff --git a/bakutoolkit/src/main/java/io/v/baku/toolkit/BakuActivityTrait.java b/bakutoolkit/src/main/java/io/v/baku/toolkit/BakuActivityTrait.java
new file mode 100644
index 0000000..72ab3d0
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/baku/toolkit/BakuActivityTrait.java
@@ -0,0 +1,88 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.baku.toolkit;
+
+import android.app.Activity;
+
+import io.v.baku.toolkit.bind.SyncbaseBinding;
+import io.v.rx.syncbase.GlobalUserSyncgroup;
+import io.v.rx.syncbase.RxDb;
+import io.v.rx.syncbase.RxSyncbase;
+import io.v.rx.syncbase.RxTable;
+import lombok.Getter;
+import lombok.experimental.Accessors;
+import lombok.extern.slf4j.Slf4j;
+import rx.subscriptions.CompositeSubscription;
+
+/**
+ * Activity trait for activities with distributed UI state. By default, shared state is stored
+ * in Syncbase under <i>app.package.name</i>/db/ui.
+ * <p>
+ * Default activity extensions incorporating this mix-in are available:
+ * <ul>
+ * <li>{@link BakuActivity} (extends {@link Activity})</li>
+ * <li>{@link BakuAppCompatActivity} (extends {@link android.support.v7.app.AppCompatActivity})</li>
+ * </ul>
+ * Since Java doesn't actually support multiple inheritance, clients requiring custom inheritance
+ * hierarchies will need to wire in manually, like any of the examples above.
+ */
+@Accessors(prefix = "m")
+@Slf4j
+public class BakuActivityTrait implements AutoCloseable {
+    @Getter
+    private final VAndroidContextTrait<? extends Activity> mVAndroidContextTrait;
+
+    @Getter
+    private final RxSyncbase mSyncbase;
+    @Getter
+    private final RxDb mSyncbaseDb;
+    @Getter
+    private final RxTable mSyncbaseTable;
+    @Getter
+    private final CompositeSubscription mSubscriptions;
+
+    public BakuActivityTrait(final VAndroidContextTrait<? extends Activity> vAndroidContextTrait) {
+        mVAndroidContextTrait = vAndroidContextTrait;
+
+        mSubscriptions = new CompositeSubscription();
+        mSyncbase = new RxSyncbase(vAndroidContextTrait);
+
+        final String app = getSyncbaseAppName(),
+                db = getSyncbaseDbName(),
+                t = getSyncbaseTableName();
+        log.info("Mapping Syncbase path: {}/{}/{}", app, db, t);
+        mSyncbaseDb = mSyncbase.rxApp(app).rxDb(db);
+        mSyncbaseTable = mSyncbaseDb.rxTable(t);
+
+        GlobalUserSyncgroup.forActivity(this).join();
+    }
+
+    @Override
+    public void close() {
+        mSubscriptions.unsubscribe();
+        mSyncbase.close();
+    }
+
+    protected String getSyncbaseAppName() {
+        return mVAndroidContextTrait.getAndroidContext().getPackageName();
+    }
+
+    protected String getSyncbaseDbName() {
+        return "db";
+    }
+
+    public String getSyncbaseTableName() {
+        return "ui";
+    }
+
+    public void onSyncError(final Throwable t) {
+        mVAndroidContextTrait.getErrorReporter().onError(R.string.err_sync, t);
+    }
+
+    public <T> SyncbaseBinding.Builder<T> binder() {
+        return SyncbaseBinding.<T>builder()
+                .bakuActivity(this);
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/baku/toolkit/BakuAppCompatActivity.java b/bakutoolkit/src/main/java/io/v/baku/toolkit/BakuAppCompatActivity.java
new file mode 100644
index 0000000..b6ecdee
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/baku/toolkit/BakuAppCompatActivity.java
@@ -0,0 +1,51 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.baku.toolkit;
+
+import android.os.Bundle;
+import android.os.PersistableBundle;
+
+import io.v.baku.toolkit.bind.SyncbaseBinding;
+import lombok.Getter;
+import lombok.experimental.Accessors;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * A default application of {@link BakuActivityTrait} extending
+ * {@link android.support.v7.app.AppCompatActivity}.
+ */
+@Accessors(prefix = "m")
+@Slf4j
+public abstract class BakuAppCompatActivity
+        extends VAppCompatActivity implements BakuActivityMixin {
+    @Getter
+    private BakuActivityTrait mBakuActivityTrait;
+
+    protected BakuActivityTrait createBakuActivityTrait() {
+        return new BakuActivityTrait(getVAndroidContextTrait());
+    }
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        mBakuActivityTrait = createBakuActivityTrait();
+    }
+
+    @Override
+    public void onCreate(Bundle savedInstanceState, PersistableBundle persistentState) {
+        super.onCreate(savedInstanceState, persistentState);
+        mBakuActivityTrait = createBakuActivityTrait();
+    }
+
+    @Override
+    protected void onDestroy() {
+        mBakuActivityTrait.close();
+        super.onDestroy();
+    }
+
+    public <T> SyncbaseBinding.Builder<T> binder() {
+        return getBakuActivityTrait().binder();
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/baku/toolkit/BlessedActivityTrait.java b/bakutoolkit/src/main/java/io/v/baku/toolkit/BlessedActivityTrait.java
new file mode 100644
index 0000000..bfbbbd5
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/baku/toolkit/BlessedActivityTrait.java
@@ -0,0 +1,145 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.baku.toolkit;
+
+import android.app.Activity;
+
+import io.v.android.libs.security.BlessingsManager;
+import io.v.android.v23.services.blessing.BlessingCreationException;
+import io.v.v23.security.Blessings;
+import io.v.v23.verror.VException;
+import lombok.Getter;
+import lombok.Synchronized;
+import lombok.experimental.Accessors;
+import lombok.extern.slf4j.Slf4j;
+import rx.Observable;
+import rx.subjects.PublishSubject;
+
+@Accessors(prefix = "m")
+@Slf4j
+public class BlessedActivityTrait implements BlessingsProvider {
+    @Getter
+    private final Activity mActivity;
+    @Getter
+    private final ErrorReporter mErrorReporter;
+
+    /**
+     * An observable that, when subscribed to, refreshes the blessing. If the account manager needs
+     * to be invoked for the refresh, the subscription will not produce results until the invocation
+     * completes. Subsequently, it will receive all blessings refreshed via
+     * {@link #refreshBlessings()} and other subscriptions to {@link #getRxBlessings()}.
+     */
+    @Getter
+    private final Observable<Blessings> mRxBlessings;
+    /**
+     * An observable for the blessings that does not refresh when subscribed to. Upon subscription,
+     * this will produce the last known blessing. It will subsequently receive all blessings
+     * refreshed via {@link #refreshBlessings()} and subscriptions to {@link #getRxBlessings()}.
+     */
+    @Getter
+    private final Observable<Blessings> mPassiveRxBlessings;
+
+    private final PublishSubject<Observable<Blessings>> mPub;
+    private Blessings mLastBlessings;
+    private Observable<Blessings> mCurrentSeek;
+    private final Object mSeekLock = new Object();
+
+    public BlessedActivityTrait(final Activity activity, final ErrorReporter errorReporter) {
+        mActivity = activity;
+        mErrorReporter = errorReporter;
+
+        mPub = PublishSubject.create();
+        mPassiveRxBlessings = Observable.switchOnNext(mPub)
+                .distinctUntilChanged()
+                .replay(1).autoConnect();
+        /* It might make more sense for b -> mLastBlessings = b to be an onNext before the above
+        replay rather than a subscription (especially if we start getting
+        OnErrorNotImplementedException or have to include a possibly redundant error reporter).
+        However, replay, even with autoConnect(0), does not offer backpressure support unless it has
+        subscribers. We can get around this by adding .onBackpressureBuffer(1), but if this turns
+        out to be a better way of doing this, we should submit an issue requesting that
+        OperatorReplay use its buffer size for backpressure. */
+        mPassiveRxBlessings.subscribe(b -> mLastBlessings = b);
+        mRxBlessings = Observable.defer(this::refreshBlessings)
+                .ignoreElements()
+                .concatWith(mPassiveRxBlessings);
+    }
+
+    @Synchronized("mSeekLock")
+    public Observable<Blessings> refreshBlessings() {
+        if (mCurrentSeek != null) {
+            return mCurrentSeek;
+        }
+
+        Blessings mgrBlessings;
+        try {
+            mgrBlessings = BlessingsManager.getBlessings(mActivity.getApplicationContext());
+        } catch (final VException e) {
+            log.warn("Could not get blessings from shared preferences", e);
+            mgrBlessings = null;
+        }
+
+        final Observable<Blessings> nextBlessings;
+
+        if (mgrBlessings == null) {
+            mCurrentSeek = nextBlessings = seekBlessings()
+                    .first() // Longer-lived providers should consider a more direct implementation
+                            // of BlessingsProvider.
+                    .onErrorResumeNext(this::handleBlessingsError)
+                    .doOnNext(this::afterSeekBlessings)
+                    .replay(1).autoConnect();
+        } else {
+            nextBlessings = Observable.just(mgrBlessings);
+        }
+        mPub.onNext(nextBlessings);
+
+        return nextBlessings;
+    }
+
+    protected Observable<Blessings> seekBlessings() {
+        final BlessingRequestFragment brf = new BlessingRequestFragment();
+        mActivity.getFragmentManager().beginTransaction()
+                .add(brf, null)
+                .commit();
+        return brf.getObservable();
+    }
+
+    protected Observable<Blessings> handleBlessingsError(final Throwable t) {
+        if (t instanceof BlessingCreationException) {
+            /* This exception can occur if a user hits "Deny" in Blessings Manager, so don't treat
+            it as an error if we have a fallback. */
+            if (mLastBlessings == null) {
+                mErrorReporter.onError(R.string.err_blessings_required, t);
+            } else {
+                log.warn("Could not create blessings", t);
+            }
+        } else if (t instanceof VException) {
+            mErrorReporter.onError(R.string.err_blessings_decode, t);
+        } else {
+            return Observable.error(t);
+        }
+
+        if (mLastBlessings == null) {
+            mActivity.finish();
+            /* Block while the app exits, as opposed to returning an error that would be reported
+            (redundantly) elsewhere. */
+            return Observable.never();
+        } else {
+            return Observable.just(mLastBlessings);
+        }
+    }
+
+    private void afterSeekBlessings(final Blessings b) {
+        try {
+            BlessingsManager.addBlessings(mActivity.getApplicationContext(), b);
+        } catch (final VException e) {
+            mErrorReporter.onError(R.string.err_blessings_store, e);
+        } finally {
+            synchronized (mSeekLock) {
+                mCurrentSeek = null;
+            }
+        }
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/baku/toolkit/BlessingRequestFragment.java b/bakutoolkit/src/main/java/io/v/baku/toolkit/BlessingRequestFragment.java
new file mode 100644
index 0000000..f046e72
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/baku/toolkit/BlessingRequestFragment.java
@@ -0,0 +1,58 @@
+package io.v.baku.toolkit;
+
+import android.app.Fragment;
+import android.content.Intent;
+import android.os.Bundle;
+
+import io.v.android.v23.services.blessing.BlessingService;
+import io.v.v23.security.Blessings;
+import lombok.Getter;
+import lombok.experimental.Accessors;
+import rx.subjects.ReplaySubject;
+
+/**
+ * Utility fragment for seeking blessings from the Vanadium Account Manager. This fragment is
+ * short-lived, starting the account manager activity in {@link #onCreate(Bundle)} and removing
+ * itself in {@link #onActivityResult(int, int, Intent)}.
+ */
+@Accessors(prefix = "m")
+public class BlessingRequestFragment extends Fragment {
+    private static final int BLESSING_REQUEST = 0;
+
+    @Getter
+    private final ReplaySubject<Blessings> mObservable = ReplaySubject.createWithSize(1);
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        final Intent intent = BlessingService.newBlessingIntent(getActivity());
+        startActivityForResult(intent, BLESSING_REQUEST);
+    }
+
+    @Override
+    public void onDestroy() {
+        mObservable.onCompleted();
+        super.onDestroy();
+    }
+
+    @Override
+    public void onActivityResult(final int requestCode, final int resultCode, final Intent data) {
+        super.onActivityResult(requestCode, resultCode, data);
+
+        switch (requestCode) {
+            case BLESSING_REQUEST:
+                try {
+                    mObservable.onNext(BlessingsUtils.fromActivityResult(resultCode, data));
+                    mObservable.onCompleted();
+                } catch (final Exception e) {
+                    mObservable.onError(e);
+                }
+                getFragmentManager().beginTransaction()
+                        .remove(this)
+                        .commit();
+                break;
+            default:
+        }
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/baku/toolkit/BlessingsProvider.java b/bakutoolkit/src/main/java/io/v/baku/toolkit/BlessingsProvider.java
new file mode 100644
index 0000000..340971e
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/baku/toolkit/BlessingsProvider.java
@@ -0,0 +1,24 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.baku.toolkit;
+
+import io.v.v23.security.Blessings;
+import rx.Observable;
+
+public interface BlessingsProvider {
+    /**
+     * @return the connect-on-subscribe observable that provides blessings. This observable should
+     * subsequently emit the same blessings as {@link #getPassiveRxBlessings()}. It might be simpler
+     * to provide only a passive observable and a refresh method, but the more common use case is to
+     * require up-to-date blessings on subscription.
+     */
+    Observable<Blessings> getRxBlessings();
+
+    /**
+     * @return the passive observable that provides blessings. This observable should emit any
+     * blessings attained through active refreshes or through {@link #getRxBlessings()}.
+     */
+    Observable<Blessings> getPassiveRxBlessings();
+}
diff --git a/bakutoolkit/src/main/java/io/v/baku/toolkit/BlessingsUtils.java b/bakutoolkit/src/main/java/io/v/baku/toolkit/BlessingsUtils.java
new file mode 100644
index 0000000..3567471
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/baku/toolkit/BlessingsUtils.java
@@ -0,0 +1,145 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.baku.toolkit;
+
+import android.content.Intent;
+
+import com.google.common.collect.Collections2;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Maps;
+
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import io.v.android.v23.V;
+import io.v.android.v23.services.blessing.BlessingCreationException;
+import io.v.android.v23.services.blessing.BlessingService;
+import io.v.impl.google.naming.NamingUtil;
+import io.v.v23.context.VContext;
+import io.v.v23.security.BlessingPattern;
+import io.v.v23.security.Blessings;
+import io.v.v23.security.VPrincipal;
+import io.v.v23.security.VSecurity;
+import io.v.v23.security.access.AccessList;
+import io.v.v23.security.access.Constants;
+import io.v.v23.security.access.Permissions;
+import io.v.v23.security.access.Tag;
+import io.v.v23.verror.VException;
+import io.v.v23.vom.VomUtil;
+import java8.util.stream.Collectors;
+import java8.util.stream.Stream;
+import java8.util.stream.StreamSupport;
+import lombok.experimental.UtilityClass;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * Common utilities for blessing and ACL management. In the future, we may want to factor these out
+ * of Baku into the V23 Java libraries.
+ */
+@Slf4j
+@UtilityClass
+public class BlessingsUtils {
+    public static final Pattern DEV_V_IO_USER = Pattern.compile("dev\\.v\\.io:u:([^:]+).*");
+
+    public static final AccessList OPEN_ACL = new AccessList(
+            ImmutableList.of(new BlessingPattern("...")), ImmutableList.of());
+
+    public static final ImmutableSet<Tag>
+            DATA_TAGS = ImmutableSet.of(Constants.READ, Constants.WRITE, Constants.ADMIN),
+            MOUNT_TAGS = ImmutableSet.of(Constants.READ, Constants.RESOLVE, Constants.ADMIN),
+            SYNCGROUP_TAGS = ImmutableSet.of(Constants.READ, Constants.WRITE, Constants.RESOLVE,
+                    Constants.ADMIN, Constants.DEBUG);
+
+    public static final Permissions
+            OPEN_DATA_PERMS = dataPermissions(OPEN_ACL),
+            OPEN_MOUNT_PERMS = mountPermissions(OPEN_ACL);
+
+    public static Blessings fromActivityResult(final int resultCode, final Intent data)
+            throws BlessingCreationException, VException {
+        // The Account Manager will pass us the blessings to use as an array of bytes.
+        return decodeBlessings(BlessingService.extractBlessingReply(resultCode, data));
+    }
+
+    public static Blessings decodeBlessings(final byte[] blessings) throws VException {
+        return (Blessings)VomUtil.decode(blessings, Blessings.class);
+    }
+
+    public static Set<String> getBlessingNames(final VContext ctx, final Blessings blessings) {
+        return ImmutableSet.copyOf(VSecurity.getBlessingNames(V.getPrincipal(ctx), blessings));
+    }
+
+    public static AccessList blessingsToAcl(final VContext ctx, final Blessings blessings) {
+        return new AccessList(ImmutableList.copyOf(Collections2.transform(
+                getBlessingNames(ctx, blessings),
+                s -> new BlessingPattern(s))), //method reference confuses Android Studio
+                ImmutableList.of());
+    }
+
+    public static Stream<String> blessingsToUsernameStream(final VContext ctx,
+                                                           final Blessings blessings) {
+        return StreamSupport.stream(getBlessingNames(ctx, blessings))
+                .map(DEV_V_IO_USER::matcher)
+                .filter(Matcher::matches)
+                .map(m -> m.group(1));
+    }
+
+    /**
+     * This method finds and parses all blessings of the form dev.v.io/u/.... This is different from
+     * the method at https://v.io/tutorials/java/android.html, which can return additional
+     * extensions ("/android").
+     */
+    public static Set<String> blessingsToUsernames(final VContext ctx, final Blessings blessings) {
+        return blessingsToUsernameStream(ctx, blessings).collect(Collectors.toSet());
+    }
+
+    public static String userMount(final String username) {
+        return NamingUtil.join("users", username);
+    }
+
+    public static Stream<String> blessingsToUserMountStream(final VContext ctx, final Blessings blessings) {
+        return blessingsToUsernameStream(ctx, blessings)
+                .map(BlessingsUtils::userMount);
+    }
+
+    public static Set<String> blessingsToUserMounts(final VContext ctx, final Blessings blessings) {
+        return blessingsToUserMountStream(ctx, blessings).collect(Collectors.toSet());
+    }
+
+    public static Permissions homogeneousPermissions(final Set<Tag> tags, final AccessList acl) {
+        return new Permissions(Maps.toMap(Collections2.transform(tags, Tag::getValue), x -> acl));
+    }
+
+    public static Permissions dataPermissions(final AccessList acl) {
+        return homogeneousPermissions(DATA_TAGS, acl);
+    }
+
+    public static Permissions mountPermissions(final AccessList acl) {
+        return homogeneousPermissions(MOUNT_TAGS, acl);
+    }
+
+    public static Permissions syncgroupPermissions(final AccessList acl) {
+        return homogeneousPermissions(SYNCGROUP_TAGS, acl);
+    }
+
+    /**
+     * Standard blessing handling for Vanadium applications:
+     * <ul>
+     *     <li>Provide the given blessings when anybody connects to us.</li>
+     *     <li>Provide these blessings when we connect to other services (for example, when we talk
+     *     to the mounttable).</li>
+     *     <li>Trust these blessings and all the "parent" blessings.</li>
+     * </ul>
+     */
+    public static void assumeBlessings(final VContext vContext, final Blessings blessings)
+            throws VException {
+        log.info("Assuming blessings: " + blessings);
+        final VPrincipal principal = V.getPrincipal(vContext);
+        principal.blessingStore().setDefaultBlessings(blessings);
+        principal.blessingStore().set(blessings, new BlessingPattern("..."));
+        VSecurity.addToRoots(principal, blessings);
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/baku/toolkit/DebugFragment.java b/bakutoolkit/src/main/java/io/v/baku/toolkit/DebugFragment.java
new file mode 100644
index 0000000..ac42765
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/baku/toolkit/DebugFragment.java
@@ -0,0 +1,42 @@
+package io.v.baku.toolkit;
+
+import android.app.Fragment;
+import android.os.Bundle;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+public class DebugFragment extends Fragment {
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setHasOptionsMenu(true);
+    }
+
+    @Override
+    public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
+        inflater.inflate(R.menu.debug, menu);
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        // Can't use a switch statement since IDs are not constant in Android libary modules.
+        final int id = item.getItemId();
+        if (id == R.id.clear_app_data) {
+            DebugUtils.clearAppData(getActivity());
+            return true;
+        } else if (id == R.id.kill_process) {
+            DebugUtils.killProcess(getActivity());
+            return true;
+        } else if (id == R.id.logging) {
+            new DebugLogDialogFragment().show(getFragmentManager(), null);
+            return true;
+        } else {
+            return super.onOptionsItemSelected(item);
+        }
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/baku/toolkit/DebugLogDialogFragment.java b/bakutoolkit/src/main/java/io/v/baku/toolkit/DebugLogDialogFragment.java
new file mode 100644
index 0000000..6e587ab
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/baku/toolkit/DebugLogDialogFragment.java
@@ -0,0 +1,68 @@
+package io.v.baku.toolkit;
+
+
+import android.app.Dialog;
+import android.app.DialogFragment;
+import android.app.FragmentTransaction;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Button;
+
+/**
+ * A {@link DialogFragment} surfacing logging options via a {@link DebugLogPreferenceFragment},
+ * Reset and Restart action buttons, and logcat via a {@link LogCatFragment}.
+ */
+public class DebugLogDialogFragment extends DialogFragment {
+    private static final String DEBUG_LOG_PF_TAG = "DebugLogPreferences";
+
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+        final Dialog dialog = super.onCreateDialog(savedInstanceState);
+        dialog.setTitle(R.string.logging);
+        return dialog;
+    }
+
+    private void wireInEventHandlers(final View view) {
+        final Button reset = (Button) view.findViewById(R.id.debug_log_reset);
+        if (reset != null) {
+            reset.setOnClickListener(v -> ((DebugLogPreferenceFragment) getChildFragmentManager()
+                    .findFragmentByTag(DEBUG_LOG_PF_TAG)).reset());
+        }
+
+        final Button restart = (Button) view.findViewById(R.id.debug_log_restart);
+        if (restart != null) {
+            restart.setOnClickListener(v -> DebugUtils.restartProcess(getActivity()));
+        }
+    }
+
+    @Override
+    public View onCreateView(final LayoutInflater inflater, final ViewGroup container,
+                             final Bundle savedInstanceState) {
+        final View view = inflater.inflate(R.layout.dialog_debug_log, container);
+        wireInEventHandlers(view);
+        return view;
+    }
+
+    private void wireInSubFragments(final Bundle savedInstanceState) {
+        final FragmentTransaction ft = getChildFragmentManager().beginTransaction();
+
+        if (getView().findViewById(R.id.pref_logging_container) != null &&
+                getChildFragmentManager().findFragmentByTag(DEBUG_LOG_PF_TAG) == null) {
+            ft.replace(R.id.pref_logging_container,
+                    new DebugLogPreferenceFragment(),
+                    DEBUG_LOG_PF_TAG);
+        }
+        if (savedInstanceState == null) {
+            ft.replace(R.id.logcat_container, new LogCatFragment());
+        }
+        ft.commit();
+    }
+
+    @Override
+    public void onActivityCreated(final Bundle savedInstanceState) {
+        super.onActivityCreated(savedInstanceState);
+        wireInSubFragments(savedInstanceState);
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/baku/toolkit/DebugLogPreferenceFragment.java b/bakutoolkit/src/main/java/io/v/baku/toolkit/DebugLogPreferenceFragment.java
new file mode 100644
index 0000000..49e2876
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/baku/toolkit/DebugLogPreferenceFragment.java
@@ -0,0 +1,83 @@
+package io.v.baku.toolkit;
+
+
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.preference.Preference;
+import android.preference.PreferenceFragment;
+import android.preference.PreferenceManager;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import io.v.v23.OptionDefs;
+
+/**
+ * A {@link PreferenceFragment} surfacing logging options.
+ * <ul>
+ * <li>VLEVEL - verbosity for vlog</li>
+ * <li>VMODULE - per-module log verbosities</li>
+ * </ul>
+ */
+public class DebugLogPreferenceFragment extends PreferenceFragment
+        implements SharedPreferences.OnSharedPreferenceChangeListener {
+    @Override
+    public void onCreate(final Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        final PreferenceManager pm = getPreferenceManager();
+        pm.setSharedPreferencesName(VAndroidContextTrait.VANADIUM_OPTIONS_SHARED_PREFS);
+        pm.getSharedPreferences().registerOnSharedPreferenceChangeListener(this);
+        createPreferences();
+    }
+
+    private void createPreferences() {
+        addPreferencesFromResource(R.xml.pref_logging);
+        final SharedPreferences sharedPreferences = getPreferenceManager().getSharedPreferences();
+        updateVLevelSummary(sharedPreferences, findPreference(OptionDefs.LOG_VLEVEL));
+        updateVModuleSummary(sharedPreferences, findPreference(OptionDefs.LOG_VMODULE));
+    }
+
+    @Override
+    public View onCreateView(final LayoutInflater inflater, final ViewGroup container,
+                             final Bundle savedInstanceState) {
+        final View view = super.onCreateView(inflater, container, savedInstanceState);
+        view.setBackgroundColor(getResources().getColor(android.R.color.background_light));
+
+        return view;
+    }
+
+    private static void updateVLevelSummary(final SharedPreferences sharedPreferences,
+                                            final Preference pref) {
+        pref.setSummary(VOptionPreferenceUtils.readVLevel(sharedPreferences)
+                .map(Object::toString)
+                .orElse(null));
+    }
+
+    private static void updateVModuleSummary(final SharedPreferences sharedPreferences,
+                                             final Preference pref) {
+        pref.setSummary(VOptionPreferenceUtils.readVModule(sharedPreferences).orElse(null));
+    }
+
+    @Override
+    public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
+        final Preference pref = findPreference(key);
+        if (pref == null) {
+            return;
+        }
+
+        if (OptionDefs.LOG_VLEVEL.equals(key)) {
+            updateVLevelSummary(sharedPreferences, pref);
+        } else if (OptionDefs.LOG_VMODULE.equals(key)) {
+            updateVModuleSummary(sharedPreferences, pref);
+        }
+    }
+
+    public void reset() {
+        getPreferenceManager().getSharedPreferences().edit()
+                .clear()
+                .commit();
+        // The easiest way to resync the preferences seems to be:
+        getPreferenceScreen().removeAll();
+        createPreferences();
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/baku/toolkit/DebugUtils.java b/bakutoolkit/src/main/java/io/v/baku/toolkit/DebugUtils.java
new file mode 100644
index 0000000..fa2f6ac
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/baku/toolkit/DebugUtils.java
@@ -0,0 +1,88 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.baku.toolkit;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.ServiceInfo;
+
+import java.io.IOException;
+
+import lombok.experimental.UtilityClass;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@UtilityClass
+public class DebugUtils {
+    /**
+     * Determines whether the top-level apk was built in debug mode. This is preferable to
+     * {@code BuildConfig.DEBUG} as that is only available per module.
+     */
+    public static boolean isApkDebug(final Context context) {
+        return (context.getApplicationInfo().flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0;
+    }
+
+    /**
+     * Clears all data for this app. This will force the application to close. It would be nice to
+     * be able to schedule a restart as well, but clearing app data clears any scheduled intents.
+     * <p>
+     * When debugging Vanadium applications, this is often useful to clear the app blessings cache
+     * and Syncbase data.
+     */
+    public static void clearAppData(final Context context) {
+        try {
+            Runtime.getRuntime().exec("pm clear " + context.getPackageName());
+        } catch (final IOException e) {
+            if (context instanceof VAndroidContextMixin) {
+                ((VAndroidContextMixin) context).getVAndroidContextTrait()
+                        .getErrorReporter()
+                        .onError(R.string.err_app_clear, e);
+            } else {
+                log.error("Unable to clear app data", e);
+            }
+        }
+    }
+
+    public static void stopPackageServices(final Context context) {
+        final PackageInfo pkg;
+        try {
+            pkg = context.getPackageManager().getPackageInfo(context.getPackageName(),
+                    PackageManager.GET_SERVICES);
+        } catch (final PackageManager.NameNotFoundException e) {
+            log.warn("Unable to enumerate package components", e);
+            return;
+        }
+
+        for (final ServiceInfo svc : pkg.services) {
+            context.stopService(new Intent().setClassName(context, svc.name));
+        }
+    }
+
+    /**
+     * Terminates the JVM for this app. When debugging Vanadium applications, this is useful for
+     * terminating any long-lived Android services that might be attached to the app process
+     * (e.g. Syncbase).
+     * <p>
+     * This additionally stops all services defined in the (merged) package manifest before
+     * terminating the process. Services default to {@link android.app.Service#START_STICKY}/{@link
+     * android.app.Service#START_STICKY_COMPATIBILITY}, which would result in started services
+     * auto-restarting after process termination. This could lead to unconventional initialization
+     * order, which is not something we necessarily want to exercise while debugging.
+     */
+    public static void killProcess(final Context context) {
+        stopPackageServices(context);
+        System.exit(0);
+    }
+
+    public static void restartProcess(final Context context) {
+        final Intent i = context.getPackageManager().getLaunchIntentForPackage(
+                context.getPackageName());
+        context.startActivity(i);
+        killProcess(context);
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/baku/toolkit/ErrorReporter.java b/bakutoolkit/src/main/java/io/v/baku/toolkit/ErrorReporter.java
new file mode 100644
index 0000000..adceed3
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/baku/toolkit/ErrorReporter.java
@@ -0,0 +1,51 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.baku.toolkit;
+
+import android.content.Context;
+import android.widget.Toast;
+
+import lombok.AllArgsConstructor;
+import lombok.EqualsAndHashCode;
+import lombok.extern.slf4j.Slf4j;
+import rx.android.schedulers.AndroidSchedulers;
+import rx.subjects.PublishSubject;
+import rx.subjects.Subject;
+
+@Slf4j
+public class ErrorReporter {
+    @AllArgsConstructor
+    @EqualsAndHashCode
+    private static class ErrorEntry {
+        private final int summaryStringId;
+        private final Throwable error;
+    }
+
+    private final Context mContext;
+    private final Subject<ErrorEntry, ErrorEntry> mErrors;
+
+    public ErrorReporter(final Context context) {
+        mContext = context;
+
+        mErrors = PublishSubject.create();
+        mErrors.distinctUntilChanged()
+                .onBackpressureBuffer()
+                .observeOn(AndroidSchedulers.mainThread())
+                .subscribe(e -> reportError(e.summaryStringId, e.error),
+                        t -> reportError(R.string.err_misc, t));
+    }
+
+    /**
+     * @param summaryStringId string resource ID for the error summary
+     */
+    public void onError(final int summaryStringId, final Throwable t) {
+        mErrors.onNext(new ErrorEntry(summaryStringId, t));
+    }
+
+    protected void reportError(final int summaryStringId, final Throwable t) {
+        log.error(mContext.getString(summaryStringId), t);
+        Toast.makeText(mContext, summaryStringId, Toast.LENGTH_LONG).show();
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/baku/toolkit/LogCatFragment.java b/bakutoolkit/src/main/java/io/v/baku/toolkit/LogCatFragment.java
new file mode 100644
index 0000000..db0590e
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/baku/toolkit/LogCatFragment.java
@@ -0,0 +1,133 @@
+package io.v.baku.toolkit;
+
+import android.app.ListFragment;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.AbsListView;
+import android.widget.ArrayAdapter;
+import android.widget.ListAdapter;
+import android.widget.ListView;
+
+import com.google.common.base.Throwables;
+
+import org.joda.time.Duration;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.concurrent.TimeUnit;
+
+import lombok.extern.slf4j.Slf4j;
+import rx.Observable;
+import rx.Subscription;
+import rx.android.schedulers.AndroidSchedulers;
+import rx.schedulers.Schedulers;
+
+@Slf4j
+public class LogCatFragment extends ListFragment {
+    private static final int
+            INITIAL_BUFFER = 1024,
+            MAX_SMOOTH_SCROLL = 64;
+    private static final Duration LOGCAT_UPDATE_PERIOD = Duration.millis(100);
+
+    // http://stackoverflow.com/questions/12692103/read-logcat-programmatically-within-application
+    private static final Observable<String> RX_LOG_CAT = Observable.<String>create(subscriber -> {
+        try {
+            final Process process = Runtime.getRuntime().exec("logcat");
+            try (final BufferedReader bufferedReader =
+                         new BufferedReader(new InputStreamReader(process.getInputStream()))) {
+                String line;
+                while (!subscriber.isUnsubscribed() && (line = bufferedReader.readLine()) != null) {
+                    subscriber.onNext(line);
+                }
+            }
+            subscriber.onCompleted();
+        } catch (final IOException e) {
+            subscriber.onError(e);
+        }
+    });
+
+    private Subscription mLogCatSubscription;
+    private boolean mFollow = true;
+    private final AbsListView.OnScrollListener mScrollListener =
+            new AbsListView.OnScrollListener() {
+                private int mPrevious;
+                @Override
+                public void onScrollStateChanged(final AbsListView view, final int scrollState) {
+                }
+
+                @Override
+                public void onScroll(final AbsListView view, final int firstVisibleItem,
+                                     final int visibleItemCount, final int totalItemCount) {
+                    final boolean atBottom = visibleItemCount == 0 ||
+                            firstVisibleItem + visibleItemCount == totalItemCount;
+                    if (firstVisibleItem < mPrevious) {
+                        mFollow = false;
+                    } else if (atBottom) {
+                        mFollow = true;
+                    }
+                    mPrevious = firstVisibleItem;
+                }
+            };
+
+    private ListAdapter createAdapter() {
+        final ArrayList<String> buffer = new ArrayList<>(INITIAL_BUFFER);
+        final ArrayAdapter<String> adapter = new ArrayAdapter<String>(getActivity(),
+                android.R.layout.simple_list_item_1, android.R.id.text1, buffer);
+        mLogCatSubscription = RX_LOG_CAT
+                .buffer(LOGCAT_UPDATE_PERIOD.getMillis(), TimeUnit.MILLISECONDS)
+                .filter(e -> !e.isEmpty())
+                .subscribeOn(Schedulers.io())
+                .onBackpressureBuffer()
+                .observeOn(AndroidSchedulers.mainThread())
+                .subscribe(
+                        s -> {
+                            buffer.addAll(s);
+                            adapter.notifyDataSetChanged();
+                            if (mFollow) {
+                                final ListView listView = getListView();
+                                if (buffer.size() - listView.getLastVisiblePosition() >
+                                        MAX_SMOOTH_SCROLL) {
+                                    listView.setSelection(buffer.size() - 1);
+                                } else {
+                                    listView.smoothScrollToPosition(buffer.size() - 1);
+                                }
+                            }
+                        },
+                        t -> {
+                            buffer.add(Throwables.getStackTraceAsString(t));
+                            log.error("Error while following logs", t);
+                        });
+        return adapter;
+    }
+
+    @Override
+    public void onCreate(final Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setListAdapter(createAdapter());
+    }
+
+    @Override
+    public void onDestroy() {
+        mLogCatSubscription.unsubscribe();
+        super.onDestroy();
+    }
+
+    @Override
+    public View onCreateView(final LayoutInflater inflater, final ViewGroup container,
+                             final Bundle savedInstanceState) {
+        return inflater.inflate(R.layout.logcat, container, false);
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        if (mFollow) {
+            setSelection(getListAdapter().getCount() - 1);
+        }
+        getListView().setOnScrollListener(mScrollListener);
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/baku/toolkit/VActivity.java b/bakutoolkit/src/main/java/io/v/baku/toolkit/VActivity.java
new file mode 100644
index 0000000..e02f1aa
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/baku/toolkit/VActivity.java
@@ -0,0 +1,37 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.baku.toolkit;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.os.PersistableBundle;
+
+import lombok.Getter;
+import lombok.experimental.Accessors;
+
+/**
+ * A default application of {@link VAndroidContextTrait} extending {@link Activity}.
+ */
+@Accessors(prefix = "m")
+public abstract class VActivity extends Activity implements VAndroidContextMixin {
+    @Getter
+    private VAndroidContextTrait<Activity> mVAndroidContextTrait;
+
+    protected VAndroidContextTrait<Activity> createVActivityTrait(final Bundle savedInstanceState) {
+        return VAndroidContextTrait.withDefaults(this, savedInstanceState);
+    }
+
+    @Override
+    protected void onCreate(final Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        mVAndroidContextTrait = createVActivityTrait(savedInstanceState);
+    }
+
+    @Override
+    public void onCreate(Bundle savedInstanceState, PersistableBundle persistentState) {
+        super.onCreate(savedInstanceState, persistentState);
+        mVAndroidContextTrait = createVActivityTrait(savedInstanceState);
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/baku/toolkit/VAndroidContextMixin.java b/bakutoolkit/src/main/java/io/v/baku/toolkit/VAndroidContextMixin.java
new file mode 100644
index 0000000..553c3cf
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/baku/toolkit/VAndroidContextMixin.java
@@ -0,0 +1,12 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.baku.toolkit;
+
+/**
+ * An optional convenience interface for classes mixing in {@link VAndroidContextTrait}.
+ */
+public interface VAndroidContextMixin {
+    VAndroidContextTrait getVAndroidContextTrait();
+}
diff --git a/bakutoolkit/src/main/java/io/v/baku/toolkit/VAndroidContextTrait.java b/bakutoolkit/src/main/java/io/v/baku/toolkit/VAndroidContextTrait.java
new file mode 100644
index 0000000..56fb72a
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/baku/toolkit/VAndroidContextTrait.java
@@ -0,0 +1,125 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.baku.toolkit;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.os.Bundle;
+
+import io.v.android.v23.V;
+import io.v.v23.OptionDefs;
+import io.v.v23.Options;
+import io.v.v23.context.VContext;
+import io.v.v23.security.Blessings;
+import io.v.v23.verror.VException;
+import lombok.Getter;
+import lombok.experimental.Accessors;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * Android context trait incorporating common Vanadium utilities:
+ * <ul>
+ * <li>Vanadium initialization during {@code onCreate}; context available via
+ * {@code getVContext}</li>
+ * <li>Blessings management, available via {@code getBlessingsProvider().getRxBlessings}.
+ * Upon {@code subscribe}, blessings are refreshed from the {@code BlessingsManager} or sought from
+ * the {@code BlessingsProvider} (by default, the Account Manager).</li>
+ * </ul>
+ * <p>
+ * Default activity extensions incorporating this mix-in are available:
+ * <ul>
+ * <li>{@link VActivity} (extends {@link Activity})</li>
+ * <li>{@link VAppCompatActivity} (extends {@link android.support.v7.app.AppCompatActivity})</li>
+ * </ul>
+ * Since Java doesn't actually support multiple inheritance, clients requiring custom inheritance
+ * hierarchies will need to wire in manually, like any of the examples above.
+ */
+@Accessors(prefix = "m")
+@Slf4j
+public class VAndroidContextTrait<T extends Context> {
+    public static final String VANADIUM_OPTIONS_SHARED_PREFS = "VanadiumOptions";
+
+    public static SharedPreferences getVanadiumPreferences(final Context androidContext) {
+        return androidContext.getSharedPreferences(VANADIUM_OPTIONS_SHARED_PREFS,
+                Context.MODE_PRIVATE);
+    }
+
+    @Getter
+    private final T mAndroidContext;
+    @Getter
+    private final BlessingsProvider mBlessingsProvider;
+    @Getter
+    private final ErrorReporter mErrorReporter;
+    @Getter
+    private final SharedPreferences mVanadiumPreferences;
+    @Getter
+    private final VContext mVContext;
+
+    public Options getSavedOptions() {
+        return VOptionPreferenceUtils.getOptionsFromPreferences(mVanadiumPreferences);
+    }
+
+    private VContext vinit() {
+        try {
+            return V.init(mAndroidContext, getSavedOptions());
+        } catch (final RuntimeException e) {
+            try {
+                /* V.shutdown so we might try V.init again if warranted. If we don't V.shutdown
+                first, the process can abruptly die. It seems that if this happens, Android might
+                just restart the app immediately, i.e. before we've been able to display an
+                intelligible error message. */
+                V.shutdown();
+            } catch (final RuntimeException e2) {
+                log.error("Unable to clean up failed Vanadium initialization", e2);
+                e.addSuppressed(e2);
+            }
+
+            if (mVanadiumPreferences.getAll().isEmpty()) {
+                throw e;
+            } else {
+                mErrorReporter.reportError(R.string.err_vinit_options, e);
+                // Don't actually clear/fix options here; leave that to the user
+                return V.init(mAndroidContext);
+            }
+        }
+    }
+
+    public VAndroidContextTrait(final T androidContext, final BlessingsProvider blessingsProvider,
+                                final ErrorReporter errorReporter) {
+        mAndroidContext = androidContext;
+        mBlessingsProvider = blessingsProvider;
+        mErrorReporter = errorReporter;
+
+        mVanadiumPreferences = getVanadiumPreferences(mAndroidContext);
+        mVContext = vinit();
+
+        //Any time our blessings change, we need to attach them to our principal.
+        mBlessingsProvider.getPassiveRxBlessings().subscribe(this::processBlessings,
+                t -> errorReporter.onError(R.string.err_blessings_misc, t));
+    }
+
+    protected void processBlessings(final Blessings blessings) {
+        try {
+            BlessingsUtils.assumeBlessings(mVContext, blessings);
+        } catch (final VException e) {
+            mErrorReporter.onError(R.string.err_blessings_assume, e);
+        }
+    }
+
+    public static <T extends Activity> VAndroidContextTrait<T> withDefaults(
+            final T activity, final Bundle savedInstanceState) {
+        if (DebugUtils.isApkDebug(activity) && savedInstanceState == null) {
+            log.info("Debug menu enabled");
+            activity.getFragmentManager().beginTransaction()
+                    .add(new DebugFragment(), null)
+                    .commit();
+        }
+        final ErrorReporter errorReporter = new ErrorReporter(activity);
+        final BlessingsProvider blessingsProvider =
+                new BlessedActivityTrait(activity, errorReporter);
+        return new VAndroidContextTrait<>(activity, blessingsProvider, errorReporter);
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/baku/toolkit/VAppCompatActivity.java b/bakutoolkit/src/main/java/io/v/baku/toolkit/VAppCompatActivity.java
new file mode 100644
index 0000000..4d25a40
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/baku/toolkit/VAppCompatActivity.java
@@ -0,0 +1,41 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.baku.toolkit;
+
+import android.os.Bundle;
+import android.os.PersistableBundle;
+import android.support.v7.app.AppCompatActivity;
+
+import lombok.Getter;
+import lombok.experimental.Accessors;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * A default application of {@link VAndroidContextTrait} extending
+ * {@link android.support.v7.app.AppCompatActivity}.
+ */
+@Accessors(prefix = "m")
+@Slf4j
+public abstract class VAppCompatActivity extends AppCompatActivity implements VAndroidContextMixin {
+    @Getter
+    private VAndroidContextTrait<AppCompatActivity> mVAndroidContextTrait;
+
+    protected VAndroidContextTrait<AppCompatActivity> createVActivityTrait(
+            final Bundle savedInstanceState) {
+        return VAndroidContextTrait.withDefaults(this, savedInstanceState);
+    }
+
+    @Override
+    protected void onCreate(final Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        mVAndroidContextTrait = createVActivityTrait(savedInstanceState);
+    }
+
+    @Override
+    public void onCreate(Bundle savedInstanceState, PersistableBundle persistentState) {
+        super.onCreate(savedInstanceState, persistentState);
+        mVAndroidContextTrait = createVActivityTrait(savedInstanceState);
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/baku/toolkit/VOptionPreferenceUtils.java b/bakutoolkit/src/main/java/io/v/baku/toolkit/VOptionPreferenceUtils.java
new file mode 100644
index 0000000..a683f48
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/baku/toolkit/VOptionPreferenceUtils.java
@@ -0,0 +1,44 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.baku.toolkit;
+
+import android.content.SharedPreferences;
+
+import com.google.common.base.Strings;
+
+import io.v.v23.OptionDefs;
+import io.v.v23.Options;
+import java8.util.Optional;
+import lombok.experimental.UtilityClass;
+
+@UtilityClass
+public class VOptionPreferenceUtils {
+    public static Optional<Integer> readVLevel(final SharedPreferences prefs) {
+        final String raw = prefs.getString(OptionDefs.LOG_VLEVEL, "");
+        try {
+            return Optional.of(Integer.parseInt(raw));
+        } catch (final NumberFormatException|NullPointerException e) {
+            return Optional.empty();
+        }
+    }
+
+    public static Optional<String> readVModule(final SharedPreferences prefs) {
+        final String raw = prefs.getString(OptionDefs.LOG_VMODULE, "");
+        if (Strings.isNullOrEmpty(raw)) {
+            return Optional.empty();
+        } else {
+            return Optional.of(raw);
+        }
+    }
+
+    public static Options getOptionsFromPreferences(final SharedPreferences prefs) {
+        final Options opts = new Options();
+        /* It would be nice to copy this map naively, but Vanadium options are type-specific and
+        Android stores some numeric preferences as strings. */
+        readVLevel(prefs).ifPresent(v -> opts.set(OptionDefs.LOG_VLEVEL, v));
+        readVModule(prefs).ifPresent(v -> opts.set(OptionDefs.LOG_VMODULE, v));
+        return opts;
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/baku/toolkit/bind/CoordinatorChain.java b/bakutoolkit/src/main/java/io/v/baku/toolkit/bind/CoordinatorChain.java
new file mode 100644
index 0000000..e531251
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/baku/toolkit/bind/CoordinatorChain.java
@@ -0,0 +1,12 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.baku.toolkit.bind;
+
+import java8.lang.FunctionalInterface;
+import java8.util.function.UnaryOperator;
+
+@FunctionalInterface
+public interface CoordinatorChain<T> extends UnaryOperator<TwoWayBinding<T>> {
+}
diff --git a/bakutoolkit/src/main/java/io/v/baku/toolkit/bind/DebouncingCoordinator.java b/bakutoolkit/src/main/java/io/v/baku/toolkit/bind/DebouncingCoordinator.java
new file mode 100644
index 0000000..3cb9203
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/baku/toolkit/bind/DebouncingCoordinator.java
@@ -0,0 +1,68 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.baku.toolkit.bind;
+
+import org.joda.time.Duration;
+
+import java.util.concurrent.TimeUnit;
+
+import io.v.rx.syncbase.WatchEvent;
+import lombok.RequiredArgsConstructor;
+import rx.Observable;
+import rx.Subscription;
+import rx.android.schedulers.AndroidSchedulers;
+import rx.subjects.ReplaySubject;
+
+/**
+ * If input events arrive too quickly, the resulting watch updates can come back in a stutter, where
+ * older watch events arrive after the input has already been subsequently updated, reverting the
+ * view for a brief moment and messing with the cursor position.
+ * <p>
+ * A simple debounce on the uplink or downlink doesn't solve the problem because it effectively just
+ * adds a delay to the boundary condition. To prevent this, any update from the model must be
+ * throttled if there was a recent update from the view.
+ * <p>
+ * Unfortunately for rapid concurrent updates this can result in divergence which should be handled
+ * via conflict resolution or CRDT.
+ */
+@RequiredArgsConstructor
+public class DebouncingCoordinator<T> implements TwoWayBinding<T> {
+    public static final Duration DEFAULT_IO_DEBOUNCE = Duration.millis(500);
+
+    private final TwoWayBinding<T> mChild;
+    private final Duration mIoDebounce;
+
+    private final ReplaySubject<Observable<?>> mRxDebounce = ReplaySubject.createWithSize(1);
+    {
+        mRxDebounce.onNext(Observable.just(0)
+                .observeOn(AndroidSchedulers.mainThread()));
+        //We expect these timeouts to be on the main thread; see putDebounceWindow
+    }
+
+    public DebouncingCoordinator(final TwoWayBinding<T> child) {
+        this(child, DEFAULT_IO_DEBOUNCE);
+    }
+
+    private Observable<?> getDebounceWindow() {
+        return Observable.switchOnNext(mRxDebounce).first();
+    }
+
+    private void putDebounceWindow() {
+        mRxDebounce.onNext(Observable.timer(mIoDebounce.getMillis(), TimeUnit.MILLISECONDS,
+                AndroidSchedulers.mainThread()));
+        //Do timeouts on the main thread to ensure that timeouts don't clear while an input update
+        //is in progress.
+    }
+
+    @Override
+    public Observable<WatchEvent<T>> downlink() {
+        return mChild.downlink().debounce(s -> getDebounceWindow());
+    }
+
+    @Override
+    public Subscription uplink(final Observable<T> rxData) {
+        return mChild.uplink(rxData.doOnNext(d -> putDebounceWindow()));
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/baku/toolkit/bind/SuppressWriteOnReadCoordinator.java b/bakutoolkit/src/main/java/io/v/baku/toolkit/bind/SuppressWriteOnReadCoordinator.java
new file mode 100644
index 0000000..f416831
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/baku/toolkit/bind/SuppressWriteOnReadCoordinator.java
@@ -0,0 +1,37 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.baku.toolkit.bind;
+
+import io.v.rx.syncbase.WatchEvent;
+import lombok.RequiredArgsConstructor;
+import rx.Observable;
+import rx.Subscription;
+
+/**
+ * If we don't suppress writes while responding to SB changes with Android widgets, we easily end
+ * up in update loops. To operate correctly, this coordinator must occur single-threaded with the
+ * widget binding layer.
+ */
+@RequiredArgsConstructor
+public class SuppressWriteOnReadCoordinator<T> implements TwoWayBinding<T> {
+    private final TwoWayBinding<T> mChild;
+
+    private boolean mSuppressWrites;
+
+    @Override
+    public Observable<WatchEvent<T>> downlink() {
+        final Observable<WatchEvent<T>> childDownlink = mChild.downlink();
+        return Observable.create(s -> s.add(childDownlink.subscribe(x -> {
+            mSuppressWrites = true;
+            s.onNext(x);
+            mSuppressWrites = false;
+        }, s::onError, s::onCompleted)));
+    }
+
+    @Override
+    public Subscription uplink(Observable<T> rxData) {
+        return mChild.uplink(rxData.filter(x -> !mSuppressWrites));
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/baku/toolkit/bind/SyncbaseBinding.java b/bakutoolkit/src/main/java/io/v/baku/toolkit/bind/SyncbaseBinding.java
new file mode 100644
index 0000000..d66c75c
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/baku/toolkit/bind/SyncbaseBinding.java
@@ -0,0 +1,227 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.baku.toolkit.bind;
+
+import android.app.Activity;
+import android.view.View;
+import android.widget.EditText;
+import android.widget.TextView;
+
+import com.google.common.collect.Iterables;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import io.v.baku.toolkit.BakuActivityTrait;
+import io.v.rx.syncbase.RxTable;
+import rx.Subscription;
+import rx.android.schedulers.AndroidSchedulers;
+import rx.functions.Action1;
+import rx.subscriptions.CompositeSubscription;
+
+public abstract class SyncbaseBinding {
+    /**
+     * The {@link #deleteValue(Object)} and {@link #defaultValue(Object)} options are minimally
+     * typesafe, but keeping this builder simple is preferable, and the absence of rigorous static
+     * type checking here is acceptable.
+     */
+    public static class Builder<T> {
+        private Activity mActivity;
+        private RxTable mRxTable;
+        private String mKey;
+        private boolean mExplicitDefaultValue;
+        private T mDeleteValue, mDefaultValue;
+        private final List<CoordinatorChain<T>> mCoordinators = new ArrayList<>();
+        private CompositeSubscription mSubscriptionParent;
+        private Action1<Throwable> mOnError;
+
+        public Builder<T> activity(final Activity activity) {
+            mActivity = activity;
+            return this;
+        }
+
+        public Builder<T> rxTable(final RxTable rxTable) {
+            mRxTable = rxTable;
+            return this;
+        }
+
+        public Builder<T> bakuActivity(final BakuActivityTrait trait) {
+            return activity(trait.getVAndroidContextTrait().getAndroidContext())
+                    .rxTable(trait.getSyncbaseTable())
+                    .subscriptionParent(trait.getSubscriptions())
+                    .onError(trait::onSyncError);
+        }
+
+        public Builder<T> key(final String key) {
+            mKey = key;
+            return this;
+        }
+
+        private String getKey(final Object fallback) {
+            return mKey == null ? fallback.toString() : mKey;
+        }
+
+        /**
+         * Note that although this option is generic and attempts to enforce some weak measure of
+         * type safety in normal use, type pollution may still result in a
+         * {@link ClassCastException} at build time.
+         */
+        @SuppressWarnings("unchecked")
+        public <U extends T> Builder<U> deleteValue(final U deleteValue) {
+            mDeleteValue = deleteValue;
+            return (Builder<U>) this;
+        }
+
+        private T getDefaultValue(final T fallback) {
+            return mExplicitDefaultValue ? mDefaultValue : fallback;
+        }
+
+        /**
+         * Note that although this option is generic and attempts to enforce some weak measure of
+         * type safety in normal use, type pollution may still result in a
+         * {@link ClassCastException} at build time.
+         */
+        @SuppressWarnings("unchecked")
+        public <U extends T> Builder<U> defaultValue(final U defaultValue) {
+            mDefaultValue = defaultValue;
+            mExplicitDefaultValue = true;
+            return (Builder<U>) this;
+        }
+
+        public <U extends T> Builder<U> zeroValue(final U zeroValue) {
+            return deleteValue(zeroValue).defaultValue(zeroValue);
+        }
+
+        @SafeVarargs
+        public final Builder<T> coordinators(final CoordinatorChain<T>... coordinators) {
+            mCoordinators.clear();
+            return chain(coordinators);
+        }
+
+        @SafeVarargs
+        public final Builder<T> chain(final CoordinatorChain<T>... coordinators) {
+            Collections.addAll(mCoordinators, coordinators);
+            return this;
+        }
+
+        public Builder<T> coordinators(final Iterable<CoordinatorChain<T>> coordinators) {
+            mCoordinators.clear();
+            return chain(coordinators);
+        }
+
+        public Builder<T> chain(final Iterable<CoordinatorChain<T>> coordinators) {
+            Iterables.addAll(mCoordinators, coordinators);
+            return this;
+        }
+
+        public Builder<T> subscriptionParent(final CompositeSubscription subscriptionParent) {
+            mSubscriptionParent = subscriptionParent;
+            return this;
+        }
+
+        private Subscription subscribe(final Subscription subscription) {
+            if (mSubscriptionParent != null) {
+                mSubscriptionParent.add(subscription);
+            }
+            return subscription;
+        }
+
+        public Builder<T> onError(final Action1<Throwable> onError) {
+            mOnError = onError;
+            return this;
+        }
+
+        public Builder<T> bindOneWay(final TextView textView) {
+            @SuppressWarnings("unchecked")
+            final Builder<String> t = (Builder<String>) this;
+
+            subscribe(TextViewBindingTermini.bindRead(textView,
+                    SyncbaseBindingTermini.bindRead(mRxTable, getKey(textView.getId()),
+                            String.class, t.getDefaultValue(""))
+                            .onBackpressureLatest()
+                            .observeOn(AndroidSchedulers.mainThread()),
+                    mOnError));
+
+            return this;
+        }
+
+        /**
+         * Constructs a two-way binding between a string in Syncbase and the text of a TextView.
+         * <p>
+         * Defaults:
+         * <ul>
+         * <li>{@code defaultValue}: {@code ""}</li>
+         * <li>{@code deleteValue}: {@code null}</li>
+         * <li>{@code coordinators}: {@code DebouncingCoordinator}, and ensures that there is a
+         * {@code SuppressWriteOnReadCoordinator} somewhere in the chain, injecting it right
+         * above the {@code TextView} if absent.</li>
+         * </ul>
+         * <p>
+         * The coordination policy must end its downlink on the Android main thread.
+         * TODO(rosswang): provide a Coordinator that coerces this.
+         * <p>
+         * If {@code subscriptionParent} is set, this method adds the generated binding to it.
+         * <p>
+         * TODO(rosswang): produce a SyncbaseBinding, and allow mutable bindings.
+         */
+        public Builder<T> bindTwoWay(final TextView textView) {
+            @SuppressWarnings("unchecked")
+            final Builder<String> t = (Builder<String>) this;
+
+            TwoWayBinding<String> core = SyncbaseBindingTermini.bind(mRxTable,
+                    getKey(textView.getId()), String.class, t.getDefaultValue(""),
+                    (String) mDeleteValue, mOnError);
+            boolean hasSuppressWriteOnRead = false;
+            for (final CoordinatorChain<String> c : t.mCoordinators) {
+                core = c.apply(core);
+                if (core instanceof SuppressWriteOnReadCoordinator) {
+                    hasSuppressWriteOnRead = true;
+                }
+            }
+            if (mCoordinators.isEmpty()) {
+                core = new DebouncingCoordinator<>(core);
+            }
+            if (!hasSuppressWriteOnRead) {
+                core = new SuppressWriteOnReadCoordinator<>(core);
+            }
+            subscribe(TextViewBindingTermini.bind(textView, core, mOnError));
+
+            return this;
+        }
+
+        /**
+         * Calls {@link #bindTwoWay(TextView)} if the {@link TextView} is an {@link EditText},
+         * {@link #bindOneWay(TextView)} otherwise.
+         */
+        public Builder<T> bindTo(final TextView textView) {
+            return textView instanceof EditText ? bindTwoWay(textView) : bindOneWay(textView);
+        }
+
+        /**
+         * An alias for {@link #bindTwoWay(TextView)}, which is the default for {@link EditText}
+         * widgets.
+         */
+        public Builder<T> bindTo(final EditText editText) {
+            return bindTwoWay(editText);
+        }
+
+        public Builder<T> bindTo(final View view) {
+            if (view instanceof TextView) {
+                return bindTo((TextView) view);
+            } else {
+                throw new IllegalArgumentException("No default binding for view " + view);
+            }
+        }
+
+        public Builder<T> bindTo(final int viewId) {
+            return bindTo(mActivity.findViewById(viewId));
+        }
+    }
+
+    public static <T> Builder<T> builder() {
+        return new Builder<>();
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/baku/toolkit/bind/SyncbaseBindingTermini.java b/bakutoolkit/src/main/java/io/v/baku/toolkit/bind/SyncbaseBindingTermini.java
new file mode 100644
index 0000000..fcd80f9
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/baku/toolkit/bind/SyncbaseBindingTermini.java
@@ -0,0 +1,64 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.baku.toolkit.bind;
+
+import java.util.Objects;
+
+import io.v.rx.VFn;
+import io.v.rx.syncbase.RxTable;
+import io.v.rx.syncbase.WatchEvent;
+import io.v.v23.syncbase.nosql.Table;
+import lombok.AllArgsConstructor;
+import lombok.experimental.UtilityClass;
+import rx.Observable;
+import rx.Subscription;
+import rx.functions.Action1;
+import rx.schedulers.Schedulers;
+
+@UtilityClass
+public class SyncbaseBindingTermini {
+    @AllArgsConstructor
+    private static class WriteData<T> {
+        public final Table t;
+        public final T data;
+    }
+
+    public static <T> Observable<WatchEvent<T>> bindRead(
+            final RxTable rxTable, final String key, final Class<T> type, final T defaultValue) {
+        return rxTable.watch(key, type, defaultValue);
+    }
+
+    public static <T> Subscription bindWrite(
+            final RxTable rxTable, final Observable<T> rxData, final String key,
+            final Class<T> type, final T deleteValue, final Action1<Throwable> onError) {
+        return rxData
+                .onBackpressureLatest()
+                .observeOn(Schedulers.io())
+                .switchMap(data -> rxTable.once().map(t -> new WriteData<>(t, data)))
+                .subscribe(VFn.unchecked(w -> {
+                    if (Objects.equals(w.data, deleteValue)) {
+                        w.t.delete(rxTable.getVContext(), key);
+                    } else {
+                        w.t.put(rxTable.getVContext(), key, w.data, type);
+                    }
+                }), onError);
+    }
+
+    public static <T> TwoWayBinding<T> bind(
+            final RxTable rxTable, final String key, final Class<T> type, final T defaultValue,
+            final T deleteValue, final Action1<Throwable> onError) {
+        return new TwoWayBinding<T>() {
+            @Override
+            public Observable<WatchEvent<T>> downlink() {
+                return bindRead(rxTable, key, type, defaultValue);
+            }
+
+            @Override
+            public Subscription uplink(final Observable<T> rxData) {
+                return bindWrite(rxTable, rxData, key, type, deleteValue, onError);
+            }
+        };
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/baku/toolkit/bind/TextViewBindingTermini.java b/bakutoolkit/src/main/java/io/v/baku/toolkit/bind/TextViewBindingTermini.java
new file mode 100644
index 0000000..035ddde
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/baku/toolkit/bind/TextViewBindingTermini.java
@@ -0,0 +1,43 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.baku.toolkit.bind;
+
+import android.widget.TextView;
+
+import com.jakewharton.rxbinding.widget.RxTextView;
+
+import java.util.Objects;
+
+import io.v.rx.syncbase.WatchEvent;
+import lombok.experimental.UtilityClass;
+import rx.Observable;
+import rx.Subscription;
+import rx.functions.Action1;
+import rx.subscriptions.CompositeSubscription;
+
+@UtilityClass
+public class TextViewBindingTermini {
+    public static Subscription bindRead(final TextView textView,
+                                        final Observable<WatchEvent<String>> downlink,
+                                        final Action1<Throwable> onError) {
+        return downlink
+                .map(WatchEvent::getValue)
+                .filter(s -> !Objects.equals(s, Objects.toString(textView.getText(), null)))
+                .subscribe(textView::setTextKeepState, onError);
+    }
+
+    public static Observable<String> bindWrite(final TextView textView) {
+        return RxTextView.afterTextChangeEvents(textView)
+                .skip(1) //don't put the initial content
+                .map(e -> Objects.toString(e.editable(), null));
+    }
+
+    public static Subscription bind(final TextView textView, final TwoWayBinding<String> binding,
+                                    final Action1<Throwable> onError) {
+        return new CompositeSubscription(
+                bindRead(textView, binding.downlink(), onError),
+                binding.uplink(bindWrite(textView)));
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/baku/toolkit/bind/TwoWayBinding.java b/bakutoolkit/src/main/java/io/v/baku/toolkit/bind/TwoWayBinding.java
new file mode 100644
index 0000000..4e827fa
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/baku/toolkit/bind/TwoWayBinding.java
@@ -0,0 +1,28 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.baku.toolkit.bind;
+
+import io.v.rx.syncbase.WatchEvent;
+import rx.Observable;
+import rx.Subscription;
+
+/**
+ * {@code TwoWayBinding}s are nested from the Syncbase layer innermost to the UI layer outermost.
+ * The downlink is the data flow from Syncbase to the UI, and the uplink is the data flow from the
+ * UI to Syncbase.
+ */
+public interface TwoWayBinding<T> {
+    /**
+     * This method should be called at most once per instance, and the observable should have at
+     * most one subscriber.
+     */
+    Observable<WatchEvent<T>> downlink();
+
+    /**
+     * This method should be called at most once per instance, and the observable should have at
+     * most one subscriber.
+     */
+    Subscription uplink(Observable<T> rxData);
+}
diff --git a/bakutoolkit/src/main/java/io/v/baku/toolkit/bind/package-info.java b/bakutoolkit/src/main/java/io/v/baku/toolkit/bind/package-info.java
new file mode 100644
index 0000000..51e9879
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/baku/toolkit/bind/package-info.java
@@ -0,0 +1,7 @@
+/**
+ * Constructs:
+ *
+ * Binding - maps one or more controls/properties to a Syncbase row.
+ * Coordination policy - integrates uplinks and downlinks.
+ */
+package io.v.baku.toolkit.bind;
\ No newline at end of file
diff --git a/bakutoolkit/src/main/java/io/v/debug/SyncbaseAndroidService.java b/bakutoolkit/src/main/java/io/v/debug/SyncbaseAndroidService.java
new file mode 100644
index 0000000..c89899d
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/debug/SyncbaseAndroidService.java
@@ -0,0 +1,122 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.debug;
+
+import android.app.Service;
+import android.content.Intent;
+import android.os.IBinder;
+
+import org.joda.time.Duration;
+
+import java.io.File;
+import java.util.concurrent.TimeUnit;
+
+import io.v.android.v23.V;
+import io.v.baku.toolkit.BlessingsUtils;
+import io.v.impl.google.services.syncbase.SyncbaseServer;
+import io.v.rx.VFn;
+import io.v.v23.context.VContext;
+import io.v.v23.rpc.Server;
+import io.v.v23.verror.VException;
+import lombok.Value;
+import lombok.experimental.Accessors;
+import lombok.extern.slf4j.Slf4j;
+import rx.Observable;
+import rx.Subscription;
+import rx.schedulers.Schedulers;
+import rx.util.async.Async;
+
+/**
+ * Syncbase Android service in lieu of GMS Core Syncbase. Exposes Syncbase as a simplistic bound
+ * service, relying on Vanadium RPC in lieu of IPC, with open permissions, returning the local
+ * Vanadium name in {@code Binder.getName}.
+ */
+@Slf4j
+public class SyncbaseAndroidService extends Service {
+    private static final Duration
+            STOP_TIMEOUT = Duration.standardSeconds(5),
+            KEEP_ALIVE = Duration.standardMinutes(5);
+
+    @Accessors(prefix = "m")
+    @Value
+    public static class BindResult {
+        Server mServer;
+        String mName;
+    }
+
+    private VContext mVContext;
+    private Observable<BindResult> mObservable;
+    private Subscription mKill;
+
+    public class Binder extends android.os.Binder {
+        private Binder() {
+        }
+
+        public Observable<BindResult> getObservable() {
+            return mObservable;
+        }
+    }
+
+    @Override
+    public void onCreate() {
+        mVContext = V.init(this);
+        // If we don't proxy, it seems we can't even mount.
+        try {
+            mVContext = V.withListenSpec(mVContext, V.getListenSpec(mVContext).withProxy("proxy"));
+        } catch (final VException e) {
+            log.warn("Unable to set up Vanadium proxy for Syncbase", e);
+        }
+
+        mObservable = Async.fromCallable(this::startServer, Schedulers.io())
+                .replay(1).autoConnect(0); //cache last result; connect immediately
+    }
+
+    @Override
+    public void onDestroy() {
+        try {
+            mObservable.doOnNext(VFn.unchecked(b -> {
+                log.info("Stopping Syncbase");
+                b.mServer.stop();
+            }))
+                    .timeout(STOP_TIMEOUT.getMillis(), TimeUnit.MILLISECONDS)
+                    .toBlocking()
+                    .single();
+            log.info("Syncbase is over");
+            System.exit(0);
+        } catch (final RuntimeException e) {
+            log.error("Failed to shut down Syncbase", e);
+            System.exit(1);
+        }
+    }
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        return new Binder();
+    }
+
+    @Override
+    public boolean onUnbind(Intent intent) {
+        mKill = Observable.timer(KEEP_ALIVE.getMillis(), TimeUnit.MILLISECONDS)
+                .subscribe(x -> stopSelf());
+        return true;
+    }
+
+    @Override
+    public void onRebind(Intent intent) {
+        mKill.unsubscribe();
+    }
+
+    private BindResult startServer() throws SyncbaseServer.StartException {
+        final File storageRoot = new File(getFilesDir(), "syncbase");
+        storageRoot.mkdirs();
+
+        log.info("Starting Syncbase");
+        final VContext sbCtx = SyncbaseServer.withNewServer(mVContext, new SyncbaseServer.Params()
+                .withPermissions(BlessingsUtils.OPEN_DATA_PERMS)
+                .withStorageRootDir(storageRoot.getAbsolutePath()));
+        final Server server = V.getServer(sbCtx);
+        return new BindResult(server, "/" + server.getStatus().getEndpoints()[0]);
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/debug/SyncbaseClient.java b/bakutoolkit/src/main/java/io/v/debug/SyncbaseClient.java
new file mode 100644
index 0000000..7f89454
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/debug/SyncbaseClient.java
@@ -0,0 +1,133 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.debug;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.os.IBinder;
+
+import io.v.v23.rpc.Server;
+import io.v.v23.security.Blessings;
+import io.v.v23.syncbase.Syncbase;
+import io.v.v23.syncbase.SyncbaseService;
+import lombok.RequiredArgsConstructor;
+import lombok.Synchronized;
+import lombok.Value;
+import lombok.experimental.Accessors;
+import rx.Observable;
+import rx.Observer;
+import rx.Subscription;
+import rx.subjects.ReplaySubject;
+
+/**
+ * Syncbase Vanadium client for the {@link SyncbaseAndroidService} bound service, wrapped in an
+ * {@link Observable}.
+ */
+@Accessors(prefix = "m")
+public class SyncbaseClient implements AutoCloseable {
+    public static class BindException extends Exception {
+        public BindException(final String message) {
+            super(message);
+        }
+    }
+
+    @Value
+    public static class ServerClient {
+        Server mServer;
+        SyncbaseService mClient;
+    }
+
+    @RequiredArgsConstructor
+    private static class SyncbaseServiceConnection implements ServiceConnection {
+        private final Observer<ServerClient> mObserver;
+        private Subscription lastSubscription;
+
+        @Override
+        public void onServiceConnected(final ComponentName componentName,
+                                       final IBinder iBinder) {
+            final SyncbaseAndroidService.Binder binder = (SyncbaseAndroidService.Binder) iBinder;
+            lastSubscription = binder.getObservable()
+                    .map(b -> new ServerClient(b.getServer(), Syncbase.newService(b.getName())))
+                    .subscribe(mObserver);
+        }
+
+        @Override
+        public void onServiceDisconnected(final ComponentName componentName) {
+            lastSubscription.unsubscribe();
+            mObserver.onNext(null);
+        }
+    }
+
+    private final Context mAndroidContext;
+    private final Observable<ServerClient> mObservable;
+    private final SyncbaseServiceConnection mConnection;
+    private boolean mBound;
+
+    public Observable<Server> getRxServer() {
+        return mObservable.map(ServerClient::getServer);
+    }
+
+    public Observable<SyncbaseService> getRxClient() {
+        return mObservable.map(ServerClient::getClient);
+    }
+
+    @Synchronized
+    private void startService(final Context androidContext, final Intent intent) {
+        if (androidContext.startService(intent) == null) {
+            mConnection.mObserver.onError(
+                    new BindException("Could not locate Syncbase Android service"));
+        }
+        mBound = androidContext.bindService(
+                intent, mConnection, Context.BIND_AUTO_CREATE);
+        if (!mBound) {
+            mConnection.mObserver.onError(
+                    new BindException("Failed to bind to Syncbase Android service"));
+        }
+    }
+
+    /**
+     * Starts/connects to {@link SyncbaseAndroidService} and returns an {@code Observable} which
+     * receives an {@code onNext} whenever the Android service client connects. Subscriptions share
+     * a connection and initially receive the active instance if still connected.
+     *
+     * @param rxBlessings an optional observable of blessings. If provided, the Syncbase service
+     *                    will not be started until blessings are available.
+     *                    TODO(rosswang): this should either handle blessings changes or not care.
+     */
+    public SyncbaseClient(final Context androidContext, final Observable<Blessings> rxBlessings) {
+        mAndroidContext = androidContext;
+
+        /*
+        SyncbaseAndroidService is included in the io.v.baku.toolkit manifest, but since Android
+        libraries are linked statically, we'll need to resolve it via the end application package
+        (through androidContext).
+         */
+        final Intent intent = new Intent(androidContext, SyncbaseAndroidService.class);
+        final ReplaySubject<ServerClient> rpl = ReplaySubject.createWithSize(1);
+        mConnection = new SyncbaseServiceConnection(rpl);
+
+        if (rxBlessings == null) {
+            startService(androidContext, intent);
+        } else {
+            rxBlessings.first()
+                    .subscribe(s -> {
+                        startService(androidContext, intent);
+                    }, rpl::onError);
+        }
+
+        mObservable = rpl.filter(s -> s != null);
+    }
+
+    @Override
+    @Synchronized
+    public void close() {
+        if (mBound) {
+            mAndroidContext.unbindService(mConnection);
+            mBound = false;
+        }
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/rx/MountEvent.java b/bakutoolkit/src/main/java/io/v/rx/MountEvent.java
new file mode 100644
index 0000000..2af85aa
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/rx/MountEvent.java
@@ -0,0 +1,45 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.rx;
+
+import org.joda.time.DateTime;
+
+import io.v.v23.verror.VException;
+import java8.util.Optional;
+import lombok.Value;
+import lombok.experimental.Accessors;
+
+@Accessors(prefix = "m")
+@Value
+public class MountEvent {
+    public static MountEvent forAddNameSuccess(final String name) {
+        return new MountEvent(true, name, Optional.empty(), DateTime.now(), Optional.empty());
+    }
+
+    public static MountEvent forAddNameFailure(final String name, final VException e) {
+        return new MountEvent(true, name, Optional.empty(), DateTime.now(), Optional.of(e));
+    }
+
+    public static MountEvent forStatus(final boolean isMount, final String name,
+                                       final String server, final DateTime timestamp,
+                                       final VException error) {
+        return new MountEvent(isMount, name, Optional.of(server), timestamp,
+                Optional.ofNullable(error));
+    }
+
+    public static int compareByTimestamp(final MountEvent a, final MountEvent b) {
+        return a.getTimestamp().compareTo(b.getTimestamp());
+    }
+
+    boolean mMount;
+    String mName;
+    Optional<String> mServer;
+    DateTime mTimestamp;
+    Optional<VException> mError;
+
+    public boolean isSuccessfulMount() {
+        return mMount && mServer.isPresent() && !mError.isPresent();
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/rx/RxMountState.java b/bakutoolkit/src/main/java/io/v/rx/RxMountState.java
new file mode 100644
index 0000000..f720047
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/rx/RxMountState.java
@@ -0,0 +1,57 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.rx;
+
+import org.joda.time.Duration;
+
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+import io.v.v23.rpc.MountStatus;
+import io.v.v23.rpc.MountStatusKey;
+import io.v.v23.rpc.MountStatusValue;
+import io.v.v23.rpc.Server;
+import java8.util.J8Arrays;
+import java8.util.stream.Collectors;
+import java8.util.stream.Stream;
+import lombok.experimental.UtilityClass;
+import rx.Observable;
+import rx.schedulers.Schedulers;
+
+@UtilityClass
+public class RxMountState {
+    /**
+     * Millisecond interval for mount status polling.
+     */
+    public static final Duration DEFAULT_POLLING_INTERVAL = Duration.standardSeconds(1);
+
+    public static Observable<Stream<MountStatus>> poll(final Server s, final Duration interval) {
+        return Observable.interval(0, interval.getMillis(), TimeUnit.MILLISECONDS,
+                Schedulers.io())
+                .map(i -> J8Arrays.stream(s.getStatus().getMounts()));
+    }
+
+    public static Observable<Stream<MountStatus>> poll(final Server s) {
+        return poll(s, DEFAULT_POLLING_INTERVAL);
+    }
+
+    public static Map<MountStatusKey, MountStatusValue> index(
+            final Stream<MountStatus> state) {
+        return state.collect(Collectors.toMap(
+                MountStatusKey::fromMountStatus,
+                MountStatusValue::fromMountStatus));
+    }
+
+    public static Map<MountStatusKey, MountStatusValue> index(
+            final MountStatus[] state) {
+        return index(J8Arrays.stream(state));
+    }
+
+    public static Observable<Map<MountStatusKey, MountStatusValue>> index(
+            final Observable<Stream<MountStatus>> rx) {
+        return rx.map(RxMountState::index)
+                .distinctUntilChanged();
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/rx/RxNamespace.java b/bakutoolkit/src/main/java/io/v/rx/RxNamespace.java
new file mode 100644
index 0000000..4fbc11d
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/rx/RxNamespace.java
@@ -0,0 +1,131 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.rx;
+
+import org.joda.time.DateTime;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import io.v.v23.rpc.MountStatus;
+import io.v.v23.rpc.MountStatusKey;
+import io.v.v23.rpc.MountStatusValue;
+import io.v.v23.rpc.Server;
+import io.v.v23.verror.VException;
+import java8.util.Maps;
+import lombok.AllArgsConstructor;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.UtilityClass;
+import rx.Observable;
+
+@UtilityClass
+public class RxNamespace {
+    @RequiredArgsConstructor
+    @AllArgsConstructor
+    private static class MountRecord {
+        /*
+        TODO(rosswang): https://github.com/vanadium/issues/issues/826
+        Right now, mount status defaults timestamps for events that have never happened to be some
+        time in 1754. As a hack, initialize these to epoch/1970 (or any time after the default).
+         */
+        public DateTime lastMount = new DateTime(0),
+                lastUnmount = new DateTime(0);
+
+        public static MountRecord fromStatus(final MountStatus status) {
+            return new MountRecord(status.getLastMount(), status.getLastUnmount());
+        }
+    }
+
+    private static Observable<MountEvent> processStatus(
+            final Map<MountStatusKey, MountRecord> mountRecords,
+            final MountStatusKey k, final MountStatusValue v) {
+
+        final List<MountEvent> newEvents = new ArrayList<>(2);
+        synchronized (mountRecords) {
+            final MountRecord record = Maps.computeIfAbsent(mountRecords, k,
+                    kk -> new MountRecord());
+            if (v.getLastMount() != null && v.getLastMount().isAfter(record.lastMount)) {
+                newEvents.add(MountEvent.forStatus(true, k.getName(), k.getServer(),
+                        v.getLastMount(), v.getLastMountError()));
+            }
+            if (v.getLastUnmount() != null && v.getLastUnmount().isAfter(record.lastUnmount)) {
+                newEvents.add(MountEvent.forStatus(false, k.getName(), k.getServer(),
+                        v.getLastUnmount(), v.getLastUnmountError()));
+            }
+            record.lastMount = v.getLastMount();
+            record.lastUnmount = v.getLastUnmount();
+        }
+        Collections.sort(newEvents, MountEvent::compareByTimestamp);
+        return Observable.from(newEvents);
+    }
+
+    private static boolean isAlreadyMounted(final MountStatus status) {
+        //There are also ambiguous cases; err on the side of false.
+        return status.getLastMount().isAfter(status.getLastUnmount()) &&
+                status.getLastMountError() == null;
+    }
+
+    /**
+     * @return an {@code Observable} of {@code MountEvent}s. Events including servers come from
+     * polling, may be mount or unmount events, and may or may not include an error. Events with
+     * {@code isMount = true} are from {@link Server#addName(String)} and may or may not include an
+     * error. If a server is already mounted, a backdated mount event is included.
+     */
+    public static Observable<MountEvent> mount(final Observable<Server> rxServer,
+                                                          final String name) {
+        return Observable.switchOnNext(
+                rxServer.map(server -> {
+                    /*
+                    A note on thread safety. The initial status scan occurs on one thread, before
+                    any concurrency contention. Subsequent modifications happen on the Rx io
+                    scheduler, which by may be on different threads for each poll. Thus, not only
+                    does the map need to be thread-safe, but also each mount record. The simplest
+                    way to ensure this is just to lock map get/create and record access on a mutex,
+                    which might as well be the map itself. This does perform some unnecessary
+                    synchronization, but it all occurs on a worker thread on a low-fidelity loop, so
+                    it's not worth a more sophisticated lock.
+
+                    A fully correct minimal lock would include a thread-safe map and a read/write
+                    lock for each record.
+                     */
+                    final Map<MountStatusKey, MountRecord> mountRecords = new HashMap<>();
+                    final MountStatus[] mounts = server.getStatus().getMounts();
+                    final List<MountEvent> alreadyMounted = new ArrayList<>(mounts.length);
+                    for (final MountStatus status : mounts) {
+                        if (status.getName().equals(name)) {
+                            mountRecords.put(MountStatusKey.fromMountStatus(status),
+                                    MountRecord.fromStatus(status));
+                            if (isAlreadyMounted(status)) {
+                                alreadyMounted.add(MountEvent.forStatus(true, status.getName(),
+                                        status.getServer(), status.getLastMount(),
+                                        status.getLastMountError() /* null */));
+                            }
+                        }
+                    }
+                    if (alreadyMounted.isEmpty()) {
+                        try {
+                            server.addName(name);
+                        } catch (final VException e) {
+                            return Observable.just(MountEvent.forAddNameFailure(name, e));
+                        }
+                        final MountEvent initial = MountEvent.forAddNameSuccess(name);
+
+                        return RxMountState.index(
+                                RxMountState.poll(server).map(state -> state.filter(
+                                        status -> status.getName().equals(name))))
+                                .flatMapIterable(Map::entrySet)
+                                .concatMap(e -> processStatus(mountRecords,
+                                        e.getKey(), e.getValue()))
+                                .startWith(initial);
+                    } else {
+                        return Observable.from(alreadyMounted);
+                    }
+                }))
+                .takeWhile(MountEvent::isMount);
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/rx/RxVIterable.java b/bakutoolkit/src/main/java/io/v/rx/RxVIterable.java
new file mode 100644
index 0000000..b6e256b
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/rx/RxVIterable.java
@@ -0,0 +1,33 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.rx;
+
+import io.v.v23.VIterable;
+import io.v.v23.verror.VException;
+import lombok.experimental.UtilityClass;
+import rx.Observable;
+
+@UtilityClass
+public class RxVIterable {
+    /**
+     * Wraps a {@link VIterable} in an observable that produces the same elements and checks for
+     * an error from the {@code VIterable} at the end if present. This is a thin wrapper that does
+     * not ensure that the {@code VIterable} is only iterated over once, so the returned
+     * {@link Observable} should be subscribed to at most once. If multiple subscriptions are
+     * needed, consider a connectable observable operator, such as {@link Observable#publish()},
+     * {@link Observable#replay()}, {@link Observable#share()}, or {@link Observable#cache()}.
+     * However, if using a replay/cache, be cognizant of buffer growth.
+     *
+     * @return an observable wrapping the {@link VIterable}. This observable should only be
+     * subscribed to once, as we can only iterate over the underlying stream once.
+     */
+    public static <T> Observable<T> wrap(final VIterable<T> vi) {
+        return Observable.from(vi)
+                .concatWith(Observable.defer(() -> {
+                    final VException e = vi.error();
+                    return e == null ? Observable.empty() : Observable.error(e);
+                }));
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/rx/UncheckedVException.java b/bakutoolkit/src/main/java/io/v/rx/UncheckedVException.java
new file mode 100644
index 0000000..f289df7
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/rx/UncheckedVException.java
@@ -0,0 +1,42 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.rx;
+
+import com.google.common.collect.Iterables;
+
+import java.util.Arrays;
+
+import io.v.v23.verror.VException;
+
+/**
+ * This wrapper for {@link VException} facilitates its use with lambdas and RxJava. Where this is
+ * used, it is expected that alternate error handling mechanisms are in place.
+ */
+public class UncheckedVException extends RuntimeException {
+    public UncheckedVException(final VException cause) {
+        super(cause);
+    }
+
+    @Override
+    public VException getCause() {
+        return (VException)super.getCause();
+    }
+
+    public boolean isIdIn(final Iterable<VException.IDAction> ids) {
+        return Iterables.any(ids, id -> id.getID().equals(getCause().getID()));
+    }
+
+    public boolean isIdIn(final VException.IDAction... ids) {
+        return isIdIn(Arrays.asList(ids));
+    }
+
+    public static boolean isIdIn(final Throwable t, final Iterable<VException.IDAction> ids) {
+        return t instanceof UncheckedVException && ((UncheckedVException)t).isIdIn(ids);
+    }
+
+    public static boolean isIdIn(final Throwable t, final VException.IDAction... ids) {
+        return isIdIn(t, Arrays.asList(ids));
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/rx/VFn.java b/bakutoolkit/src/main/java/io/v/rx/VFn.java
new file mode 100644
index 0000000..834656b
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/rx/VFn.java
@@ -0,0 +1,62 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.rx;
+
+import io.v.v23.verror.VException;
+import java8.lang.FunctionalInterface;
+import lombok.experimental.UtilityClass;
+import rx.functions.Action0;
+import rx.functions.Action1;
+import rx.functions.Func1;
+
+@UtilityClass
+public class VFn {
+    @FunctionalInterface
+    public interface VAction {
+        void call() throws VException;
+    }
+
+    @FunctionalInterface
+    public interface VAction1<T> {
+        void call(T arg) throws VException;
+    }
+
+    @FunctionalInterface
+    public interface VFunc1<T, R> {
+        R call(T arg) throws VException;
+    }
+
+    public static void doUnchecked(final VAction v) {
+        try {
+            v.call();
+        } catch (final VException e) {
+            throw new UncheckedVException(e);
+        }
+    }
+
+    public static Action0 unchecked(final VAction v) {
+        return () -> doUnchecked(v);
+    }
+
+    public static <T> Action1<T> unchecked(final VAction1<? super T> v) {
+        return t -> {
+            try {
+                v.call(t);
+            } catch (final VException e) {
+                throw new UncheckedVException(e);
+            }
+        };
+    }
+
+    public static <T, R> Func1<T, R> unchecked(final VFunc1<? super T, ? extends R> v) {
+        return t -> {
+            try {
+                return v.call(t);
+            } catch (final VException e) {
+                throw new UncheckedVException(e);
+            }
+        };
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/rx/syncbase/Creatable.java b/bakutoolkit/src/main/java/io/v/rx/syncbase/Creatable.java
new file mode 100644
index 0000000..c919650
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/rx/syncbase/Creatable.java
@@ -0,0 +1,15 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.rx.syncbase;
+
+import io.v.v23.context.VContext;
+import io.v.v23.security.access.Permissions;
+import io.v.v23.verror.VException;
+import java8.lang.FunctionalInterface;
+
+@FunctionalInterface
+interface Creatable {
+    void create(VContext vContext, Permissions permissions) throws VException;
+}
diff --git a/bakutoolkit/src/main/java/io/v/rx/syncbase/ExistenceAware.java b/bakutoolkit/src/main/java/io/v/rx/syncbase/ExistenceAware.java
new file mode 100644
index 0000000..9bb2f9d
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/rx/syncbase/ExistenceAware.java
@@ -0,0 +1,14 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.rx.syncbase;
+
+import io.v.v23.context.VContext;
+import io.v.v23.verror.VException;
+import java8.lang.FunctionalInterface;
+
+@FunctionalInterface
+interface ExistenceAware {
+    boolean exists(VContext vContext) throws VException;
+}
diff --git a/bakutoolkit/src/main/java/io/v/rx/syncbase/GlobalUserSyncgroup.java b/bakutoolkit/src/main/java/io/v/rx/syncbase/GlobalUserSyncgroup.java
new file mode 100644
index 0000000..651d98a
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/rx/syncbase/GlobalUserSyncgroup.java
@@ -0,0 +1,217 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.rx.syncbase;
+
+import android.content.Context;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.NoSuchElementException;
+
+import io.v.baku.toolkit.BakuActivityMixin;
+import io.v.baku.toolkit.BakuActivityTrait;
+import io.v.baku.toolkit.BlessingsUtils;
+import io.v.baku.toolkit.R;
+import io.v.baku.toolkit.VAndroidContextMixin;
+import io.v.baku.toolkit.VAndroidContextTrait;
+import io.v.v23.context.VContext;
+import io.v.v23.security.Blessings;
+import io.v.v23.security.access.AccessList;
+import io.v.v23.security.access.Permissions;
+import io.v.v23.services.syncbase.nosql.SyncgroupMemberInfo;
+import io.v.v23.services.syncbase.nosql.SyncgroupSpec;
+import io.v.v23.services.syncbase.nosql.TableRow;
+import io.v.v23.syncbase.nosql.Database;
+import io.v.v23.syncbase.nosql.Syncgroup;
+import io.v.v23.verror.NoExistException;
+import io.v.v23.verror.VException;
+import java8.util.function.Function;
+import java8.util.stream.Collectors;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.experimental.Accessors;
+import lombok.extern.slf4j.Slf4j;
+import rx.Observable;
+import rx.Subscription;
+import rx.functions.Action2;
+import rx.schedulers.Schedulers;
+
+@Accessors(prefix = "m")
+@AllArgsConstructor
+@Builder(builderClassName = "Builder")
+@Slf4j
+public class GlobalUserSyncgroup {
+    public static final String
+            DEFAULT_SYNCGROUP_HOST_NAME = "usersync",
+            DEFAULT_SYNCGROUP_SUFFIX = "user",
+            DEFAULT_RENDEZVOUS_MOUNT = "sgmt";
+    public static final SyncgroupMemberInfo
+            DEFAULT_SYNCGROUP_MEMBER_INFO = new SyncgroupMemberInfo();
+
+    public static GlobalUserSyncgroup forActivity(final BakuActivityTrait t) {
+        return builder().bakuActivityTrait(t).build();
+    }
+
+    public static GlobalUserSyncgroup forActivity(final BakuActivityMixin m) {
+        return forActivity(m.getBakuActivityTrait());
+    }
+
+    /*
+    As of Lombok IntelliJ 0.9.6, @Builder exhibits a few bugs interacting with @Accessors (Gradle
+    build is fine).
+
+    https://github.com/mplushnikov/lombok-intellij-plugin/issues/151
+     */
+    public static class Builder {
+        private String sgSuffix = DEFAULT_SYNCGROUP_SUFFIX;
+        private Function<String, String> descriptionForUsername = u -> "User syncgroup for " + u;
+        private Function<AccessList, Permissions> permissionsForUserAcl =
+                BlessingsUtils::syncgroupPermissions;
+        private List<TableRow> prefixes = new ArrayList<>();
+        private SyncgroupMemberInfo memberInfo = DEFAULT_SYNCGROUP_MEMBER_INFO;
+
+        /**
+         * This is an additive setter to {@link #prefixes(List)}.
+         */
+        public Builder prefix(final TableRow prefix) {
+            prefixes.add(prefix);
+            return this;
+        }
+
+        /**
+         * This is an additive setter to {@link #prefixes(List)}.
+         */
+        public Builder prefix(final String tableName, final String rowPrefix) {
+            return prefix(new TableRow(tableName, rowPrefix));
+        }
+
+        /**
+         * This is an additive setter to {@link #prefixes(List)}.
+         */
+        public Builder prefix(final String tableName) {
+            return prefix(tableName, "");
+        }
+
+        /**
+         * This is a composite setter for:
+         * <ul>
+         * <li>{@code vContext}</li>
+         * <li>{@code rxBlessings}</li>
+         * <li>{@code syncHostLevel}</li> (as a new
+         * {@link UserAppSyncHost#UserAppSyncHost(Context)})
+         * <li>{@code onError}</li>
+         * </ul>
+         * and should be called prior to any overrides for those fields.
+         */
+        public Builder vActivityTrait(final VAndroidContextTrait<?> t) {
+            return vContext(t.getVContext())
+                    .rxBlessings(t.getBlessingsProvider().getRxBlessings())
+                    .syncHostLevel(new UserAppSyncHost(t.getAndroidContext()))
+                    .onError(t.getErrorReporter()::onError);
+        }
+
+        /**
+         * In addition to those fields in {@link #vActivityTrait(VAndroidContextTrait)}, this
+         * additionally sets:
+         * <ul>
+         * <li>{@code syncbase}</li>
+         * <li>{@code db}</li>
+         * <li>and adds to {@code prefixes}</li>
+         * </ul>
+         */
+        public Builder bakuActivityTrait(final BakuActivityTrait t) {
+            return vActivityTrait(t.getVAndroidContextTrait())
+                    .syncbase(t.getSyncbase())
+                    .db(t.getSyncbaseDb())
+                    .prefix(t.getSyncbaseTableName());
+        }
+
+        /**
+         * A convenience setter for {@link #bakuActivityTrait(BakuActivityTrait)} via
+         * {@link VAndroidContextMixin}.
+         */
+        public Builder activity(final BakuActivityMixin activity) {
+            return bakuActivityTrait(activity.getBakuActivityTrait());
+        }
+    }
+
+    private final VContext mVContext;
+    private final Observable<Blessings> mRxBlessings;
+    private final SyncHostLevel mSyncHostLevel;
+    private final String mSgSuffix;
+    private final RxSyncbase mSyncbase;
+    private final RxDb mDb;
+    private final Function<String, String> mDescriptionForUsername;
+    private final Function<AccessList, Permissions> mPermissionsForUserAcl;
+    private final List<TableRow> mPrefixes;
+    private final SyncgroupMemberInfo mMemberInfo;
+    /**
+     * @see io.v.baku.toolkit.ErrorReporter#onError(int, Throwable)
+     */
+    private final Action2<Integer, Throwable> mOnError;
+
+    private SyncgroupSpec createSpec(final String username, final AccessList userAcl) {
+        return new SyncgroupSpec(mDescriptionForUsername.apply(username),
+                mPermissionsForUserAcl.apply(userAcl), mPrefixes,
+                mSyncHostLevel.getRendezvousTableNames(username), false);
+    }
+
+    private Observable<Object> createOrJoinSyncgroup(final Database db, final String sgName,
+                                                     final SyncgroupSpec spec) {
+        return Observable.create(s -> {
+            final Syncgroup sg = db.getSyncgroup(sgName);
+            try {
+                sg.join(mVContext, mMemberInfo);
+                log.info("Joined syncgroup " + sgName);
+            } catch (final NoExistException e) {
+                try {
+                    sg.create(mVContext, spec, mMemberInfo);
+                    log.info("Created syncgroup " + sgName);
+                } catch (final VException e2) {
+                    s.onError(e2);
+                    return;
+                }
+            } catch (final VException e) {
+                s.onError(e);
+                return;
+            }
+            s.onNext(null);
+            s.onCompleted();
+        });
+    }
+
+    private Observable<Object> createOrJoinSyncgroup(final String username, final AccessList acl) {
+        final String sgHost = mSyncHostLevel.getSyncgroupHostName(username);
+        final String sgName = RxSyncbase.syncgroupName(sgHost, mSgSuffix);
+        final SyncgroupSpec spec = createSpec(username, acl);
+
+        final Observable<Object> mount = SgHostUtil.ensureSyncgroupHost(
+                mVContext, mSyncbase.getRxServer(), sgHost).share();
+
+        return mDb.getObservable()
+                .observeOn(Schedulers.io())
+                .switchMap(db -> Observable.merge(mount.first().ignoreElements().concatWith(
+                        createOrJoinSyncgroup(db, sgName, spec)), mount));
+    }
+
+    public Subscription join() {
+        return Observable.switchOnNext(mRxBlessings
+                .map(b -> {
+                    final AccessList acl = BlessingsUtils.blessingsToAcl(mVContext, b);
+                    final List<Observable<?>> createOrJoins =
+                            BlessingsUtils.blessingsToUsernameStream(mVContext, b)
+                                    .distinct()
+                                    .map(u -> createOrJoinSyncgroup(u, acl))
+                                    .collect(Collectors.toList());
+                    if (createOrJoins.isEmpty()) {
+                        throw new NoSuchElementException("GlobalUserSyncgroup requires a " +
+                                "username; no username blessings found. Blessings: " + b);
+                    }
+                    return Observable.merge(createOrJoins);
+                }))
+                .subscribe(x -> {
+                }, t -> mOnError.call(R.string.err_syncgroup_join, t));
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/rx/syncbase/RxApp.java b/bakutoolkit/src/main/java/io/v/rx/syncbase/RxApp.java
new file mode 100644
index 0000000..ab81a69
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/rx/syncbase/RxApp.java
@@ -0,0 +1,43 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.rx.syncbase;
+
+import io.v.rx.VFn;
+import io.v.v23.context.VContext;
+import io.v.v23.syncbase.SyncbaseApp;
+import io.v.v23.syncbase.SyncbaseService;
+import io.v.v23.verror.VException;
+import lombok.Getter;
+import lombok.experimental.Accessors;
+import rx.Observable;
+
+@Accessors(prefix = "m")
+@Getter
+public class RxApp extends RxEntity<SyncbaseApp, SyncbaseService> {
+    private final VContext mVContext;
+    private final String mName;
+    private final RxSyncbase mRxSyncbase;
+
+    private final Observable<SyncbaseApp> mObservable;
+
+    public RxApp(final String name, final RxSyncbase rxSb) {
+        mVContext = rxSb.getVContext();
+        mName = name;
+        mRxSyncbase = rxSb;
+
+        mObservable = rxSb.getRxClient().map(VFn.unchecked(this::mapFrom));
+    }
+
+    @Override
+    public SyncbaseApp mapFrom(final SyncbaseService sb) throws VException {
+        final SyncbaseApp app = sb.getApp(mName);
+        SyncbaseEntity.compose(app::exists, app::create).ensureExists(mVContext, null);
+        return app;
+    }
+
+    public RxDb rxDb(final String name) {
+        return new RxDb(name, this);
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/rx/syncbase/RxDb.java b/bakutoolkit/src/main/java/io/v/rx/syncbase/RxDb.java
new file mode 100644
index 0000000..97ca825
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/rx/syncbase/RxDb.java
@@ -0,0 +1,43 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.rx.syncbase;
+
+import io.v.rx.VFn;
+import io.v.v23.context.VContext;
+import io.v.v23.syncbase.SyncbaseApp;
+import io.v.v23.syncbase.nosql.Database;
+import io.v.v23.verror.VException;
+import lombok.Getter;
+import lombok.experimental.Accessors;
+import rx.Observable;
+
+@Accessors(prefix = "m")
+@Getter
+public class RxDb extends RxEntity<Database, SyncbaseApp> {
+    private final VContext mVContext;
+    private final String mName;
+    private final RxApp mRxApp;
+
+    private final Observable<Database> mObservable;
+
+    public RxDb(final String name, final RxApp rxApp) {
+        mVContext = rxApp.getVContext();
+        mName = name;
+        mRxApp = rxApp;
+
+        mObservable = rxApp.getObservable().map(VFn.unchecked(this::mapFrom));
+    }
+
+    @Override
+    public Database mapFrom(final SyncbaseApp app) throws VException {
+        final Database db = app.getNoSqlDatabase(mName, null);
+        SyncbaseEntity.compose(db::exists, db::create).ensureExists(mVContext, null);
+        return db;
+    }
+
+    public RxTable rxTable(final String name) {
+        return new RxTable(name, this);
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/rx/syncbase/RxEntity.java b/bakutoolkit/src/main/java/io/v/rx/syncbase/RxEntity.java
new file mode 100644
index 0000000..937ad53
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/rx/syncbase/RxEntity.java
@@ -0,0 +1,22 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.rx.syncbase;
+
+import io.v.v23.verror.VException;
+import rx.Observable;
+
+public abstract class RxEntity<T, P> {
+    public abstract String getName();
+    public abstract Observable<T> getObservable();
+    public abstract T mapFrom(P parent) throws VException;
+
+    /**
+     * This is a shortcut for {@code getObservable().first()}, to reduce the likelihood of
+     * forgetting to filter by {@code first}. Most commands should be run in this way.
+     */
+    public Observable<T> once() {
+        return getObservable().first();
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/rx/syncbase/RxSyncbase.java b/bakutoolkit/src/main/java/io/v/rx/syncbase/RxSyncbase.java
new file mode 100644
index 0000000..e441be4
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/rx/syncbase/RxSyncbase.java
@@ -0,0 +1,62 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.rx.syncbase;
+
+import android.content.Context;
+
+import io.v.baku.toolkit.VAndroidContextTrait;
+import io.v.debug.SyncbaseClient;
+import io.v.impl.google.naming.NamingUtil;
+import io.v.v23.context.VContext;
+import io.v.v23.rpc.Server;
+import io.v.v23.security.Blessings;
+import io.v.v23.syncbase.SyncbaseService;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.experimental.Accessors;
+import rx.Observable;
+
+/**
+ * Models a binding to a Syncbase Android service as an {@code Observable} of
+ * {@link SyncbaseService}s. The binding will be asynchronously made and then potentially
+ * periodically lost and regained, so modeling further operations as subscriptions works well.
+ */
+@Accessors(prefix = "m")
+@AllArgsConstructor
+public class RxSyncbase implements AutoCloseable {
+    public static String syncgroupName(final String sgHost, final String sgSuffix) {
+        return NamingUtil.join(sgHost, "%%sync", sgSuffix);
+    }
+
+    @Getter private final VContext mVContext;
+    private final SyncbaseClient mClient;
+
+    public Observable<Server> getRxServer() {
+        return mClient.getRxServer();
+    }
+
+    public Observable<SyncbaseService> getRxClient() {
+        return mClient.getRxClient();
+    }
+
+    public RxSyncbase(final Context androidContext, final VContext ctx,
+                      final Observable<Blessings> rxBlessings) {
+        mVContext = ctx;
+        mClient = new SyncbaseClient(androidContext, rxBlessings);
+    }
+
+    public RxSyncbase(final VAndroidContextTrait trait) {
+        this(trait.getAndroidContext(), trait.getVContext(),
+                trait.getBlessingsProvider().getRxBlessings());
+    }
+
+    public void close() {
+        mClient.close();
+    }
+
+    public RxApp rxApp(final String name) {
+        return new RxApp(name, this);
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/rx/syncbase/RxTable.java b/bakutoolkit/src/main/java/io/v/rx/syncbase/RxTable.java
new file mode 100644
index 0000000..60aa58b
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/rx/syncbase/RxTable.java
@@ -0,0 +1,151 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.rx.syncbase;
+
+import io.v.rx.RxVIterable;
+import io.v.rx.VFn;
+import io.v.v23.VIterable;
+import io.v.v23.context.CancelableVContext;
+import io.v.v23.context.VContext;
+import io.v.v23.services.syncbase.nosql.BatchOptions;
+import io.v.v23.services.watch.ResumeMarker;
+import io.v.v23.syncbase.nosql.BatchDatabase;
+import io.v.v23.syncbase.nosql.Database;
+import io.v.v23.syncbase.nosql.DatabaseCore;
+import io.v.v23.syncbase.nosql.Table;
+import io.v.v23.syncbase.nosql.WatchChange;
+import io.v.v23.verror.NoExistException;
+import io.v.v23.verror.VException;
+import lombok.Getter;
+import lombok.experimental.Accessors;
+import lombok.extern.slf4j.Slf4j;
+import rx.Observable;
+import rx.Subscriber;
+import rx.schedulers.Schedulers;
+import rx.subscriptions.Subscriptions;
+
+@Accessors(prefix = "m")
+@Getter
+@Slf4j
+public class RxTable extends RxEntity<Table, DatabaseCore> {
+    private final VContext mVContext;
+    private final String mName;
+    private final RxDb mRxDb;
+
+    private final Observable<Table> mObservable;
+
+    public RxTable(final String name, final RxDb rxDb) {
+        mVContext = rxDb.getVContext();
+        mName = name;
+        mRxDb = rxDb;
+
+        mObservable = rxDb.getObservable().map(VFn.unchecked(this::mapFrom));
+    }
+
+    @Override
+    public Table mapFrom(final DatabaseCore db) throws VException {
+        final Table t = db.getTable(mName);
+        SyncbaseEntity.compose(t::exists, t::create).ensureExists(mVContext, null);
+        return t;
+    }
+
+    private <T> T getInitial(final BatchDatabase db, final String tableName, final String key,
+                             final Class<T> type, final T defaultValue) throws VException {
+        try {
+            @SuppressWarnings("unchecked")
+            final T fromGet = (T) db.getTable(tableName).get(
+                    mVContext, key, type);
+            return fromGet;
+        } catch (final NoExistException e) {
+            return defaultValue;
+        }
+    }
+
+    /**
+     * Wraps a prefix watch stream in a key-specific observable. It remains to be seen whether it
+     * will be better to feature-request an exact-match watch API from Syncbase or consolidate all
+     * watches into one stream. Exact-match presents a cleaner API boundary but results in more
+     * underlying streams, whereas consolidating at the library level will usually be more efficient
+     * unless large portions of data won't need to be watched, and also it opens up questions of
+     * whether we should computationally optimize the prefix query.
+     *
+     * @return an observable wrapping the watch stream. This observable should only be subscribed to
+     * once, as we can only iterate over the underlying stream once.
+     */
+    private static <T> Observable<WatchEvent<T>> observeWatchStream(
+            final VIterable<WatchChange> s, final String key, final T defaultValue) {
+        return RxVIterable.wrap(s)
+                .filter(c -> c.getRowName().equals(key))
+                /*
+                About the Vfn.unchecked, on error, the wrapping replay will disconnect, calling
+                cancellation (see cancelOnDisconnect). The possible source of VException here is VOM
+                decoding.
+                 */
+                .map(VFn.unchecked(c -> {
+                    return WatchEvent.fromWatchChange(c, defaultValue);
+                }))
+                .distinctUntilChanged();
+    }
+
+    private void cancelContextOnDisconnect(final Subscriber<?> subscriber,
+                                           final CancelableVContext cancelable,
+                                           final String key) {
+        subscriber.add(Subscriptions.create(() -> {
+            log.debug("Cancelling watch on {}: {}", mName, key);
+            cancelable.cancel();
+        }));
+    }
+
+    private <T> void subscribeWatch(final Subscriber<? super WatchEvent<T>> subscriber,
+                                    final Database db, final String key, final Class<T> type,
+                                    final T defaultValue) throws VException {
+        /*
+        Watch will not work properly unless the table exists (sync will not create the table),
+        and table creation must happen outside the batch.
+        https://github.com/vanadium/issues/issues/857
+        */
+        mapFrom(db);
+
+        final BatchDatabase batch = db.beginBatch(mVContext, new BatchOptions("", true));
+        final T initial = getInitial(batch, mName, key, type, defaultValue);
+        final ResumeMarker r = batch.getResumeMarker(mVContext);
+        subscriber.onNext(new WatchEvent<>(initial, r, false));
+        batch.abort(mVContext);
+
+        final CancelableVContext cancelable = mVContext.withCancel();
+        final VIterable<WatchChange> s = db.watch(cancelable, mName, key, r);
+        log.debug("Watching {}: {}", mName, key);
+        cancelContextOnDisconnect(subscriber, cancelable, key);
+        observeWatchStream(s, key, defaultValue).subscribe(subscriber);
+    }
+
+    /**
+     * Watches a specific Syncbase row for changes.
+     *
+     * TODO(rosswang): Cache this by args.
+     */
+    public <T> Observable<WatchEvent<T>> watch(final String key, final Class<T> type,
+                                               final T defaultValue) {
+        return Observable.<WatchEvent<T>>create(subscriber -> mRxDb.getObservable()
+                .observeOn(Schedulers.io())
+                .subscribe(
+                        VFn.unchecked(db -> {
+                            /*
+                            Could be an expression lambda, but that confuses both RetroLambda and
+                            AndroidStudio.
+                            */
+                            subscribeWatch(subscriber, db, key, type, defaultValue);
+                        }),
+                        subscriber::onError
+                        //onComplete is connected by subscribeWatch/observeWatchStream.subscribe
+                ))
+                /*
+                Don't create new watch streams for subsequent subscribers, but do cancel the stream
+                if no subscribers are listening (and restart if new subscriptions happen).
+                 */
+                .replay(1)
+                .refCount();
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/rx/syncbase/SgHostUtil.java b/bakutoolkit/src/main/java/io/v/rx/syncbase/SgHostUtil.java
new file mode 100644
index 0000000..112697f
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/rx/syncbase/SgHostUtil.java
@@ -0,0 +1,106 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.rx.syncbase;
+
+import org.joda.time.Duration;
+
+import io.v.rx.MountEvent;
+import io.v.rx.RxNamespace;
+import io.v.v23.context.VContext;
+import io.v.v23.rpc.Server;
+import io.v.v23.syncbase.Syncbase;
+import io.v.v23.verror.TimeoutException;
+import io.v.v23.verror.VException;
+import lombok.experimental.UtilityClass;
+import lombok.extern.slf4j.Slf4j;
+import rx.Observable;
+import rx.schedulers.Schedulers;
+
+/**
+ * This utility class is a short-term solution until a better solution for distributed syncgroup
+ * hosting is available.
+ */
+@Slf4j
+@UtilityClass
+public class SgHostUtil {
+    public static final Duration SYNCBASE_PING_TIMEOUT = Duration.standardSeconds(5);
+
+    /**
+     * This method blocks while it pings Syncbase at the given name.
+     *
+     * @throws InterruptedException if the thread is interrupted while waiting for the ping
+     *                              response. The default implementation does not throw this.
+     *                              TODO(rosswang): pick this out from the VException, if possible.
+     */
+    public static boolean isSyncbaseOnline(final VContext vContext, final String name)
+            throws InterruptedException {
+        final VContext pingContext = vContext.withTimeout(SYNCBASE_PING_TIMEOUT);
+        try {
+            /* It would be nice if there were a more straightforward ping. We can't just query the
+            mount table because the server might not have shut down cleanly. */
+            Syncbase.newService(name).getApp("ping").exists(pingContext);
+            return true;
+        } catch (final TimeoutException e) {
+            return false;
+        } catch (final VException e) {
+            log.error("Unexpected error while attempting to ping Syncgroup host at " + name, e);
+            return false;
+        }
+    }
+
+    /**
+     * @return {@code true} iff the mount event represents a successful mount.
+     */
+    private static boolean processMountEvent(final MountEvent e) {
+        e.getServer().ifPresentOrElse(
+                s -> e.getError().ifPresentOrElse(
+                        err -> log.error(String.format("Could not %s local Syncbase instance %s " +
+                                        "as syncgroup host %s",
+                                e.isMount() ? "mount" : "unmount", s, e.getName()), err),
+                        () -> log.info("{} local Syncbase instance {} as syncgroup host {}",
+                                e.isMount() ? "Mounted" : "Unmounted", s, e.getName())
+                ),
+                () -> e.getError().ifPresentOrElse(
+                        err -> log.error("Could not mount local Syncbase instance as syncgroup " +
+                                "host " + e.getName(), err),
+                        () -> log.info("Mounting local Syncbase instance as syncgroup host " +
+                                e.getName()))
+        );
+        return e.isSuccessfulMount();
+    }
+
+    private static Observable<MountEvent> mountSgHost(final Observable<Server> rxServer,
+                                                      final String name) {
+        return RxNamespace.mount(rxServer, name)
+                .filter(SgHostUtil::processMountEvent)
+                .retry((i, t) -> {
+                    log.error("Error maintaining mount of local Syncbase instance as " +
+                            "syncgroup host " + name, t);
+                    return t instanceof Exception;
+                })
+                .replay().refCount();
+    }
+
+    /**
+     * @return an observable that emits an item when a Syncbase instance is known to be hosted at
+     * the given name. The mount is updated for any new server instances until this observable has
+     * been unsubscribed.
+     */
+    public static Observable<Object> ensureSyncgroupHost(
+            final VContext vContext, final Observable<Server> rxServer, final String name) {
+        return rxServer.observeOn(Schedulers.io())
+        .switchMap(s -> {
+            try {
+                if (isSyncbaseOnline(vContext, name)) {
+                    return Observable.just(0);
+                } else {
+                    return mountSgHost(rxServer, name);
+                }
+            } catch (final InterruptedException e) {
+                return Observable.error(e);
+            }
+        });
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/rx/syncbase/SyncHostLevel.java b/bakutoolkit/src/main/java/io/v/rx/syncbase/SyncHostLevel.java
new file mode 100644
index 0000000..260609e
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/rx/syncbase/SyncHostLevel.java
@@ -0,0 +1,14 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.rx.syncbase;
+
+import java.util.List;
+
+public interface SyncHostLevel {
+    String DEFAULT_SG_HOST_SUFFIX = "sghost", DEFAULT_RENDEZVOUS_SUFFIX = "sgmt";
+
+    String getSyncgroupHostName(String username);
+    List<String> getRendezvousTableNames(String username);
+}
diff --git a/bakutoolkit/src/main/java/io/v/rx/syncbase/SyncbaseEntity.java b/bakutoolkit/src/main/java/io/v/rx/syncbase/SyncbaseEntity.java
new file mode 100644
index 0000000..be7a43e
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/rx/syncbase/SyncbaseEntity.java
@@ -0,0 +1,40 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.rx.syncbase;
+
+import io.v.v23.context.VContext;
+import io.v.v23.security.access.Permissions;
+import io.v.v23.verror.ExistException;
+import io.v.v23.verror.VException;
+
+abstract class SyncbaseEntity implements ExistenceAware, Creatable {
+    public static SyncbaseEntity compose(final ExistenceAware fnExists, final Creatable fnCreate) {
+        return new SyncbaseEntity() {
+            @Override
+            public void create(VContext vContext, Permissions permissions) throws VException {
+                fnCreate.create(vContext, permissions);
+            }
+
+            @Override
+            public boolean exists(VContext vContext) throws VException {
+                return fnExists.exists(vContext);
+            }
+        };
+    }
+
+    /**
+     * Utility for Syncbase entities with lazy creation semantics. It would be great if this were
+     * instead factored into a V23 interface and utility.
+     */
+    public void ensureExists(final VContext vContext, final Permissions permissions)
+            throws VException {
+        if (!exists(vContext)) {
+            try {
+                create(vContext, permissions);
+            } catch (final ExistException ignore) {
+            }
+        }
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/rx/syncbase/UserAppSyncHost.java b/bakutoolkit/src/main/java/io/v/rx/syncbase/UserAppSyncHost.java
new file mode 100644
index 0000000..13bd471
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/rx/syncbase/UserAppSyncHost.java
@@ -0,0 +1,34 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.rx.syncbase;
+
+import android.content.Context;
+
+import java.util.Arrays;
+import java.util.List;
+
+import io.v.baku.toolkit.BlessingsUtils;
+import io.v.impl.google.naming.NamingUtil;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+public class UserAppSyncHost implements SyncHostLevel {
+    private final String mAppName, mSgHostSuffix, mRendezvousSuffix;
+
+    public UserAppSyncHost(final Context androidContext) {
+        this(androidContext.getPackageName(), DEFAULT_SG_HOST_SUFFIX, DEFAULT_RENDEZVOUS_SUFFIX);
+    }
+
+    @Override
+    public String getSyncgroupHostName(final String username) {
+        return NamingUtil.join(BlessingsUtils.userMount(username), mAppName, mSgHostSuffix);
+    }
+
+    @Override
+    public List<String> getRendezvousTableNames(String username) {
+        return Arrays.asList(NamingUtil.join(
+                BlessingsUtils.userMount(username), mAppName, mRendezvousSuffix));
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/rx/syncbase/WatchEvent.java b/bakutoolkit/src/main/java/io/v/rx/syncbase/WatchEvent.java
new file mode 100644
index 0000000..9a9a3a5
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/rx/syncbase/WatchEvent.java
@@ -0,0 +1,37 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.rx.syncbase;
+
+import io.v.v23.services.watch.ResumeMarker;
+import io.v.v23.syncbase.nosql.ChangeType;
+import io.v.v23.syncbase.nosql.WatchChange;
+import io.v.v23.verror.VException;
+import io.v.v23.vom.VomUtil;
+import lombok.Value;
+import lombok.experimental.Accessors;
+
+@Accessors(prefix = "m")
+@Value
+public class WatchEvent<T> {
+    T mValue;
+    ResumeMarker mResumeMarker;
+    boolean mFromSync;
+
+    @SuppressWarnings("unchecked")
+    private static <T> T getWatchValue(final WatchChange change, final T defaultValue)
+            throws VException {
+        if (change.getChangeType() == ChangeType.DELETE_CHANGE) {
+            return defaultValue;
+        } else {
+            return (T) VomUtil.decode(change.getVomValue());
+        }
+    }
+
+    public static <T> WatchEvent<T> fromWatchChange(final WatchChange c, final T defaultValue)
+            throws VException {
+        return new WatchEvent<>(getWatchValue(c, defaultValue),
+                c.getResumeMarker(), c.isFromSync());
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/v23/rpc/MountStatusKey.java b/bakutoolkit/src/main/java/io/v/v23/rpc/MountStatusKey.java
new file mode 100644
index 0000000..589fb53
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/v23/rpc/MountStatusKey.java
@@ -0,0 +1,18 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.v23.rpc;
+
+import lombok.Value;
+import lombok.experimental.Accessors;
+
+@Accessors(prefix = "m")
+@Value
+public class MountStatusKey {
+    String mName, mServer;
+
+    public static MountStatusKey fromMountStatus(final MountStatus m) {
+        return new MountStatusKey(m.getName(), m.getServer());
+    }
+}
diff --git a/bakutoolkit/src/main/java/io/v/v23/rpc/MountStatusValue.java b/bakutoolkit/src/main/java/io/v/v23/rpc/MountStatusValue.java
new file mode 100644
index 0000000..9d31d55
--- /dev/null
+++ b/bakutoolkit/src/main/java/io/v/v23/rpc/MountStatusValue.java
@@ -0,0 +1,27 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.v23.rpc;
+
+import org.joda.time.DateTime;
+import org.joda.time.Duration;
+
+import io.v.v23.verror.VException;
+import lombok.Value;
+import lombok.experimental.Accessors;
+
+@Accessors(prefix = "m")
+@Value
+public class MountStatusValue {
+    DateTime mLastMount;
+    VException mLastMountError;
+    Duration mTtl;
+    DateTime mLastUnmount;
+    VException mLastUnmountError;
+
+    public static MountStatusValue fromMountStatus(final MountStatus m) {
+        return new MountStatusValue(m.getLastMount(), m.getLastMountError(), m.getTTL(),
+                m.getLastUnmount(), m.getLastUnmountError());
+    }
+}
diff --git a/bakutoolkit/src/main/res/layout-land/dialog_debug_log.xml b/bakutoolkit/src/main/res/layout-land/dialog_debug_log.xml
new file mode 100644
index 0000000..e36fd28
--- /dev/null
+++ b/bakutoolkit/src/main/res/layout-land/dialog_debug_log.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical">
+
+    <FrameLayout
+        android:id="@+id/logcat_container"
+        android:layout_width="500dp"
+        android:layout_height="match_parent" />
+
+</LinearLayout>
\ No newline at end of file
diff --git a/bakutoolkit/src/main/res/layout/dialog_debug_log.xml b/bakutoolkit/src/main/res/layout/dialog_debug_log.xml
new file mode 100644
index 0000000..98ca2c6
--- /dev/null
+++ b/bakutoolkit/src/main/res/layout/dialog_debug_log.xml
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical">
+
+    <FrameLayout
+        android:id="@+id/pref_logging_container"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content" />
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_gravity="center_horizontal"
+        android:orientation="horizontal">
+
+        <Button
+            android:id="@+id/debug_log_reset"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:text="@string/reset" />
+
+        <Button
+            android:id="@+id/debug_log_restart"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:text="@string/restart" />
+
+    </LinearLayout>
+
+    <FrameLayout
+        android:id="@+id/logcat_container"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent" />
+</LinearLayout>
\ No newline at end of file
diff --git a/bakutoolkit/src/main/res/layout/logcat.xml b/bakutoolkit/src/main/res/layout/logcat.xml
new file mode 100644
index 0000000..fd594fe
--- /dev/null
+++ b/bakutoolkit/src/main/res/layout/logcat.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical">
+
+    <ListView
+        android:id="@android:id/list"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:background="@android:color/background_light" />
+</LinearLayout>
\ No newline at end of file
diff --git a/bakutoolkit/src/main/res/menu/debug.xml b/bakutoolkit/src/main/res/menu/debug.xml
new file mode 100644
index 0000000..4eeaf62
--- /dev/null
+++ b/bakutoolkit/src/main/res/menu/debug.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<menu xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:id="@+id/debug"
+          android:title="@string/debug"
+          android:orderInCategory="999">
+        <menu>
+            <item android:id="@+id/logging"
+                  android:title="@string/logging"/>
+            <item android:id="@+id/clear_app_data"
+                  android:title="@string/clear_app_data"/>
+            <item android:id="@+id/kill_process"
+                  android:title="@string/kill_process"/>
+        </menu>
+    </item>
+</menu>
\ No newline at end of file
diff --git a/bakutoolkit/src/main/res/values/errors.xml b/bakutoolkit/src/main/res/values/errors.xml
new file mode 100644
index 0000000..b0e7d99
--- /dev/null
+++ b/bakutoolkit/src/main/res/values/errors.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="err_app_clear">Unable to clear app data</string>
+    <string name="err_blessings_assume">Unable to assume blessings</string>
+    <string name="err_blessings_decode">Unable to decode blessings</string>
+    <string name="err_blessings_misc">Unexpected error while attaining blessings</string>
+    <string name="err_blessings_required">Blessings required</string>
+    <string name="err_blessings_store">Unable to store blessings</string>
+    <string name="err_sync">Unable to sync state</string>
+    <string name="err_syncgroup_join">Unable to join syncgroup</string>
+    <string name="err_misc">Unknown error</string>
+    <string name="err_vinit_options">Invalid Vanadium options</string>
+</resources>
\ No newline at end of file
diff --git a/bakutoolkit/src/main/res/values/strings.xml b/bakutoolkit/src/main/res/values/strings.xml
new file mode 100644
index 0000000..48a0718
--- /dev/null
+++ b/bakutoolkit/src/main/res/values/strings.xml
@@ -0,0 +1,12 @@
+<resources>
+    <string name="app_name">Baku Toolkit</string>
+    <string name="clear_app_data">Clear app data</string>
+    <string name="debug">Debug</string>
+    <string name="kill_process">Kill process</string>
+    <string name="logging">Logging</string>
+    <string name="vlevel">V23 log verbosity</string>
+    <string name="vmodule">V23 module log verbosity</string>
+
+    <string name="reset">Reset</string>
+    <string name="restart">Restart app</string>
+</resources>
diff --git a/bakutoolkit/src/main/res/xml/pref_logging.xml b/bakutoolkit/src/main/res/xml/pref_logging.xml
new file mode 100644
index 0000000..74580c2
--- /dev/null
+++ b/bakutoolkit/src/main/res/xml/pref_logging.xml
@@ -0,0 +1,20 @@
+<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android">
+
+   <EditTextPreference
+        android:id="@+id/pref_vlevel"
+        android:key="io.v.v23.LOG_VLEVEL"
+        android:title="@string/vlevel"
+        android:selectAllOnFocus="true"
+        android:inputType="number"
+        android:singleLine="true"
+        android:maxLines="1" />
+
+    <EditTextPreference
+        android:id="@+id/pref_vmodule"
+        android:key="io.v.v23.LOG_VMODULE"
+        android:title="@string/vmodule"
+        android:selectAllOnFocus="false"
+        android:singleLine="true"
+        android:maxLines="1" />
+
+</PreferenceScreen>
diff --git a/bakutoolkit/src/test/java/io/v/baku/toolkit/BlessedActivityTraitTest.java b/bakutoolkit/src/test/java/io/v/baku/toolkit/BlessedActivityTraitTest.java
new file mode 100644
index 0000000..cf9d92c
--- /dev/null
+++ b/bakutoolkit/src/test/java/io/v/baku/toolkit/BlessedActivityTraitTest.java
@@ -0,0 +1,151 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.baku.toolkit;
+
+import android.app.Activity;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import io.v.android.libs.security.BlessingsManager;
+import io.v.v23.security.Blessings;
+import lombok.RequiredArgsConstructor;
+import lombok.ToString;
+import rx.Observable;
+import rx.functions.Action1;
+import rx.subjects.PublishSubject;
+
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.powermock.api.mockito.PowerMockito.mockStatic;
+
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({Blessings.class, BlessingsManager.class})
+public class BlessedActivityTraitTest {
+    private static class MockBlessedActivityTrait extends BlessedActivityTrait {
+        @RequiredArgsConstructor
+        @ToString
+        private static class ErrorEntry {
+            public final String summary;
+            public final Throwable t;
+        }
+
+        private final List<ErrorEntry> mErrors = new ArrayList<>();
+        private final PublishSubject<Blessings> mBlessingsSubject = PublishSubject.create();
+
+        public MockBlessedActivityTrait(final Activity activity,
+                                        final ErrorReporter errorReporter) {
+            super(activity, errorReporter);
+        }
+
+        @Override
+        protected Observable<Blessings> seekBlessings() {
+            return mBlessingsSubject;
+        }
+
+        public void offerBlessings(final Blessings blessings) {
+            mBlessingsSubject.onNext(blessings);
+        }
+    }
+
+    @Before
+    public void setUp() {
+        mockStatic(BlessingsManager.class);
+    }
+
+    @Test
+    public void testColdPassive() {
+        // would NPE if it tries to do anytyhing
+        new MockBlessedActivityTrait(null, null)
+                .getPassiveRxBlessings()
+                .subscribe(b -> fail("Unexpected blessings " + b));
+    }
+
+    @Test
+    public void testBlessingsFromManager() throws Exception {
+        final Activity activity = mock(Activity.class);
+        @SuppressWarnings("unchecked")
+        final Action1<Blessings>
+                cold = mock(Action1.class),
+                hot = mock(Action1.class);
+        final Blessings
+                b1 = PowerMockito.mock(Blessings.class),
+                b2 = PowerMockito.mock(Blessings.class);
+
+        PowerMockito.when(BlessingsManager.getBlessings(any())).thenReturn(b1, b2);
+
+        final MockBlessedActivityTrait t = new MockBlessedActivityTrait(activity, null);
+        t.getPassiveRxBlessings().subscribe(cold);
+
+        t.getRxBlessings().subscribe(hot);
+        verify(hot).call(b1);
+        verify(cold).call(b1);
+        verify(hot, never()).call(b2);
+
+        t.refreshBlessings();
+        verify(hot).call(b2);
+        verify(cold).call(b2);
+    }
+
+    @Test
+    public void testBlessingsFromProvider() throws Exception {
+        final Activity activity = mock(Activity.class);
+        @SuppressWarnings("unchecked")
+        final Action1<Blessings> s = mock(Action1.class);
+        final Blessings
+                b1 = PowerMockito.mock(Blessings.class),
+                b2 = PowerMockito.mock(Blessings.class);
+
+        final MockBlessedActivityTrait t = new MockBlessedActivityTrait(activity, null);
+        t.getRxBlessings().subscribe(s);
+        verify(s, never()).call(any());
+
+        t.offerBlessings(b1);
+        verify(s).call(b1);
+
+        t.refreshBlessings();
+        // The mock BlessingsManager will default to null, so it will seek blessings again.
+        t.offerBlessings(b2);
+        verify(s).call(b2);
+    }
+
+    /**
+     * Verifies that if a new subscriber needs to seek blessings, the new subscriber does not
+     * receive blessings until the seek completes (does not receive old blessings), and that the old
+     * subscriber is refreshed as well.
+     */
+    @Test
+    public void testDeferOnNewSubscriber() throws Exception {
+        final Activity activity = mock(Activity.class);
+        @SuppressWarnings("unchecked")
+        final Action1<Blessings>
+                s1 = mock(Action1.class),
+                s2 = mock(Action1.class);
+        final Blessings
+                b1 = PowerMockito.mock(Blessings.class),
+                b2 = PowerMockito.mock(Blessings.class);
+
+        final MockBlessedActivityTrait t = new MockBlessedActivityTrait(activity, null);
+        t.getRxBlessings().subscribe(s1);
+        t.offerBlessings(b1);
+
+        t.getRxBlessings().subscribe(s2);
+        verify(s2, never()).call(any());
+
+        t.offerBlessings(b2);
+        verify(s1).call(b2);
+        verify(s2).call(b2);
+    }
+}
diff --git a/bakutoolkit/src/test/java/io/v/baku/toolkit/bind/SyncbaseBindingTerminiTest.java b/bakutoolkit/src/test/java/io/v/baku/toolkit/bind/SyncbaseBindingTerminiTest.java
new file mode 100644
index 0000000..ee2d659
--- /dev/null
+++ b/bakutoolkit/src/test/java/io/v/baku/toolkit/bind/SyncbaseBindingTerminiTest.java
@@ -0,0 +1,61 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.baku.toolkit.bind;
+
+import org.junit.Test;
+
+import io.v.rx.RxTestCase;
+import io.v.rx.syncbase.RxTable;
+import io.v.v23.syncbase.nosql.Table;
+import rx.subjects.PublishSubject;
+import rx.subjects.ReplaySubject;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
+
+public class SyncbaseBindingTerminiTest extends RxTestCase {
+    @Test
+    public void testSequencing() throws Exception {
+        final ReplaySubject<Table> mockTables = ReplaySubject.createWithSize(1);
+        final RxTable rxTable = mock(RxTable.class);
+        when(rxTable.getObservable()).thenReturn(mockTables);
+        when(rxTable.once()).thenCallRealMethod();
+
+        final PublishSubject<Integer> rxData = PublishSubject.create();
+
+        final String key = "key";
+        SyncbaseBindingTermini.bindWrite(rxTable, rxData, key, Integer.class, null,
+                this::catchAsync);
+
+        rxData.onNext(1);
+        Thread.sleep(BLOCKING_DELAY_MS);
+
+        rxData.onNext(2);
+        Thread.sleep(BLOCKING_DELAY_MS);
+
+        final Table t1 = mock(Table.class);
+        mockTables.onNext(t1);
+        Thread.sleep(BLOCKING_DELAY_MS);
+        verify(t1).put(null, key, 2, Integer.class);
+
+        rxData.onNext(3);
+        Thread.sleep(BLOCKING_DELAY_MS);
+        verify(t1).put(null, key, 3, Integer.class);
+
+        verifyNoMoreInteractions(t1);
+
+        final Table t2 = mock(Table.class);
+        mockTables.onNext(t2);
+        Thread.sleep(BLOCKING_DELAY_MS);
+        verifyZeroInteractions(t2);
+
+        rxData.onNext(4);
+        Thread.sleep(BLOCKING_DELAY_MS);
+        verify(t2).put(null, key, 4, Integer.class);
+    }
+}
diff --git a/bakutoolkit/src/test/java/io/v/rx/RxNamespaceTest.java b/bakutoolkit/src/test/java/io/v/rx/RxNamespaceTest.java
new file mode 100644
index 0000000..abeb807
--- /dev/null
+++ b/bakutoolkit/src/test/java/io/v/rx/RxNamespaceTest.java
@@ -0,0 +1,166 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.rx;
+
+import org.joda.time.DateTime;
+import org.joda.time.DateTimeConstants;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.concurrent.ConcurrentLinkedQueue;
+
+import io.v.v23.rpc.MountStatus;
+import io.v.v23.rpc.Server;
+import io.v.v23.rpc.ServerStatus;
+import java8.util.function.Predicate;
+import lombok.experimental.Accessors;
+import rx.Observable;
+import rx.Subscriber;
+import rx.subjects.ReplaySubject;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class RxNamespaceTest extends RxTestCase {
+    /**
+     * There is a hack in use in {@link RxNamespace} that compares any timestamp against an
+     * arbitrary value after 1754, currently 1970. For this test, use 2000 as the time in the past.
+     */
+    private static final DateTime
+            THE_PAST = new DateTime(2000, DateTimeConstants.JANUARY, 1, 0, 0),
+            THE_DISTANT_PAST = new DateTime(1990, DateTimeConstants.JANUARY, 1, 0, 0);
+    private static final long STATUS_POLLING_DELAY_MS = verificationDelay(
+            RxMountState.DEFAULT_POLLING_INTERVAL);
+
+    @Accessors(prefix = "m")
+    private class TestSubscriber extends Subscriber<MountEvent> {
+        public boolean mayComplete;
+        /**
+         * This is a queue only as an implementation detail; we do not actually verify order here.
+         */
+        public final Collection<Predicate<MountEvent>> expectedEvents =
+                new ConcurrentLinkedQueue<>();
+
+        @Override
+        public void onCompleted() {
+            try {
+                assertTrue("Unexpectedly unsubscribed", mayComplete);
+            } catch (final Throwable t) {
+                catchAsync(t);
+            }
+        }
+
+        @Override
+        public void onError(final Throwable t) {
+            catchAsync(t);
+        }
+
+        @Override
+        public void onNext(final MountEvent e) {
+            for (final Iterator<Predicate<MountEvent>> tests = expectedEvents.iterator();
+                 tests.hasNext();) {
+                if (tests.next().test(e)) {
+                    tests.remove();
+                    return;
+                }
+            }
+            //all-else
+            fail("Unexpected mount event: " + e);
+        }
+
+        public void assertNoLeftoverExpectations() {
+            //It would be nice to print these, but lambdas don't stringize into anything meaningful.
+            assertTrue("Leftover expectations", expectedEvents.isEmpty());
+        }
+    }
+
+    private static ServerStatus mockStatus(final MountStatus... ms) {
+        return new ServerStatus(null, false, ms, null, null);
+    }
+
+    private static boolean isInitialMountAttemptStart(final MountEvent e) {
+        return e.isMount() && !e.getServer().isPresent() && !e.getError().isPresent();
+    }
+
+    private final Server mServer = mock(Server.class);
+    private final ReplaySubject<Server> mRxServer = ReplaySubject.create();
+    private final TestSubscriber mSubscriber = new TestSubscriber();
+
+    @Before
+    public void setUp() {
+        mRxServer.onNext(mServer);
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        mSubscriber.assertNoLeftoverExpectations();
+    }
+
+    private void attachSubscriber(final Observable<MountEvent> mount) {
+        mount.share().subscribe(mSubscriber);
+    }
+
+    @Test
+    public void testAlreadyMounted() {
+        when(mServer.getStatus()).thenReturn(mockStatus(new MountStatus("foo", "bar",
+                THE_PAST, null, null, THE_DISTANT_PAST, null)));
+
+        mSubscriber.expectedEvents.add(MountEvent::isSuccessfulMount);
+
+        attachSubscriber(RxNamespace.mount(mRxServer, "foo"));
+    }
+
+    @Test
+    public void testExistingOtherNames() {
+        when(mServer.getStatus()).thenReturn(mockStatus(new MountStatus("baz", "bar",
+                THE_PAST, null, null, THE_DISTANT_PAST, null)));
+
+        mSubscriber.expectedEvents.add(RxNamespaceTest::isInitialMountAttemptStart);
+
+        attachSubscriber(RxNamespace.mount(mRxServer, "foo"));
+    }
+
+    private void mountWithOldStatus() {
+        when(mServer.getStatus()).thenReturn(mockStatus(new MountStatus("foo", "bar",
+                THE_DISTANT_PAST, null, null, THE_PAST, null)));
+
+        mSubscriber.expectedEvents.add(RxNamespaceTest::isInitialMountAttemptStart);
+
+        attachSubscriber(RxNamespace.mount(mRxServer, "foo"));
+    }
+
+    @Test
+    public void testMountWithOlderEvents() throws InterruptedException {
+        mountWithOldStatus();
+
+        Thread.sleep(STATUS_POLLING_DELAY_MS);
+        assertNoAsyncErrors();
+    }
+
+    @Test
+    public void testUnsubscribeOnUnmount() throws InterruptedException {
+        mountWithOldStatus();
+        Thread.sleep(BLOCKING_DELAY_MS);
+        assertNoAsyncErrors();
+
+        mSubscriber.mayComplete = true;
+        when(mServer.getStatus()).thenReturn(mockStatus(new MountStatus("foo", "bar",
+                THE_DISTANT_PAST, null, null, DateTime.now(), null)));
+        Thread.sleep(STATUS_POLLING_DELAY_MS);
+        assertTrue("Mount should unsubscribe after unmount", mSubscriber.isUnsubscribed());
+
+        when(mServer.getStatus()).then(i -> {
+            fail("Polling should stop after an unmount");
+            return null;
+        });
+        Thread.sleep(STATUS_POLLING_DELAY_MS);
+        assertNoAsyncErrors();
+    }
+}
diff --git a/bakutoolkit/src/test/java/io/v/rx/RxTestCase.java b/bakutoolkit/src/test/java/io/v/rx/RxTestCase.java
new file mode 100644
index 0000000..d01a542
--- /dev/null
+++ b/bakutoolkit/src/test/java/io/v/rx/RxTestCase.java
@@ -0,0 +1,45 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.rx;
+
+import com.google.common.base.Throwables;
+
+import org.joda.time.Duration;
+import org.junit.After;
+
+import java.util.Collection;
+import java.util.concurrent.ConcurrentLinkedQueue;
+
+import java8.util.stream.Collectors;
+import java8.util.stream.StreamSupport;
+
+import static org.junit.Assert.fail;
+
+public abstract class RxTestCase {
+    public static final long BLOCKING_DELAY_MS = 250;
+
+    public static long verificationDelay(final Duration nominal) {
+        return 2 * nominal.getMillis();
+    }
+
+    private final Collection<Throwable> mErrors = new ConcurrentLinkedQueue<>();
+
+
+    public void catchAsync(final Throwable t) {
+        mErrors.add(t);
+    }
+
+    /**
+     * Tests should call this where it make sense and to fail early if possible.
+     */
+    @After
+    public void assertNoAsyncErrors() {
+        if (!mErrors.isEmpty()) {
+            fail(StreamSupport.stream(mErrors)
+                    .map(Throwables::getStackTraceAsString)
+                    .collect(Collectors.joining("\n")));
+        }
+    }
+}
diff --git a/bakutoolkit/src/test/java/io/v/rx/syncbase/GlobalUserSyncgroupTest.java b/bakutoolkit/src/test/java/io/v/rx/syncbase/GlobalUserSyncgroupTest.java
new file mode 100644
index 0000000..565f7d5
--- /dev/null
+++ b/bakutoolkit/src/test/java/io/v/rx/syncbase/GlobalUserSyncgroupTest.java
@@ -0,0 +1,169 @@
+package io.v.rx.syncbase;// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+import com.google.common.base.Stopwatch;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.core.classloader.annotations.SuppressStaticInitializationFor;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import io.v.baku.toolkit.BlessingsUtils;
+import io.v.debug.SyncbaseClient;
+import io.v.rx.RxMountState;
+import io.v.rx.RxTestCase;
+import io.v.v23.context.VContext;
+import io.v.v23.rpc.MountStatus;
+import io.v.v23.rpc.Server;
+import io.v.v23.rpc.ServerStatus;
+import io.v.v23.security.Blessings;
+import io.v.v23.syncbase.SyncbaseApp;
+import io.v.v23.syncbase.SyncbaseService;
+import io.v.v23.syncbase.nosql.Database;
+import io.v.v23.syncbase.nosql.Syncgroup;
+import java8.util.stream.RefStreams;
+import rx.Subscription;
+import rx.subjects.ReplaySubject;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@RunWith(PowerMockRunner.class)
+@SuppressStaticInitializationFor("io.v.baku.toolkit.BlessingsUtils")
+@PrepareForTest({BlessingsUtils.class, SgHostUtil.class})
+public class GlobalUserSyncgroupTest extends RxTestCase {
+    private static final long STATUS_POLLING_DELAY_MS = verificationDelay(
+            RxMountState.DEFAULT_POLLING_INTERVAL);
+
+    private final VContext mVContext = mock(VContext.class);
+
+    private final ReplaySubject<Blessings> mRxBlessings = ReplaySubject.create();
+    private final ReplaySubject<Server> mRxServer = ReplaySubject.create();
+    private final ReplaySubject<SyncbaseService> mRxClient = ReplaySubject.create();
+
+    private final Server mServer = mock(Server.class);
+    private final SyncbaseService mClient = mock(SyncbaseService.class);
+    private final Database mDb = mock(Database.class);
+    private final Syncgroup mSg = mock(Syncgroup.class);
+
+    private RxSyncbase mSb;
+
+    @Before
+    public void setUp() throws Exception {
+        final SyncbaseClient sbClient = mock(SyncbaseClient.class);
+        final SyncbaseApp app = mock(SyncbaseApp.class);
+
+        when(sbClient.getRxServer()).thenReturn(mRxServer);
+        when(sbClient.getRxClient()).thenReturn(mRxClient);
+
+        mRxServer.onNext(mServer);
+        mRxClient.onNext(mClient);
+
+        when(mClient.getApp("app")).thenReturn(app);
+        when(app.getNoSqlDatabase(eq("db"), any())).thenReturn(mDb);
+
+        mSb = new RxSyncbase(null, sbClient);
+
+        PowerMockito.spy(SgHostUtil.class);
+    }
+
+    private Subscription joinMockSyncgroup() throws Exception {
+        when(mDb.getSyncgroup(RxSyncbase.syncgroupName("users/foo@bar.com/app/sghost", "sg")))
+                .thenReturn(mSg);
+        final Stopwatch t = Stopwatch.createStarted();
+
+        final Subscription subscription = GlobalUserSyncgroup.builder()
+                .vContext(mVContext)
+                .rxBlessings(mRxBlessings)
+                .syncHostLevel(new UserAppSyncHost("app", "sghost", "sgmt"))
+                .sgSuffix("sg")
+                .syncbase(mSb)
+                .db(mSb.rxApp("app").rxDb("db"))
+                .onError((m, e) -> catchAsync(e))
+                .build()
+                .join();
+
+        PowerMockito.spy(BlessingsUtils.class);
+        PowerMockito.doReturn(RefStreams.of("foo@bar.com"))
+                .when(BlessingsUtils.class, "blessingsToUsernameStream", any(), any());
+        PowerMockito.doReturn(null)
+                .when(BlessingsUtils.class, "blessingsToAcl", any(), any());
+        PowerMockito.doReturn(null)
+                .when(BlessingsUtils.class, "homogeneousPermissions", any(), any());
+
+        long elapsed = t.elapsed(TimeUnit.MILLISECONDS);
+        if (elapsed > BLOCKING_DELAY_MS) {
+            fail("GlobalUserSyncgroup.join should not block; took " + elapsed + " ms (threshold " +
+                    BLOCKING_DELAY_MS + " ms)");
+        }
+        return subscription;
+    }
+
+    @Test
+    public void testJoinAlreadyMounted() throws Exception {
+        PowerMockito.doReturn(true)
+                .when(SgHostUtil.class, "isSyncbaseOnline", any(), any());
+        joinMockSyncgroup();
+        mRxBlessings.onNext(null);
+        Thread.sleep(STATUS_POLLING_DELAY_MS +
+                SgHostUtil.SYNCBASE_PING_TIMEOUT.getMillis());
+        verify(mServer, never()).addName(any());
+        verify(mServer, never()).getStatus();
+        verify(mSg).join(any(), any());
+    }
+
+    @Test
+    public void testJoinMountLifecycle() throws Exception {
+        PowerMockito.doReturn(false)
+                .when(SgHostUtil.class, "isSyncbaseOnline", any(), any());
+        final Subscription subscription = joinMockSyncgroup();
+
+        final AtomicInteger statusPolls = new AtomicInteger();
+        final ServerStatus serverStatus = mock(ServerStatus.class);
+        when(serverStatus.getMounts()).then(i -> {
+            statusPolls.incrementAndGet();
+            return new MountStatus[0];
+        });
+        when(mServer.getStatus()).thenReturn(serverStatus);
+
+        Thread.sleep(STATUS_POLLING_DELAY_MS);
+        verify(mServer, never()).addName(any());
+        assertEquals("Polling should not start until blessings are resolved", 0, statusPolls.get());
+
+        mRxBlessings.onNext(null);
+        //Verify 3 polls + initial to ensure polling loop is working.
+        Thread.sleep(4 * RxMountState.DEFAULT_POLLING_INTERVAL.getMillis() +
+                SgHostUtil.SYNCBASE_PING_TIMEOUT.getMillis());
+        verify(mServer).addName("users/foo@bar.com/app/sghost");
+        final int nPolls = statusPolls.get();
+        if (nPolls < 4) {
+            fail("Polling should start and continue after blessings are resolved (" + nPolls +
+                    "/4-5 expected polls)");
+        }
+
+        try {
+            subscription.unsubscribe();
+        } catch (final IllegalArgumentException expected) {
+            // https://github.com/ReactiveX/RxJava/pull/3167
+            // This should be fixed in the next version of RxJava.
+        }
+        Thread.sleep(BLOCKING_DELAY_MS);
+        statusPolls.set(0);
+        Thread.sleep(STATUS_POLLING_DELAY_MS);
+        assertEquals("Polling should stop after Syncgroup join is unsubscribed",
+                0, statusPolls.get());
+    }
+}
diff --git a/build.gradle b/build.gradle
new file mode 100644
index 0000000..7975321
--- /dev/null
+++ b/build.gradle
@@ -0,0 +1,22 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+
+buildscript {
+    repositories {
+        jcenter()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:1.3.0'
+        classpath 'me.tatarka:gradle-retrolambda:3.2.3'
+
+        // NOTE: Do not place your application dependencies here; they belong
+        // in the individual module build.gradle files
+    }
+}
+
+allprojects {
+    repositories {
+        jcenter()
+        mavenCentral()
+    }
+}
diff --git a/gradle.properties b/gradle.properties
new file mode 100644
index 0000000..1d3591c
--- /dev/null
+++ b/gradle.properties
@@ -0,0 +1,18 @@
+# Project-wide Gradle settings.
+
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+# Default value: -Xmx10248m -XX:MaxPermSize=256m
+# org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
+
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true
\ No newline at end of file
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000..8c0fb64
--- /dev/null
+++ b/gradle/wrapper/gradle-wrapper.jar
Binary files differ
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000..de00d04
--- /dev/null
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,6 @@
+#Thu Oct 15 16:37:26 PDT 2015
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.4-all.zip
diff --git a/gradlew b/gradlew
new file mode 100755
index 0000000..91a7e26
--- /dev/null
+++ b/gradlew
@@ -0,0 +1,164 @@
+#!/usr/bin/env bash
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+esac
+
+# For Cygwin, ensure paths are in UNIX format before anything is touched.
+if $cygwin ; then
+    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
+fi
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >&-
+APP_HOME="`pwd -P`"
+cd "$SAVED" >&-
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
+}
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
diff --git a/gradlew.bat b/gradlew.bat
new file mode 100644
index 0000000..aec9973
--- /dev/null
+++ b/gradlew.bat
@@ -0,0 +1,90 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windowz variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/settings.gradle b/settings.gradle
new file mode 100644
index 0000000..f11ede4
--- /dev/null
+++ b/settings.gradle
@@ -0,0 +1 @@
+include ':bakutoolkit'