refactor: rename items to memos, flatten lexicon names

README.md

···
 # Cistern
 
-Cistern is a private, end-to-end encrypted quick-capture system built on AT Protocol. Items are encrypted using post-quantum cryptography and stored temporarily in your Personal Data Server (PDS), then automatically retrieved and deleted after consumption.
+Cistern is a private, end-to-end encrypted quick-capture system built on AT
+Protocol. Memos are encrypted using post-quantum cryptography and stored
+temporarily in your Personal Data Server (PDS), then automatically retrieved and
+deleted after consumption.
 
-The system bridges the gap between where ideas are captured and where they are stored long-term. Create an encrypted item on your phone, and it automatically appears in your desktop application, decrypted and ready to use.
+The system bridges the gap between where ideas are captured and where they are
+stored long-term. Create an encrypted memo on your phone, and it automatically
+appears in your desktop application, decrypted and ready to use.
 
 ## Architecture
 
 Cistern is a Deno monorepo consisting of five packages:
 
 ### `@cistern/crypto`
-Core cryptographic operations using post-quantum algorithms. Implements X-Wing key encapsulation with XChaCha20-Poly1305 authenticated encryption and SHA3-512 integrity verification. Handles keypair generation, encryption, and decryption.
+
+Core cryptographic operations using post-quantum algorithms. Implements X-Wing
+key encapsulation with XChaCha20-Poly1305 authenticated encryption and SHA3-512
+integrity verification. Handles keypair generation, encryption, and decryption.
 
 ### `@cistern/lexicon`
-AT Protocol schema definitions for Cistern record types. Defines `app.cistern.lexicon.pubkey` (public key records) and `app.cistern.lexicon.item` (encrypted item records). Includes code generation from JSON schemas.
+
+AT Protocol schema definitions for Cistern record types. Defines
+`app.cistern.pubkey` (public key records) and `app.cistern.memo` (encrypted memo
+records). Includes code generation from JSON schemas.
 
 ### `@cistern/shared`
-Common utilities and authentication logic. Handles DID resolution via Slingshot service and creates authenticated RPC clients using app passwords.
+
+Common utilities and authentication logic. Handles DID resolution via Slingshot
+service and creates authenticated RPC clients using app passwords.
 
 ### `@cistern/producer`
-Creates and encrypts items for storage. Manages public key selection, encrypts plaintext content, and uploads encrypted items to the PDS as AT Protocol records.
+
+Creates and encrypts memos for storage. Manages public key selection, encrypts
+plaintext content, and uploads encrypted memos to the PDS as AT Protocol
+records.
 
 ### `@cistern/consumer`
-Retrieves, decrypts, and deletes items. Generates keypairs, manages private keys locally, retrieves items via polling or real-time streaming (Jetstream), and handles item deletion after consumption.
+
+Retrieves, decrypts, and deletes memos. Generates keypairs, manages private keys
+locally, retrieves memos via polling or real-time streaming (Jetstream), and
+handles memo deletion after consumption.
 
 ## Security Model
 
-Private keys never leave the consumer device. Public keys are stored in the PDS as records, while private keys remain off-protocol. Only the holder of the matching private key can decrypt items encrypted with the corresponding public key.
+Private keys never leave the consumer device. Public keys are stored in the PDS
+as records, while private keys remain off-protocol. Only the holder of the
+matching private key can decrypt memos encrypted with the corresponding public
+key.
 
 ## Testing
 
 Run all unit tests:
+
 ```bash
 deno test --allow-env
 ```
 
 Run end-to-end tests (requires AT Protocol credentials):
