@atlastodo/client-core 0.1.11-rc.7 → 0.1.11-rc.9

package/dist/crypto/rootKey.d.ts

@@ -16,6 +16,8 @@
  */
 /** The app whose key is the account's original DEK. */
 export declare const TODO_APP = "todo";
+/** Atlas Journal: its key and identity are a row under the root (`enableApp`). */
+export declare const JOURNAL_APP = "journal";
 /** A key wrapped under another (root slot, app key, app identity). */
 export interface RootKeyWrap {
     v: 1;

package/dist/fieldPolicy.d.ts

@@ -7,7 +7,21 @@
  * reads against.
  */
 import type { EntityKind } from "./types.js";
-/** A bundled app manifest: its id, version and the entity kinds it syncs. */
+/**
+ * What an app asks of the API tokens that include it (`api_tokens` in its manifest), which the
+ * server enforces. Absent keys are the defaults: no expiry needed, writes allowed.
+ */
+export interface TokenPolicy {
+    /** A token must name an expiry. */
+    expiry_required: boolean;
+    /** The latest expiry a token may name, in days after it is made; null is no limit. */
+    max_lifetime_days: number | null;
+    /** Whether a token may write when its creator does not say. */
+    write_by_default: boolean;
+    /** A token including the app may include no other app (the server refuses the mix). */
+    exclusive: boolean;
+}
+/** A bundled app manifest: its id, version, the entity kinds it syncs and its token policy. */
 export interface AppManifest {
     app: string;
     name: string;
@@ -15,14 +29,28 @@ export interface AppManifest {
     kinds: Record<string, {
         plaintext_fields: readonly string[] | "all";
     }>;
+    api_tokens?: Partial<TokenPolicy>;
 }
 /**
  * The manifests bundled into this client, as the server bundles them. `EntityKind` (and so
- * {@link PLAINTEXT_FIELDS}) is todo's kinds: this store syncs todo. Another app's client reads its
- * kinds from its own manifest here (journal's encrypt every field).
+ * {@link PLAINTEXT_FIELDS}) holds every bundled app's kinds, as `atlas_core::EntityKind` does;
+ * which of them a client syncs is its session's app scope. Journal's and the vault's kinds
+ * encrypt every field.
  */
 export declare const BUNDLED_MANIFESTS: readonly AppManifest[];
+/**
+ * The policy of a token for all of `apps` (bundled ids), the strictest of theirs as the server
+ * takes it: an expiry required if any requires one, the shortest lifetime, and read-only by
+ * default if any is, and exclusive if any is. A client making a token reads it to ask for an expiry
+ * and write access, and to offer an exclusive app's token on its own.
+ */
+export declare function tokenPolicyFor(apps: readonly string[]): TokenPolicy;
 /** The bundled app owning the kind with this wire name, if any. */
 export declare function appOfKind(kind: string): AppManifest | undefined;
 export declare const PLAINTEXT_FIELDS: Readonly<Record<EntityKind, readonly string[] | "all">>;
+/**
+ * Whether a value of `entity`.`field` is end-to-end encrypted, for any wire kind: a kind no
+ * bundled manifest names encrypts everything.
+ */
+export declare function shouldEncryptKindField(entity: string, field: string): boolean;
 export declare function shouldEncryptField(entity: EntityKind, field: string): boolean;

package/dist/index.d.ts

@@ -15,6 +15,7 @@ export * from "./trust.js";
 export * from "./store.js";
 export * from "./opLogFile.js";
 export * from "./persistence.js";
+export * from "./sealedPersistence.js";
 export * from "./attachments.js";
 export * from "./indexeddb.js";
 export * from "./expo-sqlite.js";

package/dist/index.js

@@ -1099,6 +1099,7 @@ import { x25519 as x255193 } from "@noble/curves/ed25519.js";
 import { sha256 as sha2566 } from "@noble/hashes/sha2.js";
 import { hkdf as hkdf5 } from "@noble/hashes/hkdf.js";
 var TODO_APP = "todo";
+var JOURNAL_APP = "journal";
 var KEY_BYTES = 32;
 var json = (parts) => utf8ToBytes(JSON.stringify(parts));
 var rootAad = (userId, slot) => json(["atlas-root-key", 1, userId.toLowerCase(), slot]);
@@ -1475,12 +1476,54 @@ var todo_default = {
     }
   }
 };
