Start with AI

# .env — you fill in the value
CHAT_ACCOUNT_KEY=ck_...

# .env — the AI fills these in when it creates the app
VITE_CHAT_PK=pk_...
CHAT_SECRET_KEY=sk_...

Read https://chat.gravex.app/en/llms.txt, create an app with the CHAT_ACCOUNT_KEY in .env, fill pk_/sk_ into .env, then add a lobby chat to my project.

- The allowed origin is my frontend dev server's address (Vite's default is http://localhost:5173). If the port is different, or it is taken and the server starts on another port, use the address it actually runs on. If the address changes later, fix it with PATCH /api/apps/{id}/keys/{keyId} — it replaces the whole origin list, so send the existing values too.
- Create the app with POST /api/apps, exactly as the Console API guide (https://chat.gravex.app/en/docs/console-api) says. Write publishableKey.value to VITE_CHAT_PK and secretKey.value to CHAT_SECRET_KEY in the file right away. The sk_ is shown only in that response, so don't print it to the screen, a log or the chat.
- Read CHAT_ACCOUNT_KEY only in the script that creates the app. Never put it in app code or in the frontend bundle. Expose only VITE_CHAT_PK to the frontend and don't widen Vite's envPrefix. Also check that .env is in .gitignore.
- Look at my project's framework and login method first and add a simple chat (one lobby room) that fits them. If I have no project, build the simplest React (Vite) + Express one.
- Backend: an endpoint that issues chat tokens, and creating the room 'lobby' (get-or-create). If there is login, issue tokens to signed-in users with chat.token(); if there is none, issue guest identities with chat.guest() as the 'Guest users' guide says. Don't invent a demo login. Create the CHAT_GUEST_SECRET that guests need in .env as a random value of at least 32 characters.
- Frontend: connect with the @kispi/chat SDK, show the message list and an input box, and send messages
- When you're done, tell me the result of checking each item of the 'UI checklist' in llms.txt, how to check it locally, and how to revoke the CHAT_ACCOUNT_KEY now that you're finished with it (the app and its pk_/sk_ keep working after that).

In the chat above, let both signed-in members and visitors who are not signed in talk.
Follow the 'Guest users' approach in the docs: issue guest identities with chat.guest(), and never sign an id the browser sends.
Show guest names as 'Guest-' plus a short number, and if CHAT_GUEST_SECRET is not in .env yet, create it as a random value of at least 32 characters.

Add a dedicated chat room (comment room) to each post's detail page.
Use the room key 'post-<post id>'. The backend creates the room with get-or-create and the frontend opens it with roomByKey.
Opening a post should show the latest messages, and scrolling up should load older ones (loadOlder).

Add a 'Reply' button to every message and build Slack-style threads.
- Send a thread reply with send({ text, threadId: original message id }), and show only messages without a threadId on the main timeline.
- Show the reply count (thread.count) on the original message, and open the thread in a right-hand panel when it is clicked.
- Quoting a specific message is replyTo; build it separately from threads.

Add emoji reactions to messages. Hovering a message shows an emoji picker button, and picking one calls room.react / room.unreact.
Show counts per emoji under the message and highlight the ones I pressed. Use the server's count as it comes, and handle the limit of 20 distinct emojis per message.

Add mentions and unread indicators.
- Typing @ in the input shows an autocomplete of the room's participants. Picking one sends entities with { type: 'mention', userId, offset, length }. Highlight mentions in the message body.
- In the room list (chat.rooms.list), draw unread and mention count badges per room, and call markRead when the room is viewed.
- Get the total unread count for the app icon from chat.unread().

Add typing and online indicators.
- Call room.typing() as I type (the SDK throttles it), and show 'X is typing…' from the typing event. Skip my own events and clear it when more than 5 seconds pass after the last event.
- Show the number of people currently in the room (room.presence) in the room header, and show the list when it is clicked.

Add a 'Send message' button to user profiles and build 1:1 DMs.
The backend calls rooms.ensureDM with the two user ids and returns the room id, and the frontend opens that room.
Build the DM list screen from chat.rooms.list() and show the last message and unread count.

Create an 'Announcements' room that only operators can write in while everyone else just reads. Use type: 'channel' and set my operator account as owner or admin.
Also write a backend function that sends system messages such as 'Maintenance starts in 10 minutes' to that room and the lobby (messages.send, kind: 'system').

Read https://chat.gravex.app/en/docs/uploads and add image uploads to the chat. The engine does not store files, so they go into my own S3 bucket.
- Follow the document's order: presigned POST, keep files in a private prefix before the check, and move only what passes the Rekognition check to the public prefix
- In the before_publish webhook, confirm that an attachment URL is this sender's file under my public prefix, and mask bad words with * in the same hook.
- Don't put AWS credentials in code; use an IAM role, and give me a separate list of what I have to do in the AWS console.

Create a chat webhook endpoint. Follow the 'Webhooks' document: verify the signature over the raw body, process each delivery only once, and answer 200 first, then work asynchronously.
When message.created arrives, notify the room's members other than the sender. I haven't chosen the channel (web push, FCM, email…), so ask me first, and leave a TODO where the notification goes until I decide.

Write operations scripts.
- A command that takes a user id, bans them (users.ban) and deletes all their messages (users.purgeMessages, repeated until purgeCapped is false)
- A command that downloads the whole app's data. Call GET /v1/export with the sk_, save it as an NDJSON file, and tell me the file is incomplete if the last line is not end.

Read https://chat.gravex.app/en/llms.txt and, using only the 'REST API reference' and 'Real-time protocol (WebSocket)' in the docs, build a chat client in Swift. Kotlin or Flutter (Dart) is fine instead.

- First read the checklist 'Building a client without the SDK' at the end of 'Real-time protocol' and implement its items one by one.
- Connecting (auth then hello) and ping, subscribing to a room (since), sending messages (dedup with clientMessageId), applying events
- Reconnect with exponential backoff plus jitter, and after reconnecting, fill the seq gap of each room from REST history.
- Make the user token a function that fetches it from my backend, and fetch a new one on every connect. Never put the sk_ in the app.
- When you're done, give me a table of which checklist items you did and didn't do.

Read https://chat.gravex.app/en/llms.txt and answer. Don't implement anything; just tell me whether it is possible and how. If the docs don't say, say you don't know.
1. Can members and visitors both chat?
2. Are comments or threads possible?
3. Are emoji reactions possible?
4. What about read marks or unread message counts?
5. Do you send app push notifications?
6. Can people upload photos? Where are they stored?
7. What about 1:1 chat and announcement-only rooms?
8. Can I take all my data out later?
9. Can I connect an iOS or Android app too? What if there is no official SDK?