+
 ```bash
 CISTERN_HANDLE="your.bsky.social" \
 CISTERN_APP_PASSWORD="xxxx-xxxx-xxxx-xxxx" \

e2e.test.ts

···
     let consumer: Awaited<ReturnType<typeof createConsumer>>;
     let producer: Awaited<ReturnType<typeof createProducer>>;
     let keypair: Awaited<ReturnType<typeof consumer.generateKeyPair>>;
-    let itemUri: string;
+    let memoUri: string;
     let testMessage: string;
 
     await t.step("Create consumer", async () => {
···
 
       expect(keypair.privateKey).toBeInstanceOf(Uint8Array);
       expect(keypair.publicKey).toBeDefined();
-      expect(keypair.publicKey).toContain("app.cistern.lexicon.pubkey");
+      expect(keypair.publicKey).toContain("app.cistern.pubkey");
     });
 
     try {
···
         expect(producer.publicKey?.uri).toEqual(keypair.publicKey);
       });
 
-      await t.step("Create encrypted item", async () => {
+      await t.step("Create encrypted memo", async () => {
         testMessage = `E2E Test - ${new Date().toISOString()}`;
-        itemUri = await producer.createItem(testMessage);
+        memoUri = await producer.createMemo(testMessage);
 
-        expect(itemUri).toBeDefined();
-        expect(itemUri).toContain("app.cistern.lexicon.item");
+        expect(memoUri).toBeDefined();
+        expect(memoUri).toContain("app.cistern.memo");
       });
 
-      await t.step("List and decrypt items", async () => {
-        const items = [];
-        for await (const item of consumer.listItems()) {
-          items.push(item);
+      await t.step("List and decrypt memos", async () => {
+        const memos = [];
+        for await (const memo of consumer.listMemos()) {
+          memos.push(memo);
         }
 
-        expect(items.length).toBeGreaterThan(0);
+        expect(memos.length).toBeGreaterThan(0);
 
-        const ourItem = items.find((item) => item.text === testMessage);
-        expect(ourItem).toBeDefined();
-        expect(ourItem!.text).toEqual(testMessage);
+        const ourMemo = memos.find((memo) => memo.text === testMessage);
+        expect(ourMemo).toBeDefined();
+        expect(ourMemo!.text).toEqual(testMessage);
       });
 
-      await t.step("Delete item", async () => {
-        const itemRkey = itemUri.split("/").pop()!;
-        await consumer.deleteItem(itemRkey);
+      await t.step("Delete memo", async () => {
+        const memoRkey = memoUri.split("/").pop()!;
+        await consumer.deleteMemo(memoRkey);
 
         // Verify deletion
-        const itemsAfterDelete = [];
-        for await (const item of consumer.listItems()) {
-          itemsAfterDelete.push(item);
+        const memosAfterDelete = [];
+        for await (const memo of consumer.listMemos()) {
+          memosAfterDelete.push(memo);
         }
 
-        const deletedItem = itemsAfterDelete.find(
-          (item) => item.text === testMessage,
+        const deletedMemo = memosAfterDelete.find(
+          (memo) => memo.text === testMessage,
         );
-        expect(deletedItem).toBeUndefined();
+        expect(deletedMemo).toBeUndefined();
       });
 
       await t.step("List public keys", async () => {
···
 
         const res = await consumer.rpc.post("com.atproto.repo.deleteRecord", {
           input: {
-            collection: "app.cistern.lexicon.pubkey",
+            collection: "app.cistern.pubkey",
             repo: consumer.did,
             rkey: publicKeyRkey,
           },
···
 });
 
 Deno.test({
-  name: "E2E: Multiple items with same keypair",
+  name: "E2E: Multiple memos with same keypair",
   ignore: SKIP_E2E,
   async fn(t) {
     const handle = Deno.env.get("CISTERN_HANDLE") as Handle;
···
     let producer: Awaited<ReturnType<typeof createProducer>>;
     let keypair: Awaited<ReturnType<typeof consumer.generateKeyPair>>;
     let messages: string[];
-    let itemUris: string[];
+    let memoUris: string[];
 
     await t.step("Create consumer and generate keypair", async () => {
       consumer = await createConsumer({
···
         expect(producer.publicKey?.uri).toEqual(keypair.publicKey);
       });
 
-      await t.step("Create multiple encrypted items", async () => {
+      await t.step("Create multiple encrypted memos", async () => {
         messages = [
-          `E2E Item 1 - ${new Date().toISOString()}`,
-          `E2E Item 2 - ${new Date().toISOString()}`,
-          `E2E Item 3 - ${new Date().toISOString()}`,
+          `E2E Memo 1 - ${new Date().toISOString()}`,
+          `E2E Memo 2 - ${new Date().toISOString()}`,
+          `E2E Memo 3 - ${new Date().toISOString()}`,
         ];
 
-        itemUris = [];
+        memoUris = [];
         for (const message of messages) {
-          const uri = await producer.createItem(message);
-          itemUris.push(uri);
+          const uri = await producer.createMemo(message);
+          memoUris.push(uri);
         }
 
-        expect(itemUris).toHaveLength(3);
+        expect(memoUris).toHaveLength(3);
       });
 
-      await t.step("Decrypt all items", async () => {
-        const items = [];
-        for await (const item of consumer.listItems()) {
-          items.push(item);
+      await t.step("Decrypt all memos", async () => {
+        const memos = [];
+        for await (const memo of consumer.listMemos()) {
+          memos.push(memo);
         }
 
-        expect(items.length).toBeGreaterThanOrEqual(3);
+        expect(memos.length).toBeGreaterThanOrEqual(3);
 
         // Verify all test messages are present
         for (const message of messages) {
-          const item = items.find((i) => i.text === message);
-          expect(item).toBeDefined();
-          expect(item!.text).toEqual(message);
+          const memo = memos.find((m) => m.text === message);
+          expect(memo).toBeDefined();
+          expect(memo!.text).toEqual(message);
         }
       });
 
-      await t.step("Cleanup: Delete test items", async () => {
-        for (const uri of itemUris) {
+      await t.step("Cleanup: Delete test memos", async () => {
+        for (const uri of memoUris) {
           const rkey = uri.split("/").pop()!;
-          await consumer.deleteItem(rkey);
+          await consumer.deleteMemo(rkey);
         }
 
-        // Verify all items deleted
-        const remainingItems = [];
-        for await (const item of consumer.listItems()) {
-          remainingItems.push(item);
+        // Verify all memos deleted
+        const remainingMemos = [];
+        for await (const memo of consumer.listMemos()) {
+          remainingMemos.push(memo);
         }
 
         for (const message of messages) {
-          const item = remainingItems.find((i) => i.text === message);
-          expect(item).toBeUndefined();
+          const memo = remainingMemos.find((m) => m.text === message);
+          expect(memo).toBeUndefined();
         }
       });
     } finally {
···
 
         const res = await consumer.rpc.post("com.atproto.repo.deleteRecord", {
           input: {
-            collection: "app.cistern.lexicon.pubkey",
+            collection: "app.cistern.pubkey",
             repo: consumer.did,
             rkey: publicKeyRkey,
           },

packages/consumer/README.md

···
 # @cistern/consumer
 
-Consumer client for retrieving, decrypting, and deleting Cistern items.
+Consumer client for retrieving, decrypting, and deleting Cistern memos.
 
 ## Usage
 
···
   handle: "user.bsky.social",
   appPassword: "xxxx-xxxx-xxxx-xxxx",
   keypair: {
-    publicKey: "at://did:plc:abc123/app.cistern.lexicon.pubkey/3jzfcijpj2z",
+    publicKey: "at://did:plc:abc123/app.cistern.pubkey/3jzfcijpj2z",
     privateKey: "base64-encoded-private-key",
   },
 });
 ```
 