+// ../../manifests/vault.json
+var vault_default = {
+  _doc: "The Atlas Vault app manifest: a password manager, end-to-end encrypted, held to a stricter threat model than todo. Its kinds are namespaced `vault.<kind>`. Vault v1 is personal: the server never fans its ops out to another account and reads none of their fields, so every field value is encrypted (no plaintext_fields), including the item type, its folder and its timestamps. `vault.item` is one item (login, note, card, identity, ssh_key, api_key: name, typed fields, urls, notes, tags, folder, favorite, secret field history), `vault.folder` one folder, `vault.preference` one of the app's settings. `api_tokens` is the policy for API tokens that include the app, which the server enforces: an expiry is required, at most `max_lifetime_days` after creation, a token is read-only unless its creator opts in to writes, and it is for the vault alone (`exclusive`: no other app's key travels with a vault secret). Bump `version` whenever the kinds, their plaintext fields or the token policy change.",
+  app: "vault",
+  name: "Atlas Vault",
+  version: 2,
+  kinds: {
+    "vault.item": { plaintext_fields: [] },
+    "vault.folder": { plaintext_fields: [] },
+    "vault.preference": { plaintext_fields: [] }
+  },
+  api_tokens: {
+    expiry_required: true,
+    max_lifetime_days: 365,
+    write_by_default: false,
+    exclusive: true
+  }
+};
 
 // src/fieldPolicy.ts
 var BUNDLED_MANIFESTS = Object.freeze([
   todo_default,
-  journal_default
+  journal_default,
+  vault_default
 ]);
+function tokenPolicyFor(apps) {
+  const policy = {
+    expiry_required: false,
+    max_lifetime_days: null,
+    write_by_default: true,
+    exclusive: false
+  };
+  for (const app of apps) {
+    const p = BUNDLED_MANIFESTS.find((m) => m.app === app)?.api_tokens;
+    if (!p)
+      continue;
+    if (p.expiry_required)
+      policy.expiry_required = true;
+    if (p.max_lifetime_days != null) {
+      policy.max_lifetime_days = policy.max_lifetime_days == null ? p.max_lifetime_days : Math.min(policy.max_lifetime_days, p.max_lifetime_days);
+    }
+    if (p.write_by_default === false)
+      policy.write_by_default = false;
+    if (p.exclusive)
+      policy.exclusive = true;
+  }
+  return policy;
+}
 function appOfKind(kind) {
   return BUNDLED_MANIFESTS.find((m) => Object.prototype.hasOwnProperty.call(m.kinds, kind));
 }