-### List Items (Polling)
+### List Memos (Polling)
 
 ```typescript
-for await (const item of consumer.listItems()) {
-  console.log(`[${item.tid}] ${item.text}`);
-  await consumer.deleteItem(item.tid);
+for await (const memo of consumer.listMemos()) {
+  console.log(`[${memo.tid}] ${memo.text}`);
+  await consumer.deleteMemo(memo.tid);
 }
 ```
 
-### Subscribe to Items (Real-time)
+### Subscribe to Memos (Real-time)
 
 ```typescript
-for await (const item of consumer.subscribeToItems()) {
-  console.log(`[${item.tid}] ${item.text}`);
-  await consumer.deleteItem(item.tid);
+for await (const memo of consumer.subscribeToMemos()) {
+  console.log(`[${memo.tid}] ${memo.text}`);
+  await consumer.deleteMemo(memo.tid);
 }
 ```

packages/consumer/mod.test.ts

···
 import type { Client, CredentialManager } from "@atcute/client";
 import type { Did, Handle, ResourceUri } from "@atcute/lexicons";
 import { now } from "@atcute/tid";
-import type { AppCisternLexiconItem } from "@cistern/lexicon";
+import type { AppCisternMemo } from "@cistern/lexicon";
 
 // Helper to create a mock Consumer instance
 function createMockConsumer(
···
   fn() {
     const mockKeypair = {
       privateKey: new Uint8Array(32).toBase64(),
-      publicKey:
-        "at://did:plc:test/app.cistern.lexicon.pubkey/abc123" as ResourceUri,
+      publicKey: "at://did:plc:test/app.cistern.pubkey/abc123" as ResourceUri,
     };
 
     const consumer = createMockConsumer({
···
           return Promise.resolve({
             ok: true,
             data: {
-              uri: "at://did:plc:test/app.cistern.lexicon.pubkey/generated123",
+              uri: "at://did:plc:test/app.cistern.pubkey/generated123",
             },
           });
         }
···
     expect(keypair).toBeDefined();
     expect(keypair.privateKey).toBeInstanceOf(Uint8Array);
     expect(keypair.publicKey).toEqual(
-      "at://did:plc:test/app.cistern.lexicon.pubkey/generated123",
+      "at://did:plc:test/app.cistern.pubkey/generated123",
     );
     expect(consumer.keypair).toEqual(keypair);
 
-    expect(capturedCollection).toEqual("app.cistern.lexicon.pubkey");
+    expect(capturedCollection).toEqual("app.cistern.pubkey");
     expect(capturedRecord).toMatchObject({
-      $type: "app.cistern.lexicon.pubkey",
+      $type: "app.cistern.pubkey",
       algorithm: "x_wing",
     });
   },
···
         keypair: {
           privateKey: new Uint8Array(32).toBase64(),
           publicKey:
-            "at://did:plc:test/app.cistern.lexicon.pubkey/existing" as ResourceUri,
+            "at://did:plc:test/app.cistern.pubkey/existing" as ResourceUri,
         },
       },
     });
···
 });
 
 Deno.test({
-  name: "listItems throws when no keypair is set",
+  name: "listMemos throws when no keypair is set",
   async fn() {
     const consumer = createMockConsumer();
 
-    const iterator = consumer.listItems();
+    const iterator = consumer.listMemos();
     await expect(iterator.next()).rejects.toThrow(
-      "no key pair set; generate a key before listing items",
+      "no key pair set; generate a key before listing memos",
     );
   },
 });
 
 Deno.test({
-  name: "listItems decrypts and yields items",
+  name: "listMemos decrypts and yields memos",
   async fn() {
     const keys = generateKeys();
-    const testText = "Test item content";
+    const testText = "Test memo content";
     const encrypted = encryptText(keys.publicKey, testText);
     const testTid = now();
 
···
             data: {
               records: [
                 {
-                  uri: "at://did:plc:test/app.cistern.lexicon.item/item1",
+                  uri: "at://did:plc:test/app.cistern.memo/memo1",
                   value: {
-                    $type: "app.cistern.lexicon.item",
+                    $type: "app.cistern.memo",
                     tid: testTid,
                     ciphertext: { $bytes: encrypted.cipherText },
                     nonce: { $bytes: encrypted.nonce },
                     algorithm: "x_wing-xchacha20_poly1305-sha3_512",
-                    pubkey: "at://did:plc:test/app.cistern.lexicon.pubkey/key1",
+                    pubkey: "at://did:plc:test/app.cistern.pubkey/key1",
                     payload: { $bytes: encrypted.content },
                     contentLength: encrypted.length,
                     contentHash: { $bytes: encrypted.hash },
-                  } as AppCisternLexiconItem.Main,
+                  } as AppCisternMemo.Main,
                 },
               ],
               cursor: undefined,
···
         appPassword: "test-password",
         keypair: {
           privateKey: keys.secretKey.toBase64(),
-          publicKey:
-            "at://did:plc:test/app.cistern.lexicon.pubkey/key1" as ResourceUri,
+          publicKey: "at://did:plc:test/app.cistern.pubkey/key1" as ResourceUri,
         },
       },
     });
 
-    const items = [];
-    for await (const item of consumer.listItems()) {
-      items.push(item);
+    const memos = [];
+    for await (const memo of consumer.listMemos()) {
+      memos.push(memo);
     }
 
-    expect(items).toHaveLength(1);
-    expect(items[0].text).toEqual(testText);
-    expect(items[0].tid).toEqual(testTid);
+    expect(memos).toHaveLength(1);
+    expect(memos[0].text).toEqual(testText);
+    expect(memos[0].tid).toEqual(testTid);
   },
 });
 
 Deno.test({
-  name: "listItems skips items with mismatched public key",
+  name: "listmemos skips memos with mismatched public key",
   async fn() {
     const keys = generateKeys();
-    const testText = "Test item content";
+    const testText = "Test memo content";
     const encrypted = encryptText(keys.publicKey, testText);
     const testTid = now();
 
···
             data: {
               records: [
                 {
-                  uri: "at://did:plc:test/app.cistern.lexicon.item/item1",
+                  uri: "at://did:plc:test/app.cistern.memo/memo1",
                   value: {
-                    $type: "app.cistern.lexicon.item",
+                    $type: "app.cistern.memo",
                     tid: testTid,
                     ciphertext: { $bytes: encrypted.cipherText },
                     nonce: { $bytes: encrypted.nonce },
                     algorithm: "x_wing-xchacha20_poly1305-sha3_512",
                     pubkey:
-                      "at://did:plc:test/app.cistern.lexicon.pubkey/different-key",
+                      "at://did:plc:test/app.cistern.pubkey/different-key",
                     payload: { $bytes: encrypted.content },
                     contentLength: encrypted.length,
                     contentHash: { $bytes: encrypted.hash },
-                  } as AppCisternLexiconItem.Main,
+                  } as AppCisternMemo.Main,
                 },
               ],
               cursor: undefined,
···
         keypair: {
           privateKey: keys.secretKey.toBase64(),
           publicKey:
-            "at://did:plc:test/app.cistern.lexicon.pubkey/my-key" as ResourceUri,
+            "at://did:plc:test/app.cistern.pubkey/my-key" as ResourceUri,
         },
       },
     });
 
-    const items = [];
-    for await (const item of consumer.listItems()) {
-      items.push(item);
+    const memos = [];
+    for await (const memo of consumer.listMemos()) {
+      memos.push(memo);
     }
 
-    expect(items).toHaveLength(0);
+    expect(memos).toHaveLength(0);
   },
 });
 
 Deno.test({
-  name: "listItems handles pagination",
+  name: "listMemos handles pagination",
   async fn() {
     const keys = generateKeys();
-    const text1 = "First item";
-    const text2 = "Second item";
+    const text1 = "First memo";
+    const text2 = "Second memo";
     const encrypted1 = encryptText(keys.publicKey, text1);
     const encrypted2 = encryptText(keys.publicKey, text2);
     const tid1 = now();
···
               data: {
                 records: [
                   {
-                    uri: "at://did:plc:test/app.cistern.lexicon.item/item1",
+                    uri: "at://did:plc:test/app.cistern.memo/memo1",
                     value: {
-                      $type: "app.cistern.lexicon.item",
+                      $type: "app.cistern.memo",
                       tid: tid1,
                       ciphertext: { $bytes: encrypted1.cipherText },
                       nonce: { $bytes: encrypted1.nonce },
                       algorithm: "x_wing-xchacha20_poly1305-sha3_512",
-                      pubkey:
-                        "at://did:plc:test/app.cistern.lexicon.pubkey/key1",
+                      pubkey: "at://did:plc:test/app.cistern.pubkey/key1",
                       payload: { $bytes: encrypted1.content },
                       contentLength: encrypted1.length,
                       contentHash: { $bytes: encrypted1.hash },
-                    } as AppCisternLexiconItem.Main,
+                    } as AppCisternMemo.Main,
                   },
                 ],
                 cursor: "next-page",
···
               data: {
                 records: [
                   {
-                    uri: "at://did:plc:test/app.cistern.lexicon.item/item2",
+                    uri: "at://did:plc:test/app.cistern.memo/memo2",
                     value: {
-                      $type: "app.cistern.lexicon.item",
+                      $type: "app.cistern.memo",
                       tid: tid2,
                       ciphertext: { $bytes: encrypted2.cipherText },
                       nonce: { $bytes: encrypted2.nonce },
                       algorithm: "x_wing-xchacha20_poly1305-sha3_512",
-                      pubkey:
-                        "at://did:plc:test/app.cistern.lexicon.pubkey/key1",
+                      pubkey: "at://did:plc:test/app.cistern.pubkey/key1",
                       payload: { $bytes: encrypted2.content },
                       contentLength: encrypted2.length,
                       contentHash: { $bytes: encrypted2.hash },
-                    } as AppCisternLexiconItem.Main,
+                    } as AppCisternMemo.Main,
                   },
                 ],
                 cursor: undefined,
···
         appPassword: "test-password",
         keypair: {
           privateKey: keys.secretKey.toBase64(),
-          publicKey:
-            "at://did:plc:test/app.cistern.lexicon.pubkey/key1" as ResourceUri,
+          publicKey: "at://did:plc:test/app.cistern.pubkey/key1" as ResourceUri,
         },
       },
     });
 