@@ -1498,7 +1541,12 @@ var ENTITY_KINDS = {
   focus_session: true,
   habit: true,
   habit_checkin: true,
-  attachment: true
+  attachment: true,
+  "journal.entry": true,
+  "journal.preference": true,
+  "vault.item": true,
+  "vault.folder": true,
+  "vault.preference": true
 };
 function loadTable(manifests) {
   const table = {};
@@ -1515,6 +1563,12 @@ function loadTable(manifests) {
   return Object.freeze(table);
 }
 var PLAINTEXT_FIELDS = loadTable(BUNDLED_MANIFESTS);
+function shouldEncryptKindField(entity, field) {
+  const plain = appOfKind(entity)?.kinds[entity]?.plaintext_fields;
+  if (plain === "all")
+    return false;
+  return !plain?.includes(field);
+}
 function shouldEncryptField(entity, field) {
   const plain = PLAINTEXT_FIELDS[entity];
   if (plain === "all")
@@ -4649,8 +4703,110 @@ function rowToOp(r) {
     value: r.value_json === null ? undefined : JSON.parse(r.value_json)
   };
 }
-// src/attachments.ts
+// src/sealedPersistence.ts
+import { hkdf as hkdf7 } from "@noble/hashes/hkdf.js";
 import { sha256 as sha2568 } from "@noble/hashes/sha2.js";
+var LOCAL_STORE_KEY_ID = "local-v1";
+var SCOPE = { kind: "personal" };
+function deriveLocalStoreKey(appKey, userId) {
+  if (appKey.length !== 32)
+    throw new Error("the app key must be 32 bytes");
+  return hkdf7(sha2568, appKey, utf8ToBytes(userId), utf8ToBytes("atlas-local-store-v1"), 32);
+}
+
+class SealedStoreError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SealedStoreError";
+  }
+}
+function seal(key, entity, entityId, field, value) {
+  return encryptField(key, LOCAL_STORE_KEY_ID, SCOPE, { entity, entityId, field }, value);
+}
+function open(key, entity, entityId, field, stored) {
+  if (!isFieldEnvelopeV2(stored) || stored.kid !== LOCAL_STORE_KEY_ID) {
+    throw new SealedStoreError(`a stored value of ${entity}.${field} is not sealed`);
+  }
+  try {
+    return decryptField(key, SCOPE, { entity, entityId, field }, stored);
+  } catch {
+    throw new SealedStoreError(`a stored value of ${entity}.${field} does not open with this key`);
+  }
+}
+function sealOp(key, op) {
+  if (op.op !== "set")
+    return op;
+  return { ...op, value: seal(key, op.entity, op.entityId, op.field, op.value) };
+}
+function openOp(key, op) {
+  if (op.op !== "set")
+    return op;
+  return { ...op, value: open(key, op.entity, op.entityId, op.field, op.value) };
+}
+function sealRepairs(key, repairs) {
+  return repairs.map((r) => ({ ...r, value: seal(key, r.entity, r.entityId, r.field, r.value) }));
+}
+function openRepairs(key, repairs) {
+  return repairs.map((r) => ({ ...r, value: open(key, r.entity, r.entityId, r.field, r.value) }));
+}
+function sealPersistence(inner, key) {
+  if (key.length !== 32)
+    throw new Error("the local store key must be 32 bytes");
+  const sealed = {
+    load: async () => (await inner.load()).map((p) => ({ ...p, op: openOp(key, p.op) })),
+    append: (op, synced) => inner.append(sealOp(key, op), synced),
+    markSynced: (opIds) => inner.markSynced(opIds),
+    getCursor: () => inner.getCursor(),
+    setCursor: (cursor) => inner.setCursor(cursor)
+  };
+  if (inner.appendBatch) {
+    const appendBatch = inner.appendBatch.bind(inner);
+    sealed.appendBatch = (ops, synced) => appendBatch(ops.map((op) => sealOp(key, op)), synced);
+  }
+  if (inner.getBootstrap) {
+    const getBootstrap = inner.getBootstrap.bind(inner);
+    sealed.getBootstrap = async () => {
+      const progress = await getBootstrap();
+      if (!progress?.repairs)
+        return progress;
+      return { ...progress, repairs: openRepairs(key, progress.repairs) };
+    };
+  }
+  if (inner.setBootstrap) {
+    const setBootstrap = inner.setBootstrap.bind(inner);
+    sealed.setBootstrap = (progress, page) => setBootstrap(progress && progress.repairs ? { ...progress, repairs: sealRepairs(key, progress.repairs) } : progress, page ? { ...page, repairs: sealRepairs(key, page.repairs) } : page);
+  }
+  if (inner.commitSyncBatch) {
+    const commit = inner.commitSyncBatch.bind(inner);
+    sealed.commitSyncBatch = (ops, cursor) => commit(ops.map((op) => sealOp(key, op)), cursor);
+  }
+  if (inner.restamp) {
+    const restamp = inner.restamp.bind(inner);
+    sealed.restamp = (ops) => restamp(ops.map((op) => sealOp(key, op)));
+  }
+  const passThrough = [
+    "clear",
+    "clearSynced",
+    "compact",
+    "deleteOps",
+    "close",
+    "loadAttachmentQueue",
+    "putAttachmentUpload",
+    "deleteAttachmentUpload",
+    "listAttachmentQueue",
+    "loadAttachmentCiphertext",
+    "updateAttachmentUpload"
+  ];
+  for (const name of passThrough) {
+    const fn = inner[name];
+    if (typeof fn === "function") {
+      sealed[name] = fn.bind(inner);
+    }
+  }
+  return sealed;
+}
+// src/attachments.ts
+import { sha256 as sha2569 } from "@noble/hashes/sha2.js";
 var DEFAULT_MAX_BLOB_BYTES = 25 * 1024 * 1024;
 function maxAttachmentBytes(maxBlobBytes = DEFAULT_MAX_BLOB_BYTES) {
   return maxPlainSize(maxBlobBytes);
@@ -4668,7 +4824,7 @@ function generateAek() {
   return randomBytes(32);
 }
 function sha256Hex(bytes) {
-  return bytesToHex(sha2568(bytes));
+  return bytesToHex(sha2569(bytes));
 }
 function bytesSource(bytes) {
   return {
@@ -4727,8 +4883,8 @@ async function sealSource(aek, source, opts = {}) {
   const expected = sealedBlobSize(total);
   const sink = opts.asBlob ? new BlobSink : new BufferSink(expected);
   const sealer = new BlobSealer(aek);
-  const blobHash = sha2568.create();
-  const plainHash = sha2568.create();
+  const blobHash = sha2569.create();
+  const plainHash = sha2569.create();
   let size = 0;
   const emit = (bytes) => {
     blobHash.update(bytes);
@@ -4791,7 +4947,7 @@ class PlainCollector {
   out;
   parts = [];
   length = 0;
-  hash = sha2568.create();
+  hash = sha2569.create();
   constructor(blobSize) {
     this.out = blobSize !== null && blobSize <= MAX_PREALLOCATION ? new Uint8Array(blobSize) : null;
   }
@@ -4869,7 +5025,7 @@ async function fetchBlob(transport, sha, aek, plainSha) {
   const download = body instanceof Uint8Array ? { size: body.length, chunks: [body] } : body;
   const opener = new BlobOpener(aek);
   const plain = new PlainCollector(download.size);
-  const received = sha2568.create();
+  const received = sha2569.create();
   for await (const piece of download.chunks) {
     received.update(piece);
     for (const chunk of opener.push(piece))
@@ -6635,10 +6791,12 @@ export {
   HlcClock,
   IndexedDbPersistence,
   InvalidApiTokenError,
+  JOURNAL_APP,
   KEY_TRUST_ID,
   Keyring,
   LEGACY_DISCOVERY,
   LEGACY_KDF,
+  LOCAL_STORE_KEY_ID,
   LocalStore,
   MAX_CLOCK_DRIFT_MS,
   MAX_COUNTER,
@@ -6665,6 +6823,7 @@ export {
   SNAPSHOT_PAGE_KEYS,
   SYNC_APPS_HEADER,
   SYNC_PROTOCOL,
+  SealedStoreError,
   ServerIncompatibleError,
   SqlitePersistence,
   SyncClient,
@@ -6714,6 +6873,7 @@ export {
   deriveApiTokenKeys,
   deriveAuthAndMek,
   deriveAuthAndMekAsync,
+  deriveLocalStoreKey,
   derivePasskeySlotKey,
   deriveRecoveryAuthKeypair,
   deriveRecoveryKey,
@@ -6815,6 +6975,7 @@ export {
   sameKeyScope,
   sealDelivery,
   sealKey,
+  sealPersistence,
   sealRootKey,
   sealSource,
   sealedBlobSize,
@@ -6824,6 +6985,7 @@ export {
   setPbkdf2Provider,
   sharedProjectIds,
   shouldEncryptField,
+  shouldEncryptKindField,
   signDelivery,
   signInWithPasskey,
   signingPublicKey,
@@ -6832,6 +6994,7 @@ export {
   toEncryptedWire,
   toWireReport,
   todoAppKeyRow,
+  tokenPolicyFor,
   unpadPlaintext,
   unpinMemberKey,
   unsealKey,

package/dist/sealedPersistence.d.ts

@@ -0,0 +1,39 @@
+import type { Persistence } from "./persistence.js";
+/**
+ * A {@link Persistence} that keeps every op's value encrypted at rest.
+ *
+ * The local op log holds what the store merged: values already decrypted from the wire. For most
+ * apps that is the device's own business, but a client that locks (a password manager) must not
+ * leave its data readable on disk while it is locked. `sealPersistence(inner, key)` wraps any
+ * backend (IndexedDB, SQLite, memory) so that each `set` op's value, and each bootstrap repair's,
+ * is stored as a field envelope under `key` instead; loading opens them again. Everything else
+ * (op ids, entities, entity ids, field names, clocks, the cursor) is stored as before: the same
+ * metadata the server sees.
+ *
+ * The envelope is the wire's v2 field envelope (AES-256-GCM, padded, associated data naming the
+ * entity, field and scope) with its own key id ({@link LOCAL_STORE_KEY_ID}), so a value sealed
+ * here can neither be opened at another field nor pass for a wire envelope. Use a key of its own
+ * ({@link deriveLocalStoreKey}), not the app key itself.
+ *
+ * Every stored value must be sealed: a backend written without the wrapper, or under another key,
+ * fails to load with {@link SealedStoreError} rather than half-load (start over with `clear()`).
+ * Attachment queue rows pass through unchanged (their blob is already ciphertext; their metadata
+ * is not sealed): a client that needs them sealed must not queue attachments through this.
+ */
+/** The key id of a value sealed at rest; never one the wire uses. */
+export declare const LOCAL_STORE_KEY_ID = "local-v1";
+/**
+ * The at-rest key for a user's local store, derived from an app key the client holds only while
+ * unlocked (HKDF-SHA256, salted with the user id, info `atlas-local-store-v1`).
+ */
+export declare function deriveLocalStoreKey(appKey: Uint8Array, userId: string): Uint8Array;
+/** A stored value that does not open under this key (another key, tampering, or never sealed). */
+export declare class SealedStoreError extends Error {
+    constructor(message: string);
+}
+/**
+ * `inner` with every value sealed under `key` (32 bytes). The wrapper offers exactly the optional
+ * methods `inner` does, so a store's behaviour (batching, restamping, bootstrap resume) is the
+ * inner backend's. Keep a reference to `key` only while the client is unlocked.
+ */
+export declare function sealPersistence(inner: Persistence, key: Uint8Array): Persistence;

package/dist/types.d.ts

@@ -330,6 +330,10 @@ export interface ApiTokenView {
     apps?: string[];
     created_at: number;
     last_used_at?: number;
+    /** When the token stops working; absent when it never does. An expired token stays listed until revoked. */
+    expires_at?: number;
+    /** Whether its sessions may write (absent from servers predating read-only tokens: they may). */
+    write?: boolean;
 }
 /** One non-todo app's key and X25519 identity wrapped for an API token (`wrapAppKeysForApiToken`). */
 export interface ApiTokenAppKeyWraps {
@@ -365,6 +369,14 @@ export interface CreateApiTokenPayload {
         ct: string;
     };
     app_keys?: Record<string, ApiTokenAppKeyWraps>;
+    /**
+     * When the token stops working (unix ms). The apps' policy ({@link tokenPolicyFor}) may require
+     * one and cap how far out it is: a vault token needs one at most 365 days ahead (needs the
+     * `api_token_policies` capability).
+     */
+    expires_at?: number;
+    /** Whether its sessions may write; the policy's default when absent (a vault token is read-only). */
+    write?: boolean;
 }
 /** `POST /auth/api-token/session`: an access token (no refresh token) and the token's wraps. */
 export interface ApiTokenSessionResponse {
@@ -393,6 +405,10 @@ export interface ApiTokenSessionResponse {
         iv: string;
         ct: string;
     };
+    /** When the token expires (unix ms); `expires_in` ends no later. Absent when it never does. */
+    expires_at?: number;
+    /** Whether the session may write; a read-only one gets 403 `api_token_read_only` on writes. */
+    write?: boolean;
 }
 export interface MemberView {
     user_id: string;
@@ -442,7 +458,17 @@ export type Operation = {
 });
 export type EntityKind = "task" | "project" | "section" | "label" | "comment" | "preference" | "saved_filter" | "reminder" | "project_member" | "activity" | "focus_session" | "habit" | "habit_checkin"
 /** Metadata only; ciphertext travels via `/attachments/blobs/:sha256`. */
- | "attachment";
+ | "attachment"
+/**
+ * Atlas Journal's kinds (`manifests/journal.json`), namespaced `<app>.<kind>` like every app's
+ * after todo. Personal and fully encrypted: no plaintext field, no project scope. A journal
+ * client syncs them in a journal-scoped session (`ApiClientOptions.apps`).
+ */
+ | JournalEntityKind
+/** Atlas Vault (`manifests/vault.json`): personal, every field encrypted. */
+ | "vault.item" | "vault.folder" | "vault.preference";
+/** Atlas Journal's entity kinds: `journal.entry` (one entry) and `journal.preference` (a setting). */
+export type JournalEntityKind = "journal.entry" | "journal.preference";
 export interface CreateTaskInput {
     title: string;
     notes?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlastodo/client-core",
-  "version": "0.1.11-rc.7",
+  "version": "0.1.11-rc.9",
   "description": "Atlas core client: hybrid logical clocks, the op log and per-field LWW merge, end-to-end encryption, the local store and the sync client",
   "license": "AGPL-3.0-only",
   "homepage": "https://github.com/atlastodo/atlas/tree/main/packages/client-core",
@@ -36,6 +36,7 @@
       "api_token_vectors.json",
       "conflict_vectors.json",
       "envelope_vectors.json",
+      "field_policy_vectors.json",
       "identity_vectors.json",
       "passkey_vectors.json",
       "password_kdf_vectors.json",

package/test-vectors/api_token_vectors.json

@@ -34,6 +34,20 @@
             "iv": "dXrtP9iobV/5dQK7",
             "ct": "YVQDhrVqw2A7XxrJ1DBI/qTTTVQ0FlPSaGNiMxAE5GyMh3JDOvj6Sl4JjdNi0xQY"
           }
+        },
+        "vault": {
+          "app_key": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+          "app_private_key": "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+          "wrapped_key": {
+            "v": 1,
+            "iv": "wm+GsbI61xROnC8+",
+            "ct": "3wMTljSLoopA53SXjhbdhPFksiuOdMXNmj7HGqiU+ByMqb794Vb57+NVh0Br9FZv"
+          },
+          "wrapped_private_key": {
+            "v": 1,
+            "iv": "/QKoOwtHubDapdW1",
+            "ct": "UFyTM//C7trgffAR2i0JDdLwtRf6I/9l+eq6oixMefK3KtXZixSE6RF5Flrdzf7C"
+          }
         }
       }
     }

package/test-vectors/field_policy_vectors.json

@@ -0,0 +1,52 @@
+{
+  "_doc": "What the bundled app manifests (manifests/*.json) decide, asserted by packages/client-core/src/fieldPolicy.test.ts and crates/atlas-client (field_policy.rs). `fields`: whether a value of `entity`.`field` leaves the device end-to-end encrypted (`encrypted`); a kind no manifest names, and any field a manifest does not list, is encrypted. Todo keeps only the ids the server routes and checks access by in plaintext; journal and vault keep nothing, so the server sees no vault item's type, name, folder, URL, timestamp or secret. `token_policies`: the API token policy of a token for `apps`, the strictest of their manifests' `api_tokens` (`max_lifetime_days` null is no limit; `exclusive`: the server refuses a token naming such an app with any other).",
+  "fields": [
+    { "entity": "task", "field": "title", "encrypted": true },
+    { "entity": "task", "field": "project_id", "encrypted": false },
+    { "entity": "task", "field": "assignee_id", "encrypted": false },
+    { "entity": "task", "field": "a_field_nobody_declared", "encrypted": true },
+    { "entity": "comment", "field": "task_id", "encrypted": false },
+    { "entity": "attachment", "field": "blob_sha", "encrypted": false },
+    { "entity": "project_member", "field": "anything", "encrypted": false },
+    { "entity": "journal.entry", "field": "body", "encrypted": true },
+    { "entity": "journal.entry", "field": "date", "encrypted": true },
+    { "entity": "journal.entry", "field": "project_id", "encrypted": true },
+    { "entity": "vault.item", "field": "type", "encrypted": true },
+    { "entity": "vault.item", "field": "name", "encrypted": true },
+    { "entity": "vault.item", "field": "fields", "encrypted": true },
+    { "entity": "vault.item", "field": "urls", "encrypted": true },
+    { "entity": "vault.item", "field": "notes", "encrypted": true },
+    { "entity": "vault.item", "field": "tags", "encrypted": true },
+    { "entity": "vault.item", "field": "folder", "encrypted": true },
+    { "entity": "vault.item", "field": "favorite", "encrypted": true },
+    { "entity": "vault.item", "field": "history", "encrypted": true },
+    { "entity": "vault.item", "field": "created_at", "encrypted": true },
+    { "entity": "vault.item", "field": "updated_at", "encrypted": true },
+    { "entity": "vault.item", "field": "deleted_at", "encrypted": true },
+    { "entity": "vault.item", "field": "project_id", "encrypted": true },
+    { "entity": "vault.item", "field": "task_id", "encrypted": true },
+    { "entity": "vault.folder", "field": "name", "encrypted": true },
+    { "entity": "vault.folder", "field": "deleted_at", "encrypted": true },
+    { "entity": "vault.preference", "field": "value", "encrypted": true },
+    { "entity": "notes.note", "field": "body", "encrypted": true },
+    { "entity": "notes.note", "field": "project_id", "encrypted": true }
+  ],
+  "token_policies": [
+    {
+      "apps": ["todo"],
+      "policy": { "expiry_required": false, "max_lifetime_days": null, "write_by_default": true, "exclusive": false }
+    },
+    {
+      "apps": ["journal"],
+      "policy": { "expiry_required": false, "max_lifetime_days": null, "write_by_default": true, "exclusive": false }
+    },
+    {
+      "apps": ["vault"],
+      "policy": { "expiry_required": true, "max_lifetime_days": 365, "write_by_default": false, "exclusive": true }
+    },
+    {
+      "apps": ["todo", "journal", "vault"],
+      "policy": { "expiry_required": true, "max_lifetime_days": 365, "write_by_default": false, "exclusive": true }
+    }
+  ]
+}