-    const items = [];
-    for await (const item of consumer.listItems()) {
-      items.push(item);
+    const memos = [];
+    for await (const memo of consumer.listMemos()) {
+      memos.push(memo);
     }
 
-    expect(items).toHaveLength(2);
-    expect(items[0].text).toEqual(text1);
-    expect(items[1].text).toEqual(text2);
+    expect(memos).toHaveLength(2);
+    expect(memos[0].text).toEqual(text1);
+    expect(memos[1].text).toEqual(text2);
     expect(callCount).toEqual(2);
   },
 });
 
 Deno.test({
-  name: "listItems throws when list request fails",
+  name: "listMemos throws when list request fails",
   async fn() {
     const mockRpc = {
       get: () =>
···
         appPassword: "test-password",
         keypair: {
           privateKey: new Uint8Array(32).toBase64(),
-          publicKey: "at://did:plc:test/app.cistern.lexicon.pubkey/key1",
+          publicKey: "at://did:plc:test/app.cistern.pubkey/key1",
         },
       },
     });
 
-    const iterator = consumer.listItems();
-    await expect(iterator.next()).rejects.toThrow("failed to list items");
+    const iterator = consumer.listMemos();
+    await expect(iterator.next()).rejects.toThrow("failed to list memos");
   },
 });
 
 Deno.test({
-  name: "subscribeToItems throws when no keypair is set",
+  name: "subscribeToMemos throws when no keypair is set",
   async fn() {
     const consumer = createMockConsumer();
 
-    const iterator = consumer.subscribeToItems();
+    const iterator = consumer.subscribeToMemos();
     await expect(iterator.next()).rejects.toThrow(
       "no key pair set; generate a key before subscribing",
     );
···
 });
 
 Deno.test({
-  name: "deleteItem successfully deletes an item",
+  name: "deleteMemo successfully deletes a memo",
   async fn() {
     let deletedRkey: string | undefined;
 
···
 
     const consumer = createMockConsumer({ rpc: mockRpc });
 
-    await consumer.deleteItem("item123");
+    await consumer.deleteMemo("memo123");
 
-    expect(deletedRkey).toEqual("item123");
+    expect(deletedRkey).toEqual("memo123");
   },
 });
 
 Deno.test({
-  name: "deleteItem throws when delete request fails",
+  name: "deleteMemo throws when delete request fails",
   async fn() {
     const mockRpc = {
       post: () =>
···
 
     const consumer = createMockConsumer({ rpc: mockRpc });
 
-    await expect(consumer.deleteItem("item123")).rejects.toThrow(
-      "failed to delete item item123",
+    await expect(consumer.deleteMemo("memo123")).rejects.toThrow(
+      "failed to delete memo memo123",
     );
   },
 });

packages/consumer/mod.ts

···
 import { JetstreamSubscription } from "@atcute/jetstream";
 import type { Did } from "@atcute/lexicons/syntax";
 import type { Client, CredentialManager } from "@atcute/client";
-import {
-  AppCisternLexiconItem,
-  type AppCisternLexiconPubkey,
-} from "@cistern/lexicon";
+import { AppCisternMemo, type AppCisternPubkey } from "@cistern/lexicon";
 import type {
   ConsumerOptions,
   ConsumerParams,
-  DecryptedItem,
+  DecryptedMemo,
   LocalKeyPair,
 } from "./types.ts";
 
···
 }
 
 /**
- * Client for generating keys and decoding Cistern items.
+ * Client for generating keys and decoding Cistern memos.
  */
 export class Consumer {
   did: Did;
···
     const keys = generateKeys();
     const name = await generateRandomName();
 
-    const record: AppCisternLexiconPubkey.Main = {
-      $type: "app.cistern.lexicon.pubkey",
+    const record: AppCisternPubkey.Main = {
+      $type: "app.cistern.pubkey",
       name,
       algorithm: "x_wing",
       content: { $bytes: keys.publicKey.toBase64() },
···
     };
     const res = await this.rpc.post("com.atproto.repo.createRecord", {
       input: {
-        collection: "app.cistern.lexicon.pubkey",
+        collection: "app.cistern.pubkey",
         repo: this.did,
         record,
       },
···
   }
 
   /**
-   * Asynchronously iterate through items in the user's PDS
+   * Asynchronously iterate through memos in the user's PDS
    */
-  async *listItems(): AsyncGenerator<
-    DecryptedItem,
+  async *listMemos(): AsyncGenerator<
+    DecryptedMemo,
     void,
     undefined
   > {
     if (!this.keypair) {
-      throw new Error("no key pair set; generate a key before listing items");
+      throw new Error("no key pair set; generate a key before listing memos");
     }
 
     let cursor: string | undefined;
···
     while (true) {
       const res = await this.rpc.get("com.atproto.repo.listRecords", {
         params: {
-          collection: "app.cistern.lexicon.item",
+          collection: "app.cistern.memo",
           repo: this.did,
           cursor,
         },
···
 
       if (!res.ok) {
         throw new Error(
-          `failed to list items: ${res.status} ${res.data.error}`,
+          `failed to list memos: ${res.status} ${res.data.error}`,
         );
       }
 
       cursor = res.data.cursor;
 
       for (const record of res.data.records) {
-        const item = parse(AppCisternLexiconItem.mainSchema, record.value);
+        const memo = parse(AppCisternMemo.mainSchema, record.value);
 
-        if (item.pubkey !== this.keypair.publicKey) continue;
+        if (memo.pubkey !== this.keypair.publicKey) continue;
 
         const decrypted = decryptText(this.keypair.privateKey, {
-          nonce: item.nonce.$bytes,
-          cipherText: item.ciphertext.$bytes,
-          content: item.payload.$bytes,
-          hash: item.contentHash.$bytes,
-          length: item.contentLength,
+          nonce: memo.nonce.$bytes,
+          cipherText: memo.ciphertext.$bytes,
+          content: memo.payload.$bytes,
+          hash: memo.contentHash.$bytes,
+          length: memo.contentLength,
         });
 
         yield {
-          tid: item.tid,
+          tid: memo.tid,
           text: decrypted,
         };
       }
···
   }
 
   /**
-   * Subscribes to the Jetstreams for the user's items. Pass `"stop"` into `subscription.next(...)` to cancel
+   * Subscribes to the Jetstreams for the user's memos. Pass `"stop"` into `subscription.next(...)` to cancel
    * @todo Allow specifying Jetstream endpoint
    */
-  async *subscribeToItems(): AsyncGenerator<
-    DecryptedItem,
+  async *subscribeToMemos(): AsyncGenerator<
+    DecryptedMemo,
     void,
     "stop" | undefined
   > {
···
 
     const subscription = new JetstreamSubscription({
       url: "wss://jetstream2.us-east.bsky.network",
-      wantedCollections: ["app.cistern.lexicon.item"],
+      wantedCollections: ["app.cistern.memo"],
       wantedDids: [this.did],
     });
 
···
       if (event.kind === "commit" && event.commit.operation === "create") {
         const record = event.commit.record;
 
-        if (!is(AppCisternLexiconItem.mainSchema, record)) {
+        if (!is(AppCisternMemo.mainSchema, record)) {
           continue;
         }
 
···
   }
 
   /**
-   * Deletes an item from the user's PDS by record key.
+   * Deletes a memo from the user's PDS by record key.
    */
-  async deleteItem(key: RecordKey) {
+  async deleteMemo(key: RecordKey) {
     const res = await this.rpc.post("com.atproto.repo.deleteRecord", {
       input: {
-        collection: "app.cistern.lexicon.item",
+        collection: "app.cistern.memo",
         repo: this.did,
         rkey: key,
       },
···
 
     if (!res.ok) {
       throw new Error(
-        `failed to delete item ${key}: ${res.status} ${res.data.error}`,
+        `failed to delete memo ${key}: ${res.status} ${res.data.error}`,
       );
     }
   }

packages/consumer/types.ts

···
 
 export type ConsumerParams = ClientRequirements<ConsumerOptions>;
 
-export interface DecryptedItem {
+export interface DecryptedMemo {
   tid: Tid;
   text: string;
 }

packages/lexicon/README.md

···
 
 ## Record Types
 
-| Collection | Description |
-|------------|-------------|
-| `app.cistern.lexicon.pubkey` | Public key records with human-readable names, referenced by items via AT-URI |
-| `app.cistern.lexicon.item` | Encrypted item records containing ciphertext, nonce, algorithm metadata, and public key reference |
+| Collection           | Description                                                                                       |
+| -------------------- | ------------------------------------------------------------------------------------------------- |
+| `app.cistern.pubkey` | Public key records with human-readable names, referenced by memos via AT-URI                      |
+| `app.cistern.memo`   | Encrypted memo records containing ciphertext, nonce, algorithm metadata, and public key reference |

packages/lexicon/lexicons/app/cistern/lexicon/item.json packages/lexicon/lexicons/app/cistern/memo.json

···
 {
   "lexicon": 1,
-  "id": "app.cistern.lexicon.item",
+  "id": "app.cistern.memo",
   "description": "An encrypted memo intended to be accessed and deleted later.",
   "defs": {
     "main": {
···
         "properties": {
           "tid": {
             "type": "string",
-            "description": "TID representing when this item was created",
+            "description": "TID representing when this memo was created",
             "format": "tid"
           },
           "ciphertext": {
···
           },
           "pubkey": {
             "type": "string",
-            "description": "URI to the public key used to encrypt this item",
+            "description": "URI to the public key used to encrypt this memo",
             "format": "at-uri"
           },
           "payload": {
             "type": "bytes",
-            "description": "Encrypted item contents"
+            "description": "Encrypted memo contents"
           },
           "contentLength": {
             "type": "integer",

packages/lexicon/lexicons/app/cistern/lexicon/pubkey.json packages/lexicon/lexicons/app/cistern/pubkey.json

···
 {
   "lexicon": 1,
-  "id": "app.cistern.lexicon.pubkey",
-  "description": "A public key used to encrypt Cistern items",
+  "id": "app.cistern.pubkey",
+  "description": "A public key used to encrypt Cistern memos",
   "defs": {
     "main": {
       "type": "record",
-      "description": "A public key used to encrypt Cistern items",
+      "description": "A public key used to encrypt Cistern memos",
       "record": {
         "type": "object",
         "required": ["name", "algorithm", "content", "createdAt"],

packages/lexicon/src/index.ts

···
-export * as AppCisternLexiconItem from "./types/app/cistern/lexicon/item.ts";
-export * as AppCisternLexiconPubkey from "./types/app/cistern/lexicon/pubkey.ts";
+export * as AppCisternMemo from "./types/app/cistern/memo.ts";
+export * as AppCisternPubkey from "./types/app/cistern/pubkey.ts";

packages/lexicon/src/types/app/cistern/lexicon/item.ts packages/lexicon/src/types/app/cistern/memo.ts

···
 const _mainSchema = /*#__PURE__*/ v.record(
   /*#__PURE__*/ v.string(),
   /*#__PURE__*/ v.object({
-    $type: /*#__PURE__*/ v.literal("app.cistern.lexicon.item"),
+    $type: /*#__PURE__*/ v.literal("app.cistern.memo"),
     /**
      * Algorithm used for encryption, in <kem>-<cipher>-<hash> format.
      */
···
      */
     nonce: /*#__PURE__*/ v.bytes(),
     /**
-     * Encrypted item contents
+     * Encrypted memo contents
      */
     payload: /*#__PURE__*/ v.bytes(),
     /**
-     * URI to the public key used to encrypt this item
+     * URI to the public key used to encrypt this memo
      */
     pubkey: /*#__PURE__*/ v.resourceUriString(),
     /**
-     * TID representing when this item was created
+     * TID representing when this memo was created
      */
     tid: /*#__PURE__*/ v.tidString(),
   }),
···
 
 declare module "@atcute/lexicons/ambient" {
   interface Records {
-    "app.cistern.lexicon.item": mainSchema;
+    "app.cistern.memo": mainSchema;
   }
 }

packages/lexicon/src/types/app/cistern/lexicon/pubkey.ts packages/lexicon/src/types/app/cistern/pubkey.ts

···
 const _mainSchema = /*#__PURE__*/ v.record(
   /*#__PURE__*/ v.string(),
   /*#__PURE__*/ v.object({
-    $type: /*#__PURE__*/ v.literal("app.cistern.lexicon.pubkey"),
+    $type: /*#__PURE__*/ v.literal("app.cistern.pubkey"),
     /**
      * KEM algorithm used to generate this key
      */
···
 
 declare module "@atcute/lexicons/ambient" {
   interface Records {
-    "app.cistern.lexicon.pubkey": mainSchema;
+    "app.cistern.pubkey": mainSchema;
   }
 }

packages/producer/README.md

···
 # @cistern/producer
 
-Producer client for creating and encrypting Cistern items.
+Producer client for creating and encrypting Cistern memos.
 
 ## Usage
 
···
 
 producer.selectPublicKey(pubkey);
 
-const itemUri = await producer.createItem("Hello, world!");
+const memoUri = await producer.createMemo("Hello, world!");
 ```
 
 Or, if you already have a public key record ID:
···
   publicKey: "3jzfcijpj2z",
 });
 
-const itemUri = await producer.createItem("Hello, world!");
+const memoUri = await producer.createMemo("Hello, world!");
 ```

packages/producer/mod.test.ts

···
 import type { ProducerParams, PublicKeyOption } from "./types.ts";
 import type { Client, CredentialManager } from "@atcute/client";
 import type { Did, Handle, ResourceUri } from "@atcute/lexicons";
-import type { AppCisternLexiconPubkey } from "@cistern/lexicon";
+import type { AppCisternPubkey } from "@cistern/lexicon";
 
 // Helper to create a mock Producer instance
 function createMockProducer(
···
   name: "Producer constructor initializes with existing public key",
   fn() {
     const mockPublicKey: PublicKeyOption = {
-      uri: "at://did:plc:test/app.cistern.lexicon.pubkey/key1" as ResourceUri,
+      uri: "at://did:plc:test/app.cistern.pubkey/key1" as ResourceUri,
       name: "Test Key",
       content: new Uint8Array(32).toBase64(),
     };
···
 });
 
 Deno.test({
-  name: "createItem successfully creates and uploads an encrypted item",
+  name: "createMemo successfully creates and uploads an encrypted memo",
   async fn() {
     const keys = generateKeys();
     let capturedRecord: unknown;
···
           return Promise.resolve({
             ok: true,
             data: {
-              uri:
-                "at://did:plc:test/app.cistern.lexicon.item/item123" as ResourceUri,
+              uri: "at://did:plc:test/app.cistern.memo/memo123" as ResourceUri,
             },
           });
         }
···
     const producer = createMockProducer({
       rpc: mockRpc,
       publicKey: {
-        uri: "at://did:plc:test/app.cistern.lexicon.pubkey/key1" as ResourceUri,
+        uri: "at://did:plc:test/app.cistern.pubkey/key1" as ResourceUri,
         name: "Test Key",
         content: keys.publicKey.toBase64(),
       },
     });
 
-    const uri = await producer.createItem("Test message");
+    const uri = await producer.createMemo("Test message");
 
-    expect(uri).toEqual("at://did:plc:test/app.cistern.lexicon.item/item123");
-    expect(capturedCollection).toEqual("app.cistern.lexicon.item");
+    expect(uri).toEqual("at://did:plc:test/app.cistern.memo/memo123");
+    expect(capturedCollection).toEqual("app.cistern.memo");
     expect(capturedRecord).toMatchObject({
-      $type: "app.cistern.lexicon.item",
+      $type: "app.cistern.memo",
       algorithm: "x_wing-xchacha20_poly1305-sha3_512",
     });
   },
 });
 
 Deno.test({
-  name: "createItem throws when no public key is set",
+  name: "createMemo throws when no public key is set",
   async fn() {
     const producer = createMockProducer();
 
-    await expect(producer.createItem("Test message")).rejects.toThrow(
-      "no public key set; select a public key before creating an item",
+    await expect(producer.createMemo("Test message")).rejects.toThrow(
+      "no public key set; select a public key before creating a memo",
     );
   },
 });
 
 Deno.test({
-  name: "createItem throws when upload fails",
+  name: "createMemo throws when upload fails",
   async fn() {
     const keys = generateKeys();
     const mockRpc = {
···
     const producer = createMockProducer({
       rpc: mockRpc,
       publicKey: {
-        uri: "at://did:plc:test/app.cistern.lexicon.pubkey/key1" as ResourceUri,
+        uri: "at://did:plc:test/app.cistern.pubkey/key1" as ResourceUri,
         name: "Test Key",
         content: keys.publicKey.toBase64(),
       },
     });
 
-    await expect(producer.createItem("Test message")).rejects.toThrow(
-      "failed to create new item",
+    await expect(producer.createMemo("Test message")).rejects.toThrow(
+      "failed to create new memo",
     );
   },
 });
···
             data: {
               records: [
                 {
-                  uri: "at://did:plc:test/app.cistern.lexicon.pubkey/key1",
+                  uri: "at://did:plc:test/app.cistern.pubkey/key1",
                   value: {
-                    $type: "app.cistern.lexicon.pubkey",
+                    $type: "app.cistern.pubkey",
                     name: "Key 1",
                     algorithm: "x_wing",
                     content: { $bytes: new Uint8Array(32).toBase64() },
                     createdAt: new Date().toISOString(),
-                  } as AppCisternLexiconPubkey.Main,
+                  } as AppCisternPubkey.Main,
                 },
                 {
-                  uri: "at://did:plc:test/app.cistern.lexicon.pubkey/key2",
+                  uri: "at://did:plc:test/app.cistern.pubkey/key2",
                   value: {
-                    $type: "app.cistern.lexicon.pubkey",
+                    $type: "app.cistern.pubkey",
                     name: "Key 2",
                     algorithm: "x_wing",
                     content: { $bytes: new Uint8Array(32).toBase64() },
                     createdAt: new Date().toISOString(),
-                  } as AppCisternLexiconPubkey.Main,
+                  } as AppCisternPubkey.Main,
                 },
               ],
               cursor: undefined,
···
               data: {
                 records: [
                   {
-                    uri: "at://did:plc:test/app.cistern.lexicon.pubkey/key1",
+                    uri: "at://did:plc:test/app.cistern.pubkey/key1",
                     value: {
-                      $type: "app.cistern.lexicon.pubkey",
+                      $type: "app.cistern.pubkey",
                       name: "Key 1",
                       algorithm: "x_wing",
                       content: { $bytes: new Uint8Array(32).toBase64() },
                       createdAt: new Date().toISOString(),
-                    } as AppCisternLexiconPubkey.Main,
+                    } as AppCisternPubkey.Main,
                   },
                 ],
                 cursor: "next-page",
···
               data: {
                 records: [
                   {
-                    uri: "at://did:plc:test/app.cistern.lexicon.pubkey/key2",
+                    uri: "at://did:plc:test/app.cistern.pubkey/key2",
                     value: {
-                      $type: "app.cistern.lexicon.pubkey",
+                      $type: "app.cistern.pubkey",
                       name: "Key 2",
                       algorithm: "x_wing",
                       content: { $bytes: new Uint8Array(32).toBase64() },
                       createdAt: new Date().toISOString(),
-                    } as AppCisternLexiconPubkey.Main,
+                    } as AppCisternPubkey.Main,
                   },
                 ],
                 cursor: undefined,
···
     const producer = createMockProducer();
 
     const mockPublicKey: PublicKeyOption = {
-      uri: "at://did:plc:test/app.cistern.lexicon.pubkey/key1" as ResourceUri,
+      uri: "at://did:plc:test/app.cistern.pubkey/key1" as ResourceUri,
       name: "Selected Key",
       content: new Uint8Array(32).toBase64(),
     };
···
   fn() {
     const producer = createMockProducer({
       publicKey: {
-        uri: "at://did:plc:test/app.cistern.lexicon.pubkey/old" as ResourceUri,
+        uri: "at://did:plc:test/app.cistern.pubkey/old" as ResourceUri,
         name: "Old Key",
         content: new Uint8Array(32).toBase64(),
       },
···
     expect(producer.publicKey?.name).toEqual("Old Key");
 
     const newKey: PublicKeyOption = {
-      uri: "at://did:plc:test/app.cistern.lexicon.pubkey/new" as ResourceUri,
+      uri: "at://did:plc:test/app.cistern.pubkey/new" as ResourceUri,
       name: "New Key",
       content: new Uint8Array(32).toBase64(),
     };

packages/producer/mod.ts

···
 import { type Did, parse, type ResourceUri } from "@atcute/lexicons";
 import type { Client, CredentialManager } from "@atcute/client";
 import { now } from "@atcute/tid";
-import {
-  type AppCisternLexiconItem,
-  AppCisternLexiconPubkey,
-} from "@cistern/lexicon";
+import { type AppCisternMemo, AppCisternPubkey } from "@cistern/lexicon";
 
 import type {} from "@atcute/atproto";
 
···
       params: {
         repo: reqs.miniDoc.did,
         rkey,
-        collection: "app.cistern.lexicon.pubkey",
+        collection: "app.cistern.pubkey",
       },
     });
 
···
       );
     }
 
-    const record = parse(AppCisternLexiconPubkey.mainSchema, res.data.value);
+    const record = parse(AppCisternPubkey.mainSchema, res.data.value);
 
     publicKey = {
       uri: res.data.uri,
···
   }
 
   /**
-   * Creates an item and saves it as a record in the user's PDS
+   * Creates a memo and saves it as a record in the user's PDS
    */
-  async createItem(text: string): Promise<ResourceUri> {
+  async createMemo(text: string): Promise<ResourceUri> {
     if (!this.publicKey) {
       throw new Error(
-        "no public key set; select a public key before creating an item",
+        "no public key set; select a public key before creating a memo",
       );
     }
 
···
       Uint8Array.fromBase64(this.publicKey.content),
       text,
     );
-    const record: AppCisternLexiconItem.Main = {
-      $type: "app.cistern.lexicon.item",
+    const record: AppCisternMemo.Main = {
+      $type: "app.cistern.memo",
       tid: now(),
       algorithm: "x_wing-xchacha20_poly1305-sha3_512",
       ciphertext: { $bytes: payload.cipherText },
···
 
     const res = await this.rpc.post("com.atproto.repo.createRecord", {
       input: {
-        collection: "app.cistern.lexicon.item",
+        collection: "app.cistern.memo",
         repo: this.did,
         record,
       },
···
 
     if (!res.ok) {
       throw new Error(
-        `failed to create new item: ${res.status} ${res.data.error}`,
+        `failed to create new memo: ${res.status} ${res.data.error}`,
       );
     }
 
···
     while (true) {
       const res = await this.rpc.get("com.atproto.repo.listRecords", {
         params: {
-          collection: "app.cistern.lexicon.pubkey",
+          collection: "app.cistern.pubkey",
           repo: this.did,
           cursor,
         },
···
       cursor = res.data.cursor;
 
       for (const record of res.data.records) {
-        const item = parse(AppCisternLexiconPubkey.mainSchema, record.value);
+        const memo = parse(AppCisternPubkey.mainSchema, record.value);
 
         yield {
           uri: record.uri,
-          content: item.content.$bytes,
-          name: item.name,
+          content: memo.content.$bytes,
+          name: memo.name,
         };
